Python type()

Na aula Tipos de Dados você viu que todo valor tem um tipo, e que o tipo muda tudo: 15 + 27 dá 42, mas "15" + "27" dá "1527". Só que, olhando para uma variável, nem sempre dá para saber o tipo do que está guardado nela. A função type() (em inglês, "tipo") responde a essa pergunta. Ela é a lupa do programador: quando um resultado sai estranho, perguntar o tipo é muitas vezes o primeiro passo para achar o erro.

Você vai aprender

A perguntar o tipo de um valor, de uma variável e do resultado de uma conta com type().
A ler a resposta: o que quer dizer <class 'int'>.
A usar type() para descobrir por que um programa deu 1527 em vez de 42.
A conferir se um valor é de um tipo: type(x) == int, e a armadilha de comparar com "int".
A conhecer o isinstance(), o jeito mais usado de conferir tipos.
Os erros reais: type() vazio, Type com maiúscula e o nome do tipo entre aspas.

Os programas desta aula foram rodados com o Python 3.14 na máquina fictícia da Ana (usuária ana, computador notebook), com python3 arquivo.py.

A ideia: ler o rótulo da embalagem

Na despensa da padaria, dois potes iguais, sem nada escrito: um tem sal, o outro tem açúcar. Por fora, não dá para saber. Antes de pôr a colher no bolo, a Ana vira o pote e lê o rótulo no fundo.

Uma variável é como esse pote: vendas pode guardar o número 15 ou o texto "15", e o print mostra os dois do mesmo jeito, 15. O type() vira o pote e lê o rótulo: diz se ali dentro tem um int, um str, um float…

1. Perguntando o tipo

print(type(42))
print(type(7.5))
print(type("Ana"))
print(type(True))
print(type(None))

$ python3 ty-basico.py
<class 'int'>
<class 'float'>
<class 'str'>
<class 'bool'>
<class 'NoneType'>

type: O nome da função. Tudo em minúsculas, como print.
( 42 ): O valor cujo tipo você quer saber. Vai um valor só.
print( … ): O type() devolve o tipo, mas não mostra nada sozinho num programa. Quem mostra é o print, como sempre.
<class 'int'>: A resposta. class ("classe") é o nome que o Python dá a um tipo; entre as aspas vem o nome do tipo, aqui int. Os sinais < e > só marcam que aquilo é uma descrição, e não um texto comum. Leia como "é do tipo int".

No modo interativo

No >>> (aula O Modo Interativo) nem precisa do print. É o jeito mais rápido de tirar uma dúvida:

$ 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.
>>> type(42)
<class 'int'>
>>> type("42")
<class 'str'>
>>> type(42.0)
<class 'float'>
>>> exit()

2. O tipo de variáveis e de contas

Dentro dos parênteses pode ir qualquer coisa que tenha valor: uma variável, uma conta, o que uma função devolveu. O type() responde o tipo do valor que está ali naquele momento:

