Números decimais com float: o ponto no lugar da vírgula

Ponto, não vírgula: a pegadinha brasileira

No Brasil, um e setenta e cinco se escreve 1,75. Em Python, se escreve 1.75, com ponto, porque a linguagem segue a convenção americana. Essa diferença cultural seria só um detalhe chato se o erro fizesse barulho, mas ele não faz: escrever a vírgula no lugar do ponto NÃO gera mensagem de erro. O Python interpreta a vírgula como separador de valores e cria, sem avisar, um par de números. O programa continua rodando com um dado errado por dentro, que é o pior tipo de bug.

altura_certa = 1.75
print(altura_certa)

altura_errada = 1,75  # a vírgula cria um PAR (tupla), não um decimal
print(altura_errada)

# Saída:
# 1.75
# (1, 75)

A segunda saída, (1, 75), é uma tupla de dois inteiros. Nenhum erro na tela, mas o dado está errado.

Aquele (1, 75) entre parênteses é uma tupla, uma estrutura que agrupa valores e que tem aula própria no módulo 11. Por ora, o que importa é reconhecer o sintoma: se um número decimal seu aparecer entre parênteses e com vírgula na saída, a causa é quase certamente uma vírgula digitada no código onde deveria haver ponto. Grave o reflexo agora, porque ele evita horas de confusão: decimal em código Python usa ponto, sempre, mesmo que o resto da sua vida use vírgula.

O caso 0.1 + 0.2, explicado sem drama

Abra o Playground e digite print(0.1 + 0.2). A resposta não é 0.3: é 0.30000000000000004. Esse resultado assusta todo iniciante, vira piada na internet e alimenta a lenda de que o computador erra conta. A explicação é mais interessante que a lenda. O computador guarda números em binário, o sistema de uns e zeros, e nesse sistema o 0.1 é uma dízima infinita, assim como 1 dividido por 3 vira 0,333... infinito no nosso sistema decimal. Como a memória é finita, o computador guarda uma aproximação excelente, mas não exata. Somando duas aproximações, a sobra microscópica aparece lá na décima sétima casa.

print(0.1 + 0.2)
print(round(0.1 + 0.2, 2))
print(0.1 + 0.2 == 0.3)

# Saída:
# 0.30000000000000004
# 0.3
# False

A soma crua, a soma arredondada com round() e a comparação que devolve False por causa da sobra binária.

Isso não é um defeito do Python: é o comportamento do padrão de ponto flutuante usado por praticamente todos os computadores e linguagens do mundo, documentado na própria documentação oficial. E para o dia a dia, o efeito é irrelevante: um erro na décima sétima casa decimal não muda nenhum cálculo de receita, nota de prova ou conta de restaurante. A ferramenta para exibir o valor limpo é a função round(), que recebe o número e a quantidade de casas desejadas. round(0.1 + 0.2, 2) devolve 0.3, pronto para mostrar ao usuário.

Duas consequências práticas para levar. Primeira: ao exibir floats, arredonde com round() para o número de casas que faz sentido, duas para dinheiro, uma para notas. Segunda: evite comparar floats com igualdade exata, como na terceira linha do exemplo, que devolve False; quando as condições chegarem, no módulo 7, você verá jeitos melhores de comparar decimais. Sistemas bancários de verdade vão além e guardam dinheiro em centavos inteiros, exatamente para escapar do arredondamento, um truque que a aula de int já insinuou.

Int ou float: como escolher

Com os dois tipos numéricos na mão, a pergunta natural é qual usar em cada situação. O critério é o dado, não o gosto: o que se conta em unidades inteiras e não admite fração é int; o que se mede e pode ter fração é float. Quantidade de filhos, número de parcelas e itens no estoque são int, porque não existe meio filho nem 2,7 parcelas. Altura, peso, preço e temperatura são float, porque o mundo os fornece com casas decimais.

Quando os dois tipos se misturam numa conta, o Python promove o resultado para float: 2 + 1.5 dá 3.5, e até 2 + 1.0 dá 3.0. A regra é simples de lembrar: float contamina a conta. E como a aula de int adiantou, a divisão com / devolve float sempre, mesmo entre inteiros. Nada disso exige decoreba; com os exercícios do módulo, o comportamento vira intuição. Na próxima aula, o elenco de tipos ganha o membro mais enxuto e mais poderoso: o bool, que só conhece dois valores.