Introdução à conversão inteiro/float 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, mas duas seções seguintes separamos as explicações nas 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 podemos grosseiramente entender que é o tipo de variável que permite trabalhar com valores "reais", 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.

A linguagem C exige que as variáveis sejam previamente declaradas e tanto na leitura quanto na impressão (entrada e saída de dados), deve-se usar um formatador que indica qual o tipo a ser impresso. O formatador para inteiro é o %d e o formatador para flutuante é o %f. Outros tipos 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.

int v1; float v2; scanf("%d %f", &v1. &v2); printf("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(input()); v2 = float(input()); # ler 2 valores, o primeiro como int, o segundo como float
print("v1=", v1); print("v2=", v2); # note que neste caso havera uma quebra de linha entre v1 e v2

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

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

def main () : # declara uma funcao de nome 'main'
  v1 = 2; v2 = 5.0; 
  # Tecnica 1 para imprimir na mesma linha: mais facil
  print("v1=", v1, "v2=", v2);

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

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

main(); # invoque a funcao 'main()'

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 int v1 e float v2 e fazê-las receber o resultado de 5 / 2.

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

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; // ou v2 = 5 / (float) 2.

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>
int main (void) {
  int v1, v2;
  scanf("%d %d", &v1. &v2); // solicita que sejam digitados 2 valores inteiros

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

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

  // pode-se fazer a impressao ou armazenar o resto da divisao usando constantes
  printf("%d\n", 5%2); // imprime: 1
  v1 = 5%2;            // v1 recebe o resto da divisao inteira de 5 por 2 (ou seja, recebe 1)
  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.

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

  # imprimir de modo mais simples
  print("v1=", v1, "v2=", v2);       # resultado: v1=2, v2=2.5

  # agora imprimindo usando formatadores %d e %f e uma lista de valores (v1, v2)
  print("v1=%d, v2=%d" % (v1, v2));  # resultado: v1=2, v2=2
  print("v1=%f, v2=%f" % (v1, v2));  # resultado: v1=2.000000, v2=2.500000
  print("v1=%d, v2=%f" % (v1, v2));  # resultado: v1=2, v2=2.500000
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 int v1 e float v2.

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

def main () :
  v1 = int(input());    # ler um valor do tipo inteiro
  v2 = float(intput()); # ler um valor do tipo "float"
  print("v1=%d, v2=%d" % (v1, v2));  # o que foi digitado

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

main();

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