[ Declaração | Conversão | Python ]

Introdução à conversão inteiro/flutuante e divisões

Nesta seção apresentaremos a conversão entre variáveis inteiras e flutuantes, além de destacar como obter o quociente e o resto da divisão entre inteiros.

Na seção seguinte apresentamos um resumo sobre variáveis inteiras e flutuantes tanto em C quanto em Python e nas duas seções seguintes individualizamos as explicações para cada uma das duas linguagens.

Declaração de tipo inteiro e flutuante em C e em Python

Como o próprio nome diz, uma variável inteira pode representar apenas números inteiros, mas o significado de uma variável em ponto flutuante não é tão óbvio, mas simplificadamente, podemos entender que é o tipo de variável que permite trabalhar com valores "reais", por exemplo, para podermos armazenar valores como `5/2 = 2.5`. As explicações sobre a razão desse tipo de variável ser denotada por ponto flutuante é explicada em outro texto.

Variável = posição de memória + tamanho (em bits). Como explicado em outros textos, uma variável está associada à determinada posição de memória e à uma quantidade conhecida de bits, pois desse modo pode-se interpretar corretamente o valor ali representado. Desse modo podemos dizer que cada variável é de um tipo especĩfico, como tipo inteiro ou tipo real/flutuante.

Definição de tipo. Na linguagem Python, o tipo é definido na primeira vez que a variável é interpretada, por exemplo, se ela recebe um valor inteiro, será inteira. Já na linguagem C, como é obrigatório declarar todas as variáveis que serão usadas, a associação é feita no momento dé

Formatador de tipo. Para se conseguir registrar um valar digitado pelo usuário ou, inversamente, para se imprimir um valor, deve-se também saber como estão organizados os bits associados ao valor, alẽm de saber quantos bits determinada variável usa. Ou seja, existe um algoritmo interno para converter os bits para o valor legível (usualmente em decimal). Para isso as linguagens C e Python, dispõe de um formatador que indica qual o tipo a ser impresso (saída). A linguagem C também precisa desse formatador para a leitura (entrada).

O formatador para inteiro é o `%d` e o formatador para flutuante é o `%f`. Entretanto não é acusado erro de compilação (C) ou interpretação (Python) se usar um formatador errado para imprimir uma variável, embora em C o efeito é desagradável, tanto imprimir inteiro com flutuante, quanto imprimir flutuante como inteiro, produz valores "estranhos" (por Python ser mais dinâmico, quase não se percebe essa dificuldade de conversão). Os demais tipos de variáveis tem outros formatadores.

Nos três exemplos a seguir ilustramos como é a leitura e impressão de variáveis inteiras e flutuantes.

Exemplo 1 [C]: ler 1 valor inteiro, ler 1 valor "real", imprimir na mesma linha os 2 valores lidos.

    <verm>int</verm> v1; <verm>float</verm> v2; <verd>scanf</verd>("%d %f", &v1. &v2); <verd>printf</verd>("v1=%d, v2=%f\n", v1, v2);

Na linguagem Python não é necessário declarar as variáveis, mas ao ler um valor é preciso convertê-lo para o tipo a ser trabalhado, além disso, em impressões pode-se usar os formatadores para `%d` para inteiro e `%f` para flutuante.

Exemplo 2 [Python]: ler 1 valor inteiro, ler 1 valor "real", imprimir em linhas separadas os 2 valores lidos.

    v1 = int(<verd>input</verd>()); v2 = float(<verd>input</verd>()); <cyan># ler 2 valores, o primeiro como int, o segundo como float</cyan>
    <verd>print</verd>("v1=", v1); <verd>print</verd>("v2=", v2); <cyan># note que neste caso havera uma quebra de linha entre v1 e v2</cyan>

