Python Números (int e float)

Quase todo programa faz conta: quantos pães sobraram na padaria, quanto custa o pedido, qual a média da turma. Para isso, o Python tem dois tipos de número que você vai usar o tempo todo: o int, para os números inteiros (3, 0, -5, 1250000), e o float, para os números com casas decimais (0.75, 25.9, -3.5). Nesta aula você vai ver como escrever cada um, por que o Python usa ponto e não vírgula, como ele lida com números gigantes e por que 0.1 + 0.2 não dá exatamente 0.3.

Os programas desta aula rodaram no Python 3.14 da máquina da Ana (usuária ana, computador notebook, Ubuntu 26.04), na pasta pessoal dela. Todos podem ser repetidos no editor do guia, que roda Python de verdade no navegador.

A ideia: contar e medir

Pense na padaria do bairro. Algumas coisas ali a gente conta: 12 pães, 3 bolos, 40 clientes. Ninguém compra "dois pães e meio". Outras coisas a gente mede: 2,5 kg de farinha, 0,75 real por pão, 1,8 litro de leite. Essas quase sempre têm uma parte depois da vírgula.

O Python separa os números do mesmo jeito:

O nome "ponto flutuante" vem do jeito como o computador guarda esses números por dentro: o ponto decimal pode "flutuar" para a esquerda ou para a direita, o que permite guardar tanto 0.000002 quanto 2500000.0. Você não precisa saber os detalhes; basta lembrar que float é o número com casas decimais.

E como o Python sabe qual é qual? Pela escrita: número sem ponto é int; número com ponto é float. Você não precisa avisar o tipo em lugar nenhum.

1. Números inteiros: int

Para ter um inteiro, escreva os algarismos, sem aspas e sem ponto. A Ana anota o estoque da padaria:

paes = 12
bolos = 3
print(paes)
print(paes + bolos)
print(type(paes))

paes = 12

Guarda o número 12 na variável paes (veja a aula Variáveis). Sem aspas: é um número, e não o texto "12".

paes + bolos

Uma conta: o Python soma os dois valores e entrega o resultado, 15.

type(paes)

"Tipo": pergunta ao Python o tipo do valor (aula Descobrindo o Tipo).

$ python3 estoque.py
12
15
<class 'int'>

O <class 'int'> confirma: 12 é um int. Inteiros também podem ser negativos (com o sinal de menos na frente, colado) ou zero:

temperatura = -5
saldo = 0
print(temperatura)
print(saldo)
print(type(temperatura))

$ python3 temperatura.py
-5
0
<class 'int'>

O int do Python não tem limite

Em muitas linguagens, o inteiro tem um tamanho máximo, e passar dele dá resultado errado. No Python, não: o int cresce o quanto for preciso, enquanto houver memória no computador.

Conta a lenda que o inventor do xadrez pediu ao rei, como recompensa, 1 grão de arroz na primeira casa do tabuleiro, 2 na segunda, 4 na terceira, sempre dobrando, até a casa 64. Quanto arroz é isso? O ** é a potência ("elevado a"); ele tem explicação completa na aula Operadores Aritméticos.

# grãos de arroz na última casa do tabuleiro de xadrez
ultima_casa = 2 ** 63
print(ultima_casa)
total = 2 ** 64 - 1
print(total)
print(type(total))

$ python3 xadrez.py
9223372036854775808
18446744073709551615
<class 'int'>

Mais de 18 quintilhões de grãos, calculados sem erro nenhum, e o resultado continua sendo um int comum. Dá para ir muito além: 2 ** 1000 é um número de 302 algarismos, e o Python calcula na hora. (Existe um limite só para mostrar números com milhares de algarismos; você vai vê-lo em Quando dá errado.)

2. Números grandes com sublinhado: 1_000_000

Quantos zeros tem 10000000? Você teve de contar, não teve? Na escrita do dia a dia, a gente separa os milhares com ponto: 10.000.000. No Python, o ponto já tem outro uso (a casa decimal), então a separação é feita com o sublinhado _:

vendas_do_ano = 1_250_000
meta = 2_000_000
print(vendas_do_ano)
print(meta - vendas_do_ano)

$ python3 vendas.py
1250000
750000

Repare: o sublinhado serve só para você ler o código. Para o Python, 1_250_000 e 1250000 são exatamente o mesmo número, e o print mostra sem os sublinhados. As regras são poucas:

• O sublinhado fica entre algarismos: 1_000 vale; _1000 não é um número (é um nome de variável!) e 1000_ dá erro.
• Um sublinhado por vez: 1__000, com dois seguidos, dá erro.
• O costume é separar de três em três, como os milhares, mas o Python não confere isso.

