Variáveis e tipos de dados em Python: uma introdução prática

Q: O que vem a seguir?

No próximo tutorial, Números e matemática, você vai se aprofundar no sistema numérico do Python. Vai conhecer o módulo math, estratégias de arredondamento, formatação de números e como criar programas que fazem contas como um profissional.

Iniciante25 min6 exercícios95 XP

Este tutorial foi traduzido do original em inglês.Read in English Leer en español Читать на русском อ่านภาษาไทย Avisar sobre um erro de tradução

Antes de começar

Python para iniciantes: seu primeiro programa em 5 minutos

0/6 exercícios

Imagine que você vai enviar uma encomenda. Você preenche uma etiqueta que pede o peso. Em vez de um número, você escreve "pesado". O sistema da transportadora trava: ele não consegue calcular um preço a partir da palavra "pesado".

É exatamente esse tipo de problema que os tipos de dados resolvem na programação. Os tipos dizem ao Python se algo é um número, um texto, uma resposta verdadeiro/falso ou nada. Acertar isso é a diferença entre um código que funciona e um código que explode.

No tutorial anterior, você aprendeu a criar variáveis e a trabalhar com strings e números. Agora vamos mais fundo. Você vai conhecer todos os tipos de dados básicos do Python, aprender a verificá-los e a converter de um para outro, e evitar os erros mais comuns relacionados a tipos.

O que são tipos de dados em Python?

Um tipo de dado é um rótulo que diz ao Python que tipo de valor algo é. Ele determina quais operações você pode fazer com esse valor.

Pense nos recipientes de uma cozinha. Um copo medidor serve para líquidos. Uma balança pesa sólidos. Você não colocaria farinha num copo medidor esperando obter o peso exato. Cada recipiente foi feito para um tipo específico de coisa.

O Python tem cinco tipos de dados básicos que você vai usar todos os dias:

Os cinco tipos de dados básicos do Python

# The five core data types

age = 25 # int - whole numbers

temperature = 98.6 # float - decimal numbers

name = "Alice" # str - text

is_sunny = True # bool - True or False

result = None # None - absence of a value

print(type(age)) # <class 'int'>

print(type(temperature)) # <class 'float'>

print(type(name)) # <class 'str'>

print(type(is_sunny)) # <class 'bool'>

print(type(result)) # <class 'NoneType'>

Saída

<class 'int'>
<class 'float'>
<class 'str'>
<class 'bool'>
<class 'NoneType'>

A função type() é sua melhor amiga quando você trabalha com tipos de dados. Ela diz exatamente com que tipo de valor você está lidando. Quando o código não funciona, verificar os tipos costuma ser o jeito mais rápido de achar o problema.

Como funcionam inteiros e floats em Python

O Python tem dois tipos de números: números inteiros (int), para números sem parte decimal, e números de ponto flutuante (float), para números com casas decimais. Na maior parte do tempo, você não precisa pensar na diferença. Mas às vezes ela importa muito.

Quando usar inteiros e quando usar floats

Use inteiros para valores que nunca têm parte decimal, como a contagem de pessoas, uma pontuação ou o índice de uma lista. Use floats para números que podem ter parte decimal, como medir temperatura, calcular porcentagens ou trabalhar com dinheiro.

Inteiros e floats

# Integers - whole numbers, no decimal point

students = 30

lives_remaining = 3

year = 2025

negative_number = -42

# Floats - numbers with a decimal point

pi = 3.14159

batting_average = 0.325

bank_balance = 1042.50

tiny_number = 0.001

print(type(students)) # <class 'int'>

print(type(bank_balance)) # <class 'float'>

Saída

<class 'int'>
<class 'float'>

Números grandes mais legíveis com sublinhados

Números grandes são difíceis de ler. 1000000 é um milhão ou dez milhões? O Python permite usar sublinhados (underscores) como separadores visuais. Ele ignora completamente os sublinhados: eles servem só para os seus olhos.

Sublinhados em números grandes

# Hard to read

population = 8000000000

# Easy to read - underscores are ignored by Python

population = 8_000_000_000

