Python Conversão de Tipos

Para o Python, "12" (entre aspas) e 12 (sem aspas) são coisas diferentes: o primeiro é um texto que por acaso tem dois algarismos; o segundo é um número, com o qual dá para fazer conta. E o problema aparece logo: tudo o que o input() lê do teclado chega como texto. Nesta aula você vai aprender a converter um valor de um tipo para outro com int(), float(), str() e bool(), e a conhecer as surpresas do caminho: a vírgula brasileira, o int() que corta em vez de arredondar e o round() que arredonda 2.5 para 2.

Você vai aprender

Por que "12" + 1 dá erro, e como transformar o texto em número com int().
A converter o que o input() lê: int(input(…)).
A usar float(), e o que fazer com o "3,5" escrito com vírgula.
Que int(3.9) dá 3: ele corta, não arredonda.
A arredondar com round(), e por que round(2.5) dá 2.
A transformar número em texto com str().
O que bool() faz com números e textos.
Os erros reais: ValueError e TypeError.

Os programas desta aula rodaram no Python 3.14 da máquina da Ana (usuária ana, computador notebook), e podem ser repetidos no editor do guia.

A ideia: o número escrito no papel

Na padaria, o padeiro deixa um bilhete para a Ana: "faltam 12 pães". Para saber quantos pães terá depois de assar mais uma fornada, a Ana não faz conta com o papel: ela lê o "12" do bilhete, entende que é o número doze e aí faz a conta de cabeça.

O Python é igualzinho. O texto "12" é o bilhete: só desenhos de algarismos. Para fazer conta, alguém precisa "ler" o texto e transformar em número. Quem faz isso são as funções de conversão, que têm o mesmo nome do tipo que você quer obter:

Função	Converte para	Exemplo	Resultado
`int(…)`	Número inteiro	`int("12")`	`12`
`float(…)`	Número com casas decimais	`float("3.5")`	`3.5`
`str(…)`	Texto (string)	`str(12)`	`'12'`
`bool(…)`	Verdadeiro ou falso	`bool(0)`	`False`

Converter não muda o valor original: a função devolve um valor novo, do tipo pedido. Se você quiser guardá-lo, ponha numa variável.

1. Texto para inteiro: `int()`

Primeiro, o problema. A Ana guardou a quantidade como texto (repare nas aspas) e tentou somar 1:

quantidade = "12"
print(quantidade + 1)

$ python3 soma_errada.py
Traceback (most recent call last):
  File "/home/ana/soma_errada.py", line 2, in <module>
    print(quantidade + 1)
          ~~~~~~~~~~~^~~
TypeError: can only concatenate str (not "int") to str

Traceback (most recent call last): O programa começou a rodar e parou por causa de um erro. As linhas de baixo dizem onde e por quê.
File "/home/ana/soma_errada.py", line 2: O erro está na linha 2.
~~~~~~~~~~~^~~: Os tils marcam as duas partes da conta, e o chapeuzinho, o +: foi a soma que falhou.
TypeError: "Erro de tipo": a operação não funciona com esses tipos.
can only concatenate str (not "int") to str: "Só dá para concatenar (juntar) str com str (não com int)". Com um texto do lado esquerdo, o + quer juntar textos (aula Juntar e Repetir Textos), e o 1 não é texto.

A solução é converter o texto em número antes da conta:

quantidade = "12"
numero = int(quantidade)
print(numero + 1)
print(type(quantidade))
print(type(numero))

$ python3 soma_certa.py
13
<class 'str'>
<class 'int'>

int(quantidade): Lê o texto "12" e devolve o número 12.
numero = …: Guarda o número novo numa variável.
<class 'str'>: A variável quantidade continua sendo texto: o int() não mexeu nela, criou um valor novo.

O que o `int()` aceita

No modo interativo dá para testar vários de uma vez:

$ python3 -q
>>> int("12")
12
>>> int(" 12 ")
12
>>> int("-7")
-7
>>> int("1_000")
1000