farinha_em_gramas = 2500000
print(farinha_em_gramas)

farinha_em_gramas = 2_500_000
print(farinha_em_gramas)

3. Números com casas decimais: float

Para ter um float, escreva o número com um ponto separando a parte inteira da parte decimal:

preco_pao = 0.75
preco_bolo = 25.90
print(preco_pao)
print(preco_bolo)
print(type(preco_bolo))

$ python3 precos.py
0.75
25.9
<class 'float'>

Duas coisas para reparar:

• Ponto, nunca vírgula. O Python foi criado com a escrita dos números em inglês, em que a casa decimal é separada por ponto: 25.90. A vírgula, no Python, tem outro significado (ela separa valores), e trocar um pelo outro dá um resultado bem estranho. Você vai ver em Quando dá errado.
• O zero do fim some. Você escreveu 25.90, e o Python mostrou 25.9. Para ele, os dois são o mesmo número, e ele sempre mostra a forma mais curta. Para mostrar um preço com duas casas (25.90), use as f-strings: f"{preco_bolo:.2f}".

Quando o resultado vira float

Basta um float na conta para o resultado ser float. E a divisão com / sempre dá float, mesmo quando a conta é exata:

print(10 / 2)
print(3 + 0.5)
print(2 * 1.5)
print(4.0)
print(type(10 / 2))

$ python3 mistura.py
5.0
3.5
3.0
4.0
<class 'float'>

10 / 2 → 5.0