print(population) # 8000000000

print(type(population)) # <class 'int'>

# Works with floats too

budget = 1_250_000.75

print(budget) # 1250000.75

Saída

8000000000
<class 'int'>
1250000.75

O problema do 0.1 + 0.2 em Python

Aqui está algo que surpreende quase todo mundo na primeira vez. Experimente executar este código:

A surpresa do ponto flutuante

print(0.1 + 0.2)

Saída

0.30000000000000004

Você esperava 0.3, mas recebeu 0.30000000000000004. Isso não é um bug do Python. A maioria das linguagens de programação dá a mesma resposta, porque elas guardam números decimais do mesmo jeito.

Computadores guardam números em binário (uns e zeros). Alguns números decimais, como 0,1, não podem ser representados com exatidão em binário, assim como 1/3 não pode ser escrito com exatidão como decimal (0,333333... continua para sempre).

Como lidar com problemas de ponto flutuante

# The problem

print(0.1 + 0.2 == 0.3) # False!

# Solution 1: round() for display

print(round(0.1 + 0.2, 1)) # 0.3

# Solution 2: check if values are "close enough"

result = 0.1 + 0.2

print(abs(result - 0.3) < 0.0001) # True - close enough!

Saída

False
0.3
True

Mais um detalhe importante: a divisão comum (/) sempre produz um float, mesmo quando os dois números são inteiros e a divisão é exata.

A divisão sempre retorna um float

print(10 / 2) # 5.0 - float, not int!

print(type(10 / 2)) # <class 'float'>

# Use // for integer division