Espaços em volta são ignorados, o sinal de menos funciona e até o sublinhado da aula Números passa. Mas o texto tem de ser um inteiro escrito direitinho. Com ponto, com letras ou vazio, dá erro:

$ python3 -q
>>> int("12.5")
Traceback (most recent call last):
  File "<python-input-0>", line 1, in <module>
    int("12.5")
    ~~~^^^^^^^^
ValueError: invalid literal for int() with base 10: '12.5'
>>> int("doze")
Traceback (most recent call last):
  File "<python-input-1>", line 1, in <module>
    int("doze")
    ~~~^^^^^^^^
ValueError: invalid literal for int() with base 10: 'doze'
>>> int("")
Traceback (most recent call last):
  File "<python-input-2>", line 1, in <module>
    int("")
    ~~~^^^^
ValueError: invalid literal for int() with base 10: ''

File "<python-input-0>", line 1: No modo interativo não há arquivo: <python-input-0> é a primeira coisa digitada na sessão, -1 a segunda, e assim por diante.
ValueError: "Erro de valor": o tipo está certo (é um texto, e o int() aceita textos), mas aquele texto em particular não serve.
invalid literal for int() with base 10: '12.5': "Escrita inválida para int() na base 10". "Base 10" é o nosso sistema de sempre, com os algarismos de 0 a 9. Entre aspas, no fim, o Python mostra o texto que recusou; no último caso, '', um texto vazio (o que acontece quando a pessoa aperta Enter sem digitar nada).

Para "12.5", há dois caminhos: float("12.5"), se você quer o número com a casa decimal, ou int(float("12.5")), que passa pelo float e depois corta para 12. Nos outros casos, o texto simplesmente não é um número; a aula try e except ensina a tratar isso sem o programa parar.

Missão: o programa dá TypeError. Converta a quantidade para inteiro antes da soma, para ele mostrar 13.

quantidade = "12"
print(quantidade + 1)

quantidade = "12"
print(int(quantidade) + 1)

2. Convertendo o que o `input()` lê

É aqui que você mais vai usar a conversão. O input() (aula input()) sempre devolve texto, mesmo quando a pessoa digita só algarismos:

idade = input("Quantos anos você tem? ")
print(type(idade))
idade = int(idade)
print("No ano que vem você terá", idade + 1, "anos.")

$ python3 idade.py
Quantos anos você tem? 30
<class 'str'>
No ano que vem você terá 31 anos.

A Ana digitou 30, e o type mostrou str: um texto. Depois do int(idade), a variável passou a guardar o número 30, e a conta funcionou. Repare que a linha 3 reaproveita o mesmo nome: idade = int(idade) lê o texto antigo, converte e guarda o número no lugar dele.

O mais comum é fazer tudo numa linha só, uma função dentro da outra:

idade = int(input("Quantos anos você tem? "))

O Python resolve de dentro para fora: primeiro o input() lê o texto; depois o int() converte; por fim, o número vai para a variável.

3. Texto para `float`: `float()` e a vírgula

O float() faz o mesmo para números com casas decimais. Ele aceita um pouco mais que o int():

$ python3 -q
>>> float("3.5")
3.5
>>> float("12")
12.0
>>> float("1e3")
1000.0
>>> float(" 2.75\n")
2.75

Um texto de inteiro vira 12.0; a notação científica funciona; espaços e quebras de linha (\n) em volta são ignorados. Agora, a armadilha brasileira. A Ana fez um programa para a balança da padaria:

texto = input("Preço do quilo: ")
preco = float(texto)
print("2 quilos custam", preco * 2)

$ python3 preco.py
Preço do quilo: 3.5
2 quilos custam 7.0
$ python3 preco.py
Preço do quilo: 3,5
Traceback (most recent call last):
  File "/home/ana/preco.py", line 2, in <module>
    preco = float(texto)
ValueError: could not convert string to float: '3,5'