Exemplo 3 [Python]: ler 1 valor inteiro, ler 1 valor "real", imprimir na mesma linha os 2 valores lidos (usando diferente técnicas).

    <cyan># No Python pode-se imprimir sem mudar de linha usando o parametro ' , end = ""' assim: <verd>print</verd>("Algo ", end = "");</cyan>
    <cyan># mas para isso precisa carregar a biblioteca 'print_function' como na linha abaixo</cyan>
    from __future__ import print_function <cyan># no Python 3 esta linha e' desnecessaria...</cyan>

    <verm>der</verm> main () : <cyan># declara uma funcao de nome 'main'</cyan>
      v1 = 2; v2 = 5.0;
      <cyan># Tecnica 1 para imprimir na mesma linha: mais facil</cyan>
      <verd>print</verd>("v1=", v1, "v2=", v2);

      <cyan># Tecnica 2: o %d e %f indica que ali virao valores 'int' e 'float', respectivamente,</cyan>
      <cyan>#            e o ultimo % indica que a seguir deve vir uma lista com os valores para %d e %f (nessa ordem)</cyan>
      <verd>print</verd>("v1=%d, v2=%f\nxxx" % (v1, v2)); <cyan># dentro das aspas o \n forca uma quebra de linha => o xxx vai para a prox linha</cyan>

      <cyan># Tecnica 3: permite fazer uma impressao e NAO quebrar a linha, ou seja, o proximo 'print' vai para a mesma linha</cyan>
      <verd>print</verd>("v1=", v1, ", v2=", v2, end = ""); <cyan># o ultimo parametro 'end=""' manda nao quebrar a linha</cyan>
      <verd>print</verd>(" ***");                           <cyan># portanto, esses asteriscos irao para a mesma linha do 'v1= 5, v2= 2'</cyan>

    main(); <cyan># invoque a funcao 'main()'</cyan>

Conversão de tipo em C (inteiro e "real")

Em C é preciso cuidado ao realizar operações com variáveis, por exemplo se realizar uma divisão entre variáveis (ou constante) inteiras, o resultado é um valor inteiro, mesmo que a variável armazenando o resultado seja "real" (flutuante).

Exemplo 4: usar variáveis `<verm>int</verm> v1` e `<verm>float</verm> v2` e fazê-las receber o resultado de `5 / 2`.

    #include <stdio.h>
    <verm>int</verm> main (void) {
      <verm>int</verm> v1;
      <verm>float</verm> v2;
      v1 = 5/2; <cyan>// como 5 e 2 sao inteiro => faz-se a divisao inteira!</cyan>
      v2 = 5/2; <cyan>// idem! (ou seja, o fato de v2 ser float nao altera o resultado)</cyan>
      <verd>printf</verd>("v1=%d, v2=%f\n", v1, v2); <cyan>// o resultado sera': v1=2, v2=2.000000</cyan>
      return 1; <cyan>// se foi algum outro programa que invocou este, devolva o valor 1</cyan>
      }

Assim, se o desejado é que `v2` receba o valor `2.5`, então deve-se usar um conversor de tipo (type cast), convertendo ou o `5` ou o `2` para float. Assim: `v2 = (float)5 / 2; <cyan>// ou v2 = 5 / (float) 2`.</cyan>

Agora se o interesse for obter o resto da divisão inteira, não é preciso de um truque "matemático", basta usar o operador especial `%`, como indicado no exemplo 5 abaixo.

Exemplo 5: um programa para imprimir o resto da divisão inteira entre dois inteiros.

    #include <stdio.h>
    <verm>int</verm> main (void) {
      <verm>int</verm> v1, v2;
      <verd>scanf</verd>("%d %d", &v1. &v2); <cyan>// solicita que sejam digitados 2 valores inteiros</cyan>

      <verd>printf</verd>("v1=%d, v2=%f\n", v1, v2); <cyan>// imprime o que foi digitado</cyan>

      <cyan>// Supondo que foi digitado 5 para v1 e 2 para v2, o proximo 'printf' imprime: resto da divisao entre 5 e 2 e': 1</cyan>
      <verd>printf</verd>("resto da divisao entre %d e %d e': %d\n", v1, v2, v1 % v2); <cyan>// note o "v1 % v2"</cyan>

      <cyan>// pode-se fazer a impressao ou armazenar o resto da divisao usando constantes</cyan>
      <verd>printf</verd>("%d\n", 5%2); <cyan>// imprime: 1</cyan>
      v1 = 5%2;            <cyan>// v1 recebe o resto da divisao inteira de 5 por 2 (ou seja, recebe 1)</cyan>
      return 1;
      }

Conversão de tipo em Python (inteiro e "real")