print(10 // 2) # 5 - int!

print(type(10 // 2)) # <class 'int'>

Saída

5.0
<class 'float'>
5
<class 'int'>

Como funcionam os booleanos em Python (True e False)

Um booleano é o tipo de dado mais simples do Python. Ele só pode ter um de dois valores: True ou False. Só isso.

Booleanos são como interruptores de luz: ligado ou desligado, sim ou não. Eles são a base de todas as decisões que o seu código toma. Toda instrução if, todo laço while, toda comparação se resume a um booleano.

Booleanos e comparações

is_raining = True

has_umbrella = False

print(is_raining) # True

print(type(is_raining)) # <class 'bool'>

# Comparisons produce booleans

print(10 > 5) # True

print(10 < 5) # False

print(10 == 10) # True

print(10 != 10) # False

Saída

True
<class 'bool'>
True
False
True
False

O que são valores truthy e falsy em Python?

Qualquer valor em Python pode ser tratado como booleano. Alguns valores contam como True (são chamados de "truthy") e outros contam como False (são chamados de "falsy"). Você pode testar qualquer valor passando-o para bool().

Valores truthy e falsy

# Falsy values - these all act like False

print(bool(0)) # False - zero

print(bool(0.0)) # False - zero float

print(bool("")) # False - empty string

print(bool(None)) # False - None

print(bool([])) # False - empty list

print("---")

# Truthy values - everything else acts like True

print(bool(1)) # True - any non-zero number

print(bool(-5)) # True - negative numbers too!

print(bool("hello")) # True - any non-empty string

print(bool("False")) # True - the STRING "False" is truthy!

print(bool([1, 2])) # True - non-empty list

Saída

False
False
False
False
False
---
True
True
True
True
True

Estes são os valores falsy que você mais vai encontrar. O padrão: False, None, o zero de qualquer tipo numérico e qualquer coisa vazia. Todo o resto é truthy:

Valor falsy	Tipo	Por que é falsy
`False`	bool	É literalmente False
`0`	int	Zero
`0.0`	float	Zero
`""`	str	String vazia
`None`	NoneType	Ausência de valor
`[]`	list	Lista vazia
`{}`	dict	Dicionário vazio
`()`	tuple	Tupla vazia
`set()`	set	Conjunto vazio

O que é None em Python?

None é o jeito do Python de dizer "não tem nada aqui". Não é zero. Não é uma string vazia. É a ausência total de um valor.

Pense num formulário com um campo "nome do meio". Se alguém deixa o campo em branco, isso é diferente de escrever o número 0 ou uma string vazia "". A pessoa só não tem nome do meio. Esse campo em branco é None.

None não é zero nem vazio

middle_name = None

print(middle_name) # None

print(type(middle_name)) # <class 'NoneType'>

# None is NOT the same as 0, False, or ""

print(None == 0) # False

print(None == False) # False

print(None == "") # False

Saída

None
<class 'NoneType'>
False
False
False

Como verificar se um valor é None em Python

Sempre use is None ou is not None para verificar se algo é None. Não use ==. Essa é uma convenção do Python com um motivo técnico real por trás.

Evite: == None

value = None

if value == None:
    print("No value")

Prefira: is None

value = None

if value is None:
    print("No value")

None como valor padrão

# Common pattern: using None as a default

def greet(name=None):

if name is None:

print("Hello, stranger!")

else:

print(f"Hello, {name}!")

greet() # Hello, stranger!

greet("Alice") # Hello, Alice!

Saída

Hello, stranger!
Hello, Alice!

Você vai ver None usado como valor padrão em funções o tempo todo. É um jeito limpo de dizer "este argumento é opcional".

Como verificar o tipo de uma variável em Python

O Python oferece duas ferramentas para verificar tipos: type() e isinstance(). Elas se parecem, mas servem a propósitos diferentes.

Usando type() para identificar um valor

type() informa o tipo exato de um valor. É ótima para depurar: quando algo não funciona, verificar o tipo muitas vezes revela o problema na hora.

Usando type() para inspecionar valores

print(type(42)) # <class 'int'>

print(type(3.14)) # <class 'float'>

print(type("hello")) # <class 'str'>

print(type(True)) # <class 'bool'>

print(type(None)) # <class 'NoneType'>

# You can compare types directly

age = 25

print(type(age) == int) # True

print(type(age) == str) # False

Saída

<class 'int'>
<class 'float'>
<class 'str'>
<class 'bool'>
<class 'NoneType'>
True
False

Usando isinstance() para verificar tipos

isinstance() verifica se um valor é de um certo tipo (ou de um entre vários tipos). É a forma preferida de verificar tipos em código real, porque funciona com herança e é mais legível.

isinstance(): a forma preferida de verificar tipos

age = 25

name = "Alice"

temperature = 98.6

# Check against one type

print(isinstance(age, int)) # True

print(isinstance(name, str)) # True

print(isinstance(age, str)) # False

# Check against multiple types at once

print(isinstance(age, (int, float))) # True - age is an int

print(isinstance(temperature, (int, float))) # True - temp is a float

print(isinstance(name, (int, float))) # False - name is a str

Saída

True
True
False
True
True
False

Uma curiosidade: em Python, os booleanos são na verdade uma subclasse dos inteiros. No fundo, True é 1 e False é 0.

A relação entre bool e int

# Booleans are secretly integers

print(isinstance(True, int)) # True - bool is a subclass of int!

print(isinstance(True, bool)) # True

# This means you can do math with booleans

print(True + True) # 2

print(True * 10) # 10

print(False + 42) # 42

Saída

True
True
2
10
42

Como converter entre tipos em Python

Às vezes você tem um valor de um tipo, mas precisa dele em outro. Um usuário digita a idade num formulário: ela chega como a string "25", mas você precisa do inteiro 25 para fazer contas. O Python oferece funções embutidas para converter entre tipos.

Convertendo com int(), float(), str() e bool()

Conversão de tipos: o básico

# str → int

age_text = "25"

age_number = int(age_text)

print(age_number + 5) # 30 - now we can do math!

# str → float

price_text = "9.99"

price = float(price_text)

print(price * 2) # 19.98

# int → str

score = 100

message = "Your score: " + str(score)

print(message) # Your score: 100

# int → float

whole = 42

decimal = float(whole)

print(decimal) # 42.0

# float → int (truncates - does NOT round!)

pi = 3.99

whole_pi = int(pi)

print(whole_pi) # 3 - the .99 is chopped off!

Saída

30
19.98
Your score: 100
42.0
3

Armadilhas comuns na conversão de tipos

Nem toda conversão funciona. O Python interrompe o programa com um ValueError se você tentar converter algo que não faz sentido.

Conversões que falham

# These work fine

print(int("42")) # 42

print(float("3.14")) # 3.14

print(str(100)) # "100"

# These will CRASH

try:

print(int("hello")) # ValueError! "hello" isn't a number

except ValueError as e:

print(f"Error: {e}")

try:

print(int("3.14")) # ValueError! int() can't handle decimals in strings

except ValueError as e:

print(f"Error: {e}")

# Fix: convert string to float first, then to int

print(int(float("3.14"))) # 3 - works!

Saída

42
3.14
100
Error: invalid literal for int() with base 10: 'hello'
Error: invalid literal for int() with base 10: '3.14'
3

Converter com bool() segue as regras de truthy/falsy que vimos antes:

Convertendo para bool

# bool() follows truthy/falsy rules

print(bool(1)) # True

print(bool(0)) # False

print(bool("text")) # True

print(bool("")) # False

print(bool(None)) # False

# Careful: the string "0" is truthy!

print(bool("0")) # True - it's a non-empty string!

Saída

True
False
True
False
False
True

Atribuição de variáveis em Python: atribuição múltipla e troca de valores

O Python tem alguns atalhos práticos para trabalhar com variáveis que a maioria das outras linguagens não tem. Não são só truques espertos: desenvolvedores profissionais usam esses atalhos todos os dias.

Atribuição múltipla em uma linha

Você pode atribuir valores a várias variáveis numa única linha. Isso é especialmente útil quando você tem um grupo de valores relacionados.

Atribuição múltipla

# Assign multiple variables at once

x, y, z = 10, 20, 30

print(x) # 10

print(y) # 20

print(z) # 30

# Great for related values

first_name, last_name, age = "Alice", "Smith", 25

print(f"{first_name} {last_name}, age {age}")

# Assign the same value to multiple variables

a = b = c = 0

print(a, b, c) # 0 0 0

Saída

10
20
30
Alice Smith, age 25
0 0 0

Trocando variáveis sem uma variável temporária

Na maioria das linguagens, trocar o valor de duas variáveis exige uma variável temporária. O Python tem um jeito mais limpo.

Outras linguagens: precisam de uma variável temporária

a = 1
b = 2

# Need a third variable to hold the value
temp = a
a = b
b = temp
print(a, b)  # 2 1

Python: troca em uma linha

a = 1
b = 2

# Python handles the swap in one step
a, b = b, a
print(a, b)  # 2 1

A linha a, b = b, a funciona porque o Python avalia primeiro todo o lado direito (b, a vira 2, 1) e depois atribui esses valores ao lado esquerdo. Nenhuma variável temporária é necessária.

Exercícios práticos

Hora de pôr seu conhecimento à prova! Estes exercícios cobrem tudo o que você viu neste tutorial. Eles vão do mais fácil ao mais difícil.

Lembre-se: quebrar a cabeça faz parte do aprendizado. Tente cada exercício antes de espiar as dicas. Leia as mensagens de erro com atenção: elas costumam dizer exatamente o que deu errado.

Exercício 1: crie variáveis de cada tipo

Escreva o código

Crie uma variável de cada tipo básico do Python e exiba o tipo dela. A saída deve ser exatamente:

<class 'int'>
<class 'float'>
<class 'str'>
<class 'bool'>
<class 'NoneType'>

Você pode dar qualquer nome e qualquer valor às variáveis, desde que os tipos estejam certos.

# Create one variable of each type

# Print the type of each variable

Exercício 2: conversor de temperatura

Escreva o código

Converta uma temperatura de Fahrenheit para Celsius.

A fórmula é: **Celsius = (Fahrenheit - 32) * 5 / 9**

A variável fahrenheit já vem com o valor 98.6. Calcule o equivalente em Celsius e exiba o resultado exatamente neste formato:

98.6F = 37.0C

fahrenheit = 98.6

# Calculate celsius using the formula

# Print the result

Exercício 3: preveja a saída: truthy ou falsy?

Preveja a saída

Sem executar o código, preveja o que cada linha vai exibir. Depois execute para conferir suas respostas.

Escreva suas previsões como comentários e clique em Executar para conferir.

print(bool("")) # Your prediction:

print(bool(0)) # Your prediction:

print(bool("False")) # Your prediction:

print(bool(None)) # Your prediction:

print(bool(-1)) # Your prediction:

print(bool(" ")) # Your prediction:

Exercício 4: corrija o bug: erro ao juntar string e número

Corrija o erro

Este código deveria exibir um resumo do perfil de um usuário, mas ele quebra com um TypeError. Corrija o código para que ele exiba:

Name: Alice
Age: 25
Height: 5.6 feet

Você pode corrigir do jeito que preferir (f-strings, conversão com str() etc.).

name = "Alice"

age = 25

height = 5.6

print("Name: " + name)

print("Age: " + age)

print("Height: " + height + " feet")

Exercício 5: troque os valores de duas variáveis

Escreva o código

Você tem duas variáveis: a = 10 e b = 20. Troque os valores delas sem usar uma variável temporária e depois exiba as duas.

Saída esperada:

a = 20
b = 10

a = 10

b = 20

# Swap a and b without a temp variable

print(f"a = {a}")

print(f"b = {b}")

Exercício 6: uma cadeia de conversões de tipo

Escreva o código

Você recebe uma string price_text contendo "49" e um inteiro quantity igual a 3.

1. Converta price_text para inteiro

2. Calcule o total (preço vezes quantidade)

3. Exiba o resultado exatamente neste formato:

3 items at $49 each = $147 total

Use as variáveis originais: não escreva os números diretamente na instrução print.

price_text = "49"

quantity = 3

# Step 1: Convert price_text to an integer

# Step 2: Calculate the total

# Step 3: Print the formatted result

Resumo: variáveis e tipos de dados em Python

Aqui está uma referência rápida de tudo o que você aprendeu neste tutorial:

Tipo	Exemplo	O que guarda
`int`	`42`, `-7`, `1_000`	Números inteiros
`float`	`3.14`, `0.0`, `-2.5`	Números com casas decimais
`str`	`"hello"`, `'world'`	Texto
`bool`	`True`, `False`	Valores sim/não
`None`	`None`	Ausência de valor

Ferramentas principais:

Ferramenta	Para que serve	Exemplo
`type(x)`	Ver qual é o tipo de `x`	`type(42)` → `<class 'int'>`
`isinstance(x, int)`	Verificar se `x` é de um certo tipo	`isinstance(42, int)` → `True`
`int()`, `float()`, `str()`	Converter entre tipos	`int("42")` → `42`
`bool()`	Verificar se é truthy/falsy	`bool("")` → `False`
`a, b = 1, 2`	Atribuição múltipla	Atribuir várias variáveis de uma vez
`a, b = b, a`	Trocar valores	Sem variável temporária

O que vem a seguir?

No próximo tutorial, Números e matemática, você vai se aprofundar no sistema numérico do Python. Vai conhecer o módulo math, estratégias de arredondamento, formatação de números e como criar programas que fazem contas como um profissional.

O que são tipos de dados em Python?

Como funcionam inteiros e floats em Python

Quando usar inteiros e quando usar floats

Números grandes mais legíveis com sublinhados

O problema do 0.1 + 0.2 em Python

Como funcionam os booleanos em Python (True e False)

O que são valores truthy e falsy em Python?

O que é None em Python?

Como verificar se um valor é None em Python

Como verificar o tipo de uma variável em Python

Usando type() para identificar um valor

Usando isinstance() para verificar tipos

Como converter entre tipos em Python

Convertendo com int(), float(), str() e bool()

Armadilhas comuns na conversão de tipos

Atribuição de variáveis em Python: atribuição múltipla e troca de valores

Atribuição múltipla em uma linha

Trocando variáveis sem uma variável temporária

Exercícios práticos

Resumo: variáveis e tipos de dados em Python

O que vem a seguir?

Tutoriais relacionados