Com ponto, funcionou. Com vírgula, do jeito que qualquer pessoa no Brasil digita, o programa parou: could not convert string to float: '3,5', "não foi possível converter o texto em float". O float() só entende o ponto. (Repare que, desta vez, não apareceram os tils e chapeuzinhos embaixo da linha. O Python nem sempre os mostra; o que importa é o número da linha e a mensagem do fim.)

Você não pode obrigar quem usa o programa a digitar ponto. Então o programa troca a vírgula pelo ponto antes de converter, com o .replace(",", ".") ("substituir"), um método de texto que você vai conhecer na aula Métodos de Texto:

texto = input("Preço do quilo: ")
preco = float(texto.replace(",", "."))
print("2 quilos custam", preco * 2)

$ python3 preco_virgula.py
Preço do quilo: 3,5
2 quilos custam 7.0

texto.replace(",", "."): Devolve uma cópia do texto com cada vírgula trocada por ponto: "3,5" vira "3.5". Se a pessoa já digitou ponto, não há vírgula para trocar e nada muda.
float(…): Converte o texto já consertado.

Também não passa nada além do número: float("R$ 3.50") dá o mesmo ValueError, por causa do R$.

Missão: o editor vai digitar 3,50, com vírgula, e o programa para com ValueError. Troque a vírgula por ponto antes do float(), para ele mostrar o preço de 2 quilos.

texto = input("Preço do quilo: ")
preco = float(texto)
print("2 quilos custam", preco * 2)

texto = input("Preço do quilo: ")
preco = float(texto.replace(",", "."))
print("2 quilos custam", preco * 2)

4. `float` para inteiro: o `int()` corta

O int() também converte um float. Só que ele não arredonda: ele joga fora tudo o que vem depois do ponto.

print(int(3.9))
print(int(3.1))
print(int(-3.9))
print(round(3.9))
print(round(-3.9))

$ python3 corte.py
3
3
-3
4
-4

3.9 virou 3, e não 4. Com os negativos é igual: -3.9 virou -3 (o corte sempre vai em direção ao zero). Quando você quer o inteiro mais próximo, use o round() ("arredondar"), como nas duas últimas linhas.

Valor	`int()` (corta)	`round()` (arredonda)
`3.9`	`3`	`4`
`3.1`	`3`	`3`
`-3.9`	`-3`	`-4`

5. Arredondando: `round()` e o 2.5 que vira 2

O round tem duas formas. Sem o segundo número, ele devolve um inteiro; com ele, devolve um float com aquela quantidade de casas:

nota1 = 7
nota2 = 8
nota3 = 8
media = (nota1 + nota2 + nota3) / 3
print(media)
print(round(media, 1))
print(round(media))

$ python3 media.py
7.666666666666667
7.7
8

(nota1 + nota2 + nota3) / 3: Soma as notas e divide por 3. Os parênteses fazem a soma acontecer antes da divisão (aula Precedência).
round(media, 1): Arredonda para 1 casa decimal: 7.7.
round(media): Sem o segundo número: arredonda para o inteiro mais próximo e devolve um int, 8.

A surpresa: `round(2.5)` dá `2`

Na escola, a gente aprende que 2,5 arredonda para cima, 3. Veja o que o Python faz:

$ python3 -q
>>> round(2.5)
2
>>> round(3.5)
4
>>> round(0.5)
0
>>> round(1.5)
2
>>> round(4.5)
4
>>> round(2.6)
3

Não é defeito. Quando o número está exatamente no meio (terminado em ,5), o Python arredonda para o vizinho par: 2,5 vai para 2; 3,5 vai para 4; 4,5 vai para 4. Esse jeito se chama arredondamento bancário (ou "arredondamento para o par"). O motivo: se você arredondar milhares de valores sempre para cima, a soma deles vai ficando maior do que deveria; indo metade das vezes para cima e metade para baixo, os erros se compensam. É o que bancos e programas de estatística costumam fazer, e é a regra do round() segundo a documentação oficial do Python.

Fora do meio exato, nada muda: round(2.6) dá 3, como na escola.

Com casas decimais, entra o float