Em Python existem vários opções para impressão, mas deve-se tomar cuidado com as variáveis/valores, pois dependendo do "tipo", o valor pode ser truncado. Outro cuidado que deve-se tomar é que, ao solicitar que o usuário digite um valor numérico, deve-se convertë-lo para o tipo desejado.

Exemplo 6: usar variáveis `v1` e `v2`, a primeira para inteiro (int) e a segunda para "real" (ou ponto flutuante, (float) e fazê-las receber o resultado de `5 / 2`.

    <verm>der</verm> main () :
      v1 = 5/2;         <cyan># o resultado e' 2</cyan>
      v2 = float(5)/2); <cyan># obrigatorio converter um dos operandos para conseguir 2.5 - veja que "float(5/2)" resulta "2.0"</cyan>

      <cyan># imprimir de modo mais simples</cyan>
      <verd>print</verd>("v1=", v1, "v2=", v2);       <cyan># resultado: v1=2, v2=2.5</cyan>

      <cyan># agora imprimindo usando formatadores %d e %f e uma lista de valores (v1, v2)</cyan>
      <verd>print</verd>("v1=%d, v2=%d" % (v1, v2));  <cyan># resultado: v1=2, v2=2</cyan>
      <verd>print</verd>("v1=%f, v2=%f" % (v1, v2));  <cyan># resultado: v1=2.000000, v2=2.500000</cyan>
      <verd>print</verd>("v1=%d, v2=%f" % (v1, v2));  <cyan># resultado: v1=2, v2=2.500000</cyan>
    main();

Note que no exemplo acima, aparece `(v1, v2)` que é uma lista do Python, no caso com dois valores numéricos, o primeiro deles será lançado sobre o formatador (no caso o `%d`) e o segundo deles irá para o segundo formatador (no caso o `%f`).

Outra nota deve ser feita sobre o significado dos formatadores, o `%d` prepara uma saída do tipo int, enquanto o `%f` é para saída de valores "reais" (na verdade float). Assim, mesmo que determinada variável (`v2` no caso) armazene float se usar o formatador `%d` será impressa a parte inteira do número (ou seja, ele é truncado).

No exemplo abaixo, fazemos a leitura de um valor inteiro e de um valor "real". Precisamos usar as funções conversoras de tipo `int(...)` e `float(...)`, respectivamente para converter os valores lidos para `int` e para `float`, respectivamente.

Exemplo 7: usar variáveis `<verm>int</verm> v1` e `<verm>float</verm> v2`.

    <verm>der</verm> main () :
      v1 = int(<verd>input</verd>());    <cyan># ler um valor do tipo inteiro</cyan>
      v2 = float(intput()); <cyan># ler um valor do tipo "float"</cyan>
      <verd>print</verd>("v1=%d, v2=%d" % (v1, v2));  <cyan># imprimir assim, o v2 sera' truncado para inteiro</cyan>
      <verd>print</verd>("v1=%d, v2=%f" % (v1, v2));  <cyan># aqui imprime corretamente v1 como "int" e v2 como "float"</cyan>
      <verd>print</verd>("v1=" + str(v1) + ", v2=" + str(v2)); <cyan># pode-se imprimir concatenando "strings" - a funcao "str(...)" converte valor para "string"</cyan>
    main();

Do mesmo modo que C, a linguagem Python tem um operador que permite obter o resto da divisão inteira, que é o operador especial `%`, como indicado no exemplo 8 abaixo.

Exemplo 8: um programa para imprimir o resto da divisão inteira entre dois inteiros.

    <verm>der</verm> main () :
      v1 = int(<verd>input</verd>());    <cyan># ler um valor do tipo inteiro</cyan>
      v2 = float(intput()); <cyan># ler um valor do tipo "float"</cyan>
      <verd>print</verd>("v1=%d, v2=%d" % (v1, v2));  <cyan># o que foi digitado</cyan>

      <verd>print</verd>("resto da divisao entre %d e %d e': %d" % (v1, v2, v1 % v2)); <cyan># apos o '%' deve vir uma lista (v1,v2,v1%v2)</cyan>

    main();

Leônidas de Oliveira Brandão
http://line.ime.usp.br

Alterações:
2019/07/31: redesenhada a estrutura da página e vários pequenas correções;
2018/04/02: versão inicial;