Tipos de Dados em Python: Um Guia Completo

Todo valor em Python tem um tipo de dado que informa ao interpretador que tipo de dado é e quais operações são permitidas sobre ele. Como Python é tipado dinamicamente, você nunca declara um tipo explicitamente — o interpretador o infere em tempo de execução. Entender os tipos embutidos é, portanto, essencial: escolher o tipo errado leva a bugs, cópias desnecessárias ou desempenho ruim.

Este capítulo aborda todos os tipos de dados embutidos:

Use a função embutida type() a qualquer momento para inspecionar que tipo um valor possui:

print(type(42))       # <class 'int'>
print(type(3.14))     # <class 'float'>
print(type("hello"))  # <class 'str'>
print(type(True))     # <class 'bool'>
print(type([1, 2]))   # <class 'list'>
print(type((1, 2)))   # <class 'tuple'>
print(type({1, 2}))   # <class 'set'>
print(type({"a": 1})) # <class 'dict'>
print(type(None))     # <class 'NoneType'>

Tipos Numéricos

Python possui três tipos numéricos: int, float e complex. Os três suportam os operadores aritméticos padrão (+, -, *, /, //, %, **).

int

Um int armazena um número inteiro de tamanho ilimitado — os inteiros do Python não são limitados a 32 ou 64 bits.

Operadores principais

Observe que / sempre retorna um float mesmo quando o resultado é um número inteiro. Use // quando precisar de um quociente inteiro.

Tipo de dado Integer em Python

# Integer addition
print(1 + 2)    # 3

# Integer subtraction
print(3 - 1)    # 2

# Integer multiplication
print(2 * 3)    # 6

# True division always returns float
print(6 / 2)    # 3.0

# Floor division returns int
print(7 // 2)   # 3

# Exponentiation
print(2 ** 10)  # 1024

float

Um float armazena um número decimal usando precisão dupla IEEE 754. Use floats sempre que precisar de valores fracionários.

Atenção — representação de ponto flutuante: 0.1 + 0.2 não é exatamente 0.3 em ponto flutuante binário. Use round() ou o módulo decimal quando a aritmética decimal exata for importante (por exemplo, moedas).

complex

Um número complex tem uma parte real e uma parte imaginária, escrito como a + bj em Python (usando j, não i). Números complexos são usados principalmente em computação científica, processamento de sinais e cálculos de engenharia.

str (Strings)

Um str é uma sequência imutável de caracteres Unicode. As strings podem ser delimitadas por aspas simples, aspas duplas ou aspas triplas (para strings de múltiplas linhas).

single = 'Hello'
double = "World"
multi  = """This spans
multiple lines."""

Operações comuns com strings

Métodos úteis de string

s = "  Hello World  "
print(s.strip())          # "Hello World"  — remove whitespace
print(s.strip().lower())  # "hello world"
print(s.strip().upper())  # "HELLO WORLD"
print("Hello World".split())   # ['Hello', 'World']
print(",".join(["a", "b", "c"]))  # a,b,c
print("Hello World".replace("World", "Python"))  # Hello Python
print(len("Hello"))       # 5

f-strings (literais de string formatados)

f-strings (introduzidos no Python 3.6) são a forma preferida de incorporar valores dentro de strings:

name = "Alice"
age  = 30
print(f"{name} is {age} years old.")   # Alice is 30 years old.
print(f"Next year she will be {age + 1}.")  # Next year she will be 31.

Como as strings são imutáveis, toda operação que "altera" uma string cria uma nova. Para mais informações sobre métodos de string, consulte o capítulo Python Strings.

bool (Boolean)

Um bool tem exatamente dois valores: True e False. Booleans são uma subclasse de int em Python — True é igual a 1 e False é igual a 0.

print(type(True))   # <class 'bool'>
print(True + 1)     # 2  (True is treated as 1)
print(False + 10)   # 10 (False is treated as 0)

Valores truthy e falsy

Todo objeto Python pode ser avaliado em um contexto boolean. Os seguintes valores são falsy (avaliam como False); todo o restante é truthy:

• False, None
• Zero numérico: 0, 0.0, 0j
• Sequências vazias: "", [], (), set()
• Mapeamento vazio: {}

print(bool(0))      # False
print(bool(""))     # False
print(bool([]))     # False
print(bool(None))   # False

print(bool(42))     # True
print(bool("hi"))   # True
print(bool([0]))    # True  — list with one item is truthy

Para um tratamento completo, consulte o capítulo Python Booleans.

list

Um list é uma sequência ordenada e mutável. Pode conter itens de qualquer tipo, incluindo uma mistura de tipos, e permite duplicatas.

# Creating a list
fruits = ["apple", "banana", "cherry"]

# Modifying an item
fruits[1] = "orange"
print(fruits)  # ['apple', 'orange', 'cherry']

# Adding items
fruits.append("mango")
print(fruits)  # ['apple', 'orange', 'cherry', 'mango']

# Removing an item
fruits.remove("orange")
print(fruits)  # ['apple', 'cherry', 'mango']

# Length
print(len(fruits))  # 3

Quando usar um list: quando você precisa de uma coleção ordenada que vai mudar — adicionar itens, remover itens ou atualizar valores in place. Para uma cobertura aprofundada, consulte o capítulo Python Lists.

tuple

Um tuple é uma sequência ordenada e imutável. Uma vez criado, seus elementos não podem ser alterados.

# Creating a tuple
coords = (10, 20)
print(coords[0])    # 10
print(len(coords))  # 2

# Tuple unpacking
x, y = coords
print(x, y)  # 10 20

# Single-element tuple needs a trailing comma
single = (42,)
print(type(single))  # <class 'tuple'>

Quando usar um tuple em vez de um list:

• Os dados não devem mudar (por exemplo, coordenadas GPS, valores de cor RGB, linhas de banco de dados).
• Você deseja usar o valor como chave de dicionário (lists não podem ser chaves de dict porque são mutáveis; tuples podem).
• Você deseja comunicar intenção: "esta sequência é fixa."

Para mais informações, consulte o capítulo Python Tuples.

set

Um set é uma coleção não ordenada de itens únicos. Valores duplicados são silenciosamente descartados na criação ou adição.

# Duplicates are automatically removed
unique = {1, 2, 2, 3, 3, 3}
print(unique)  # {1, 2, 3}

# Adding an item
unique.add(4)
print(unique)  # {1, 2, 3, 4}

# Membership test — O(1) average
print(3 in unique)  # True

# Set operations
a = {1, 2, 3}
b = {2, 3, 4}
print(a | b)  # {1, 2, 3, 4}  union
print(a & b)  # {2, 3}        intersection
print(a - b)  # {1}           difference

Quando usar um set: quando você precisa de testes de pertencimento rápidos ou deseja eliminar duplicatas de uma coleção. Para mais informações, consulte o capítulo Python Sets.

dict (Dicionário)

Um dict é um mapeamento não ordenado de pares chave-valor. A partir do Python 3.7, os dicionários preservam a ordem de inserção. As chaves devem ser únicas e imutáveis (strings e números são as escolhas mais comuns).

person = {"name": "John", "age": 32, "city": "New York"}

# Access by key
print(person["name"])  # John

# Add a key
person["country"] = "United States"
print(person)
# {'name': 'John', 'age': 32, 'city': 'New York', 'country': 'United States'}

# Remove a key
del person["city"]
print(person)
# {'name': 'John', 'age': 32, 'country': 'United States'}

# Safe access with a default value
print(person.get("email", "not provided"))  # not provided

# Iterate over keys and values
for key, value in person.items():
    print(f"{key}: {value}")

Quando usar um dict: quando os dados são naturalmente estruturados em chave-valor e você precisa de busca rápida por nome. Para mais informações, consulte o capítulo Python Dictionary Methods.

NoneType

None é o valor nulo do Python — representa a ausência de um valor. É a única instância de NoneType.

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

# Functions that do not explicitly return a value return None
def greet(name):
    print(f"Hello, {name}!")

x = greet("Alice")    # prints: Hello, Alice!
print(x)              # None

Sempre use is None (verificação de identidade) em vez de == None (verificação de igualdade):

if result is None:
    print("No result yet")

Mutabilidade em resumo

A mutabilidade determina se um valor pode ser alterado in place após a criação. Isso afeta a correção (aliasing acidental), o desempenho (cópia versus referência) e o que pode ser usado como chave de dict.

Conversão de tipos

Python fornece funções embutidas para converter entre tipos. Isso é chamado de conversão de tipo explícita (ou casting).

# To int
print(int("42"))      # 42
print(int(3.9))       # 3  (truncates, does not round)
print(int(True))      # 1

# To float
print(float(7))       # 7.0
print(float("3.14"))  # 3.14

# To str
print(str(3.14))      # '3.14'
print(str(True))      # 'True'

# Between sequences
print(list((1, 2, 3)))   # [1, 2, 3]
print(tuple([1, 2, 3]))  # (1, 2, 3)
print(set([1, 2, 2, 3])) # {1, 2, 3}

int() trunca (não arredonda): int(3.9) retorna 3, não 4. Use round() antes de int() se o arredondamento for necessário.

Para uma discussão completa das regras de casting, consulte o capítulo Python Casting.

Verificando um tipo no seu código

Use isinstance() (preferido) ou type() para verificações de tipo:

x = 42
print(isinstance(x, int))    # True
print(isinstance(x, float))  # False

# isinstance also works with a tuple of types
print(isinstance(x, (int, float)))  # True

Prefira isinstance() em vez de type(x) == int porque respeita a herança — um bool também é um int, portanto isinstance(True, int) retorna True, que é geralmente o que você deseja.

Resumo de referência rápida

* Ordem de inserção preservada a partir do Python 3.7+.

Prática