>>> round(7.456, 2)
7.46
>>> round(2.675, 2)
2.67

Por que 2.675 virou 2.67, e não 2.68? Nem é o arredondamento bancário: é a aproximação do float que você viu na aula Números. O 2.675 guardado no computador é, na verdade, um pouquinho menos que 2,675, então ele fica mais perto de 2,67. Para mostrar valores, o round é ótimo; para dinheiro que precisa bater centavo por centavo, use centavos em int ou o módulo decimal.

6. Número para texto: `str()`

O caminho inverso também existe. O str() transforma qualquer valor em texto:

$ python3 -q
>>> str(12)
'12'
>>> str(25.9)
'25.9'
>>> str(-3)
'-3'
>>> type(str(12))
<class 'str'>

As aspas na resposta ('12') são o jeito do modo interativo mostrar que aquilo é um texto. Para que serve? Para juntar um número a um texto com o +. Sem a conversão, é o mesmo TypeError do começo da aula:

total = 15
print("Total: " + total)

$ python3 total_texto.py
Traceback (most recent call last):
  File "/home/ana/total_texto.py", line 2, in <module>
    print("Total: " + total)
          ~~~~~~~~~~^~~~~~~
TypeError: can only concatenate str (not "int") to str

total = 15
mensagem = "Total: " + str(total)
print(mensagem)
print("Total:", total)

$ python3 total_str.py
Total: 15
Total: 15

As duas linhas mostram o mesmo. Na segunda, o print recebeu dois valores separados por vírgula e cuidou sozinho da conversão (e do espaço entre eles). O str() é necessário quando você quer o texto pronto numa variável, como a mensagem. Na prática, para montar textos com números, a forma mais usada é a f-string: f"Total: {total}".

7. Para verdadeiro ou falso: `bool()`

O bool() converte um valor em True (verdadeiro) ou False (falso). A regra, para números e textos, é curta: zero e vazio viram False; todo o resto vira True.

$ python3 -q
>>> bool(0)
False
>>> bool(1)
True
>>> bool(-2)
True
>>> bool(0.0)
False
>>> bool("")
False
>>> bool("0")
True
>>> bool("False")
True

Repare nos dois últimos: "0" e "False" são textos com letras dentro, então não estão vazios, e viram True. O bool() não lê o que está escrito; só olha se o texto tem alguma coisa. O caminho inverso também funciona: int(True) dá 1 e float(False) dá 0.0. A aula Booleanos explica tudo isso com calma.

Formas diferentes de fazer

Ler um número do teclado

Forma	Quando usar
`quantidade = int(input("Quantos? "))`	Números inteiros: quantidades, idades. É a forma mais comum
`preco = float(input("Preço: "))`	Números com casas decimais, se a pessoa digitar com ponto
`preco = float(input("Preço: ").replace(",", "."))`	Números com casas decimais digitados por brasileiros: aceita vírgula e ponto
`texto = input(…)` e, na linha de baixo, `numero = int(texto)`	Quando você ainda vai usar o texto original, ou quer deixar cada passo claro

Tirar as casas decimais

Forma	3.7 vira	2.5 vira	Quando usar
`int(x)`	`3`	`2`	Quando você quer só a parte inteira, cortando (ex.: anos completos)
`round(x)`	`4`	`2`	Quando você quer o inteiro mais próximo (no meio exato, o par)
`round(x, 2)`	`3.7`	`2.5`	Para mostrar um valor com até 2 casas
`math.floor(x)` e `math.ceil(x)`	`3` e `4`	`2` e `3`	Sempre para baixo ou sempre para cima (aula O Módulo math)

Quando dá errado

Somar um texto com um número: TypeError

TypeError: can only concatenate str (not "int") to str. Um dos lados do + é texto (muitas vezes, o que veio do input()) e o outro é número. Como consertar: se você queria fazer conta, converta o texto com int() ou float(); se queria juntar textos, converta o número com str().

Texto que não é número: ValueError no int()