A divisão com uma barra sempre devolve float, por isso aparece 5.0, e não 5. (Existe a divisão que devolve inteiro, a //, na aula Operadores Aritméticos.)

3 + 0.5 → 3.5

Inteiro com float: o resultado é float. O Python "promove" o 3 para 3.0 antes de somar.

2 * 1.5 → 3.0

O resultado é redondo, mas continua float: por isso o .0.

4.0

Um número redondo escrito com ponto é float. O .0 é o jeito de o Python mostrar "isto é um float, não um int".

4. O mistério do 0.1 + 0.2

Abra o modo interativo do Python (aula O Modo Interativo) e faça uma conta que uma criança faz de cabeça:

$ python3
Python 3.14.4 (main, Aug 20 2026, 10:41:58) [GCC 15.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1 + 0.2 == 0.3
False
>>> 1.1 * 3
3.3000000000000003
>>> 0.5 + 0.25
0.75

Não é defeito do Python, nem do seu computador. O == pergunta "é igual?" (aula Comparações), e o Python respondeu False: para ele, 0.1 + 0.2 não é igual a 0.3. O motivo é o jeito como o computador guarda os float.

Por que isso acontece

Tente escrever um terço com casas decimais: 0,333333… Por mais "3" que você escreva, nunca fica exato; em algum momento você para e arredonda. O computador tem o mesmo problema, só que com outros números: ele guarda os float em binário (só com 0 e 1), e em binário o número 0.1 é uma dízima sem fim, como o um terço para nós. Ele guarda uma aproximação muito boa (cerca de 16 algarismos certos), mas não exata. Quando você soma duas aproximações, o errinho às vezes aparece lá no 17º algarismo.

Repare que 0.5 + 0.25 deu 0.75 exato: metades, quartos e oitavos são "redondos" em binário. Já décimos e centésimos, os números do dinheiro, quase nunca são.

Como lidar com isso

>>> round(0.1 + 0.2, 2)
0.3

O round(numero, casas) ("arredondar") devolve o número arredondado para a quantidade de casas que você pedir. Ele tem um detalhe curioso com os números terminados em 5, que você vai ver na aula Conversão de Tipos.

print(0.1 + 0.2)

print(round(0.1 + 0.2, 2))

5. Notação científica: 1.5e3

Na escola, você talvez tenha visto números escritos como 1,5 × 10³ (que é 1500). O Python tem um jeito curto de escrever isso: a letra e (de "expoente") quer dizer "vezes 10 elevado a".

>>> 1.5e3
1500.0
>>> 2e-3
0.002
>>> 1e6
1000000.0
>>> type(1e6)
<class 'float'>

1.5e3

1,5 × 10³ = 1,5 × 1000 = 1500. O expoente positivo anda com a vírgula para a direita.

2e-3

2 × 10⁻³ = 2 ÷ 1000 = 0,002. O expoente negativo anda para a esquerda.

1e6

1 × 10⁶, um milhão. Atenção: o resultado é 1000000.0, um float. Escrito com e, o número é sempre float, mesmo que seja redondo.

Você mesmo raramente vai escrever assim, mas o Python escreve: quando um float fica muito pequeno ou muito grande, ele passa a mostrá-lo em notação científica.

>>> 0.1 ** 10
1.0000000000000006e-10
>>> 1e16
1e+16
>>> 2.5e-4 * 2
0.0005

1.0000000000000006e-10 quer dizer 0,0000000001 (com o errinho do fim, que você já conhece). 1e+16 é 1 seguido de 16 zeros: o + só deixa claro que o expoente é positivo. Se aparecer um e no meio de um resultado seu, não se assuste: é só um número muito grande ou muito pequeno.

O float tem limites, o int não

O int cresce à vontade; o float, não. Ele guarda só uns 16 algarismos certos e tem um tamanho máximo (perto de 1,8 × 10³⁰⁸). Veja a diferença com o mesmo número escrito dos dois jeitos:

>>> 9007199254740993
9007199254740993
>>> 9007199254740993.0
9007199254740992.0
>>> 1e308 * 10
inf

Como int, o número ficou exato. Como float, o último algarismo virou 2: não coube. E passando do máximo, o float vira inf (de infinity, "infinito"). Moral: para contar coisas, use sempre int.

6. Um terceiro tipo: complex (só para conhecer)

O Python tem ainda um tipo de número que você provavelmente nunca vai usar fora de Matemática e Engenharia: os números complexos, com uma parte "imaginária" marcada pela letra j.

>>> 3 + 2j
(3+2j)
>>> type(3 + 2j)
<class 'complex'>

Fica só o registro de que ele existe: se um dia aparecer um j colado num número, é um complex. Neste guia, os números são int e float.

Formas diferentes de escrever o mesmo número

O mesmo valor pode ser escrito de vários jeitos. Às vezes o tipo muda junto:

>>> 1000000
1000000
>>> 1_000_000
1000000
>>> 10 ** 6
1000000
>>> 1e6
1000000.0
>>> .5
0.5
>>> 5.
5.0
>>> 5e-1
0.5
>>> 1 / 2
0.5

Quando dá errado

preco = 4,50
print(preco)
print(preco * 2)
print(type(preco))

$ python3 virgula.py
(4, 50)
(4, 50, 4, 50)
<class 'tuple'>

cep = 01310
print(cep)

$ python3 cep.py
  File "/home/ana/cep.py", line 1
    cep = 01310
          ^
SyntaxError: leading zeros in decimal integer literals are not permitted; use an 0o prefix for octal integers

$ python3 -q
>>> 1_000__000
  File "<python-input-0>", line 1
    1_000__000
         ^
SyntaxError: invalid decimal literal

numero = 10 ** 5000
print(numero)

$ python3 gigante.py
Traceback (most recent call last):
  File "/home/ana/gigante.py", line 2, in <module>
    print(numero)
    ~~~~~^^^^^^^^
ValueError: Exceeds the limit (4300 digits) for integer string conversion; use sys.set_int_max_str_digits() to increase the limit

print(2 ** 10000 > 0)
print(2.0 ** 10000)

$ python3 estouro.py
True
Traceback (most recent call last):
  File "/home/ana/estouro.py", line 2, in <module>
    print(2.0 ** 10000)
          ~~~~^^~~~~~~
OverflowError: (34, 'Numerical result out of range')

preco_bolo = 25,90
quantidade = 2
total = preco_bolo * quantidade
print(total)

preco_bolo = 25.90
quantidade = 2
total = preco_bolo * quantidade
print(total)

Referência rápida

Exercícios

Missão final: a conta do café da manhã

preco_pao = 0,75
quantidade = 10
print(preco_pao)

preco_pao = 0.75
quantidade = 10
print(preco_pao * quantidade)

Deu 7.5: R$ 7,50. O zero do fim sumiu, como você já viu; para mostrar 7.50, use as f-strings.

Resumo

• int é o número inteiro (para contar); float é o número com casas decimais (para medir). O Python decide pelo jeito de escrever: com ponto é float.
• O int do Python não tem limite de tamanho: 2 ** 64 - 1 sai exato.
• Números grandes ficam legíveis com sublinhado: 1_250_000. O Python ignora os sublinhados.
• A casa decimal é separada por ponto. Com vírgula, 4,50 vira um pacote de dois números, sem erro nenhum.
• A divisão com / sempre dá float, e misturar int com float dá float.
• 0.1 + 0.2 dá 0.30000000000000004: o float é uma aproximação. Arredonde para mostrar; não compare float com ==; para dinheiro de verdade, use centavos em int.
• 1.5e3 é notação científica (1500.0), e é sempre float.
• CEP, telefone e documentos são texto, não número: o zero à esquerda dá SyntaxError.