preco = 7.5
quantidade = 3
total = preco * quantidade
print(type(preco))
print(type(quantidade))
print(type(total))
print(type(7 / 2), type(10 // 2), type(3 + 0.5))

$ python3 ty-var.py
<class 'float'>
<class 'int'>
<class 'float'>
<class 'float'> <class 'int'> <class 'float'>

type(preco): o Python troca o nome pelo valor, 7.5, e responde float.
type(total): 7.5 * 3 dá 22.5; um float vezes um int dá float.
type(7 / 2): a divisão com / sempre dá float. Já o //, a divisão inteira (aula Operadores Aritméticos), deu int.

Só o nome do tipo

Para mostrar o tipo numa frase, sem o <class '…'> em volta, peça só o nome com .__name__ (dois sublinhados de cada lado; em inglês, "nome"):

estoque = 12
print("estoque é do tipo", type(estoque).__name__)

$ python3 ty-nome.py
estoque é do tipo int

Esse ponto depois do type(estoque) quer dizer "pegue uma informação de dentro dele". Você vai ver muitos pontos assim a partir da aula Métodos de Texto; por enquanto, basta saber que type(x).__name__ dá o nome do tipo como texto.

3. O `type()` como detetive

Lembra do programa da aula input() que somava 15 e 27 e dava 1527? Imagine que você não soubesse o motivo. Um print(type(...)) resolve o mistério:

manha = input("Vendas da manhã: ")
tarde = input("Vendas da tarde: ")
print("Total:", manha + tarde)
print(type(manha), type(tarde))

$ python3 ty-debug.py
Vendas da manhã: 15
Vendas da tarde: 27
Total: 1527
<class 'str'> <class 'str'>

Os dois são str: o + juntou textos em vez de somar números. Pista encontrada, conserto sabido: int(input(...)). Esse truque de colocar um print a mais para "espiar" o programa é a forma mais simples de depuração (achar e corrigir erros); a aula Depurando com pdb mostra ferramentas maiores.

Missão: seja o detetive. Acrescente no fim uma linha que mostre o tipo de manha, com print(type(manha)), e veja com os seus olhos por que o total saiu errado. (O editor digita 15 e 27.)

manha = input("Vendas da manhã: ")
tarde = input("Vendas da tarde: ")
print("Total:", manha + tarde)

manha = input("Vendas da manhã: ")
tarde = input("Vendas da tarde: ")
print("Total:", manha + tarde)
print(type(manha))

4. Conferindo se um valor é de um tipo

Às vezes você não quer só ver o tipo, quer perguntar: "isto é um inteiro?". O nome do tipo, sem aspas, pode ser comparado com o == ("é igual?"), e a resposta é um bool, True ou False:

idade = 29
print(type(idade) == int)
print(type(idade) == str)
print(type(idade) == "int")

$ python3 ty-compara.py
True
False
False

type(idade) == int: "O tipo de idade é int?" Sim: True. Aqui int vai sem aspas: é o próprio tipo, o mesmo nome que você usa em int(input(...)).
type(idade) == str: "É str?" Não: False.
type(idade) == "int": Cuidado: deu False, sem erro nenhum. Com aspas, "int" é um texto de três letras, e o tipo int não é igual a um texto. A pergunta está errada e a resposta engana.

Essas respostas True/False vão ficar úteis quando o programa começar a tomar decisões, com o if ("se"), na aula if.

O `isinstance()`

Existe uma segunda função para essa pergunta, e é a que os programadores Python mais usam: isinstance(), de is instance, "é uma instância de", ou seja, "é um exemplar de". Ela recebe dois valores: o que você quer testar e o tipo.

idade = 29
preco = 7.5
print(isinstance(idade, int))
print(isinstance(preco, int))
print(isinstance(preco, (int, float)))
print(isinstance(preco, int | float))
print(isinstance("29", int))

$ python3 ty-isinstance.py
True
False
True
True
False

isinstance(idade, int): "idade é um int?" Sim.
isinstance(preco, int): 7.5 é float, não int: False.
isinstance(preco, (int, float)): Vários tipos entre parênteses, separados por vírgula: "é int ou float?". Sim. É o jeito de perguntar "é um número?".
isinstance(preco, int | float): A mesma pergunta, escrita com a barra vertical |, que aqui se lê "ou". Funciona desde o Python 3.10.
isinstance("29", int): Com aspas, "29" é texto: False.

Por que existem dois jeitos?

O type(x) == int pergunta "o tipo é exatamente int?". O isinstance(x, int) pergunta "é um int, ou um tipo que é uma variação de int?". A diferença aparece num caso curioso: para o Python, o bool é uma variação do int (True vale 1 nas contas). Então type(True) == int dá False, mas isinstance(True, int) dá True. Essa história de "tipos que são variações de outros" se chama herança e fica para a aula Herança. Por enquanto, a regra prática: para conferir um tipo, prefira isinstance(); use type() para ver qual é o tipo.

Missão: o programa pergunta se preco é um int, e a resposta é False. Mude a pergunta para "é int ou float?", com o isinstance(), para a resposta ser True.

preco = 7.5
print(isinstance(preco, int))

preco = 7.5
print(isinstance(preco, (int, float)))

Formas diferentes de descobrir o tipo

Forma	Responde	Quando usar
`type(x)` no `>>>`	`<class 'int'>`	Tirar uma dúvida rápida
`print(type(x))`	`<class 'int'>`	Espiar um programa que está dando resultado estranho
`type(x).__name__`	`'int'` (um texto)	Mostrar o nome do tipo numa frase
`type(x) == int`	`True` / `False`	Conferir o tipo exato. Raro
`isinstance(x, int)`	`True` / `False`	O jeito preferido de conferir um tipo
`isinstance(x, (int, float))`	`True` / `False`	Conferir vários tipos de uma vez ("é um número?")

Quando dá errado

type() sem nada, ou com dois valores

print(type())

$ python3 ty-err-vazio.py
Traceback (most recent call last):
  File "/home/ana/ty-err-vazio.py", line 1, in <module>
    print(type())
          ~~~~^^
TypeError: type() takes 1 or 3 arguments

"type() recebe 1 ou 3 argumentos". Com zero não dá. Com dois valores, como type(12, 7.5), a mensagem é a mesma. O jeito com 3 argumentos serve para criar tipos novos, coisa avançada que você não vai precisar; para perguntar o tipo, é sempre um valor. Como consertar: um type() para cada valor: print(type(12), type(7.5)).

Type com maiúscula

print(Type(29))

$ python3 ty-err-Type.py
Traceback (most recent call last):
  File "/home/ana/ty-err-Type.py", line 1, in <module>
    print(Type(29))
          ^^^^
NameError: name 'Type' is not defined. Did you mean: 'type'?

Como com o Print da aula print(): o Python diferencia maiúsculas, e a dica "Did you mean" já diz o conserto: type, minúsculo.

O nome do tipo entre aspas no isinstance()

print(isinstance(29, "int"))

$ python3 ty-err-texto.py
Traceback (most recent call last):
  File "/home/ana/ty-err-texto.py", line 1, in <module>
    print(isinstance(29, "int"))
          ~~~~~~~~~~^^^^^^^^^^^
TypeError: isinstance() arg 2 must be a type, a tuple of types, or a union

"O argumento 2 do isinstance() tem de ser um tipo, uma tupla de tipos ou uma união". O segundo valor foi o texto "int", e não o tipo int. (A "tupla de tipos" é o (int, float); a "união" é o int | float.) Aqui, pelo menos, o Python avisa; com type(x) == "int", ele só responde False em silêncio (seção 4). Como consertar: sem aspas, isinstance(29, int).

Nome do tipo por extenso

print(isinstance(29, integer))

$ python3 ty-err-nome.py
Traceback (most recent call last):
  File "/home/ana/ty-err-nome.py", line 1, in <module>
    print(isinstance(29, integer))
                         ^^^^^^^
NameError: name 'integer' is not defined

O tipo se chama int, abreviado, e não integer. O mesmo vale para str (e não string) e bool (e não boolean). Como consertar: use os nomes curtos, exatamente como o type() mostra: int, float, str, bool.

Uma variável chamada type

Na aula Nomes de Variáveis você viu que dá para criar uma variável com o nome de uma função do Python, e que isso esconde a função. Com type é igual: depois de type = "pão doce", qualquer type(…) do programa dá TypeError: 'str' object is not callable. Use outro nome, como tipo ou categoria.

Missão: o programa deveria responder True (29 é um inteiro), mas responde False, e sem erro. Ache o problema na comparação e conserte.

idade = 29
print(type(idade) == "int")

idade = 29
print(type(idade) == int)

Referência rápida

Escrita	Resultado
`type(42)`	`<class 'int'>`
`type(7.5)`	`<class 'float'>`
`type("Ana")`	`<class 'str'>`
`type(True)`	`<class 'bool'>`
`type(None)`	`<class 'NoneType'>`
`type(7 / 2)`	`<class 'float'>` (o tipo do resultado da conta)
`type(x).__name__`	Só o nome do tipo, como texto: `'int'`
`type(x) == int`	`True` se o tipo for exatamente `int`
`isinstance(x, int)`	`True` se `x` for um `int`
`isinstance(x, (int, float))` ou `isinstance(x, int \| float)`	`True` se for `int` ou `float`

Mensagem	Causa provável
`TypeError: type() takes 1 or 3 arguments`	`type()` vazio ou com dois valores
`NameError: name 'Type' is not defined. Did you mean: 'type'?`	Maiúscula no nome da função
`TypeError: isinstance() arg 2 must be a type, a tuple of types, or a union`	Nome do tipo entre aspas
`NameError: name 'integer' is not defined`	Nome do tipo por extenso: é `int`
`type(x) == "int"` sempre dá `False`, sem erro	Comparando o tipo com um texto: tire as aspas

Exercícios

1. Complete

Complete para mostrar o tipo da variável nome:

print((nome))

2. Qual é a saída?

O que mostra print(type(10 / 5))?

Saída:

3. Verdadeiro ou falso?

O que mostra print(isinstance("7", int))?

Saída:

4. A pessoa digitou 42 em valor = input("Valor: "). O que mostra print(type(valor))?

<class 'int'> <class 'str'> <class 'float'> 42

5. Qual destas linhas responde True para x = 3.5?

type(x) == "float" isinstance(x, int) type(x) == int isinstance(x, (int, float))

6. Qual é a recomendação para conferir se um valor é de um tipo?

Comparar type(x) com o nome do tipo entre aspas Olhar o valor com print Usar isinstance(x, tipo) Usar type() com dois argumentos

Missão final: a ficha de cadastro

Missão: o cadastro lê nome, idade e altura, e mostra o tipo de cada um. Hoje, os três saem str. Converta a idade com int() e a altura com float() para a ficha mostrar nome: str, idade: int e altura: float. (O editor digita Ana, 29 e 1.65.)

nome = input("Nome: ")
idade = input("Idade: ")
altura = input("Altura: ")
print("nome:", type(nome).__name__)
print("idade:", type(idade).__name__)
print("altura:", type(altura).__name__)

nome = input("Nome: ")
idade = int(input("Idade: "))
altura = float(input("Altura: "))
print("nome:", type(nome).__name__)
print("idade:", type(idade).__name__)
print("altura:", type(altura).__name__)

Resumo

type(valor) devolve o tipo de um valor, de uma variável ou do resultado de uma conta; num programa, mostre com print.
A resposta <class 'int'> se lê "é do tipo int". Para só o nome, type(x).__name__.
Resultado estranho? Espie com print(type(...)): muitos erros de iniciante são um str onde deveria haver um número.
type(x) == int confere o tipo exato; o tipo vai sem aspas (com aspas, a resposta é sempre False).
isinstance(x, int) é o jeito preferido de conferir; aceita vários tipos: isinstance(x, (int, float)).
Os nomes dos tipos são curtos: int, float, str, bool.