ValueError: invalid literal for int() with base 10: '12.5'. O texto tem ponto, letras, espaço no meio ou está vazio. Como consertar: se tem casa decimal, use float(); se a pessoa pode digitar qualquer coisa, trate o erro com try e except.

Número com vírgula: ValueError no float()

ValueError: could not convert string to float: '3,5'. O float() só entende ponto. Como consertar: float(texto.replace(",", ".")).

Esqueceu de guardar o resultado

quantidade = "12"
int(quantidade)
print(quantidade + 1)

Este programa dá o mesmo TypeError do começo da aula. A linha 2 converteu, mas o número novo não foi guardado em lugar nenhum e se perdeu; quantidade continua sendo o texto "12". Como consertar: quantidade = int(quantidade).

Achar que o int() arredonda

A média da turma deu 7.9 e o programa mostrou 7: o int() cortou. Não aparece mensagem nenhuma, porque não é erro do Python; é o comportamento do int(). Como consertar: use round().

Missão: o programa para com TypeError. Converta o número para texto, para ele mostrar Total: 15.

total = 15
print("Total: " + total)

total = 15
print("Total: " + str(total))

Referência rápida

Escrita	Resultado	Observação
`int("12")`	`12`	Espaços em volta são ignorados
`int("12.5")`	`ValueError`	Texto com ponto não vira `int` direto
`int(3.9)`	`3`	Corta as casas decimais (em direção ao zero)
`float("3.5")`	`3.5`	Só com ponto
`float("3,5")`	`ValueError`	Use `.replace(",", ".")` antes
`float("12")`	`12.0`
`round(3.7)`	`4`	Devolve `int`
`round(2.5)`	`2`	No meio exato, vai para o par
`round(7.456, 2)`	`7.46`	Devolve `float`
`str(12)`	`'12'`	Para juntar com outros textos
`bool(0)`, `bool("")`	`False`	Zero e vazio são falsos
`bool("0")`	`True`	Texto com algo dentro é verdadeiro
`int(input(…))`	um `int`	Lê do teclado e converte

Exercícios

1. O que sai?

Escreva o resultado de cada conversão, como o modo interativo mostraria:

int(" 40 ") → int(9.99) → float("8") → round(6.5) →

2. Ler um inteiro

Complete para a variável guardar um número inteiro lido do teclado:

paes = (input("Quantos pães? "))

3. A pessoa digitou 2,75. O que acontece em float(input("Peso: "))?

O resultado é 2.75 O resultado é (2, 75) ValueError: could not convert string to float: '2,75' O resultado é 275.0

4. Por que round(4.5) dá 4?

Porque o round sempre arredonda para baixo Porque, no meio exato, o Python arredonda para o vizinho par Porque o round corta as casas decimais, como o int É um defeito do Python 3.14

5. Quanto vale bool("0")?

False, porque é zero 0 Dá erro True, porque o texto não está vazio

Missão final: a média arredondada

Missão: a média da Ana mostra 7.666666666666667, casas demais para o boletim. Use o round para mostrar a média com 1 casa decimal.

nota1 = 7
nota2 = 8
nota3 = 8
media = (nota1 + nota2 + nota3) / 3
print(media)

nota1 = 7
nota2 = 8
nota3 = 8
media = (nota1 + nota2 + nota3) / 3
print(round(media, 1))

Resumo

"12" é texto; 12 é número. Para fazer conta com um texto, converta: int("12") ou float("3.5").
O input() sempre devolve texto: int(input(…)) lê e converte de uma vez.
O float() só entende ponto: float("3,5") dá ValueError. Troque antes com .replace(",", ".").
Texto que não é número ("doze", "", "12.5" no int) dá ValueError.
int(3.9) dá 3: corta. Para arredondar, round().
round(x) devolve int; round(x, 2) devolve float. No meio exato vai para o par: round(2.5) é 2.
str() transforma em texto, para juntar com +. Sem ele, "Total: " + 15 dá TypeError.
bool(): zero e vazio são False; o resto é True, até "0" e "False".
Converter cria um valor novo: guarde-o numa variável.