Python em poucas palavras

Python é uma linguagem de alto nível e de propósito geral, criada por Guido van Rossum e lançada em 1991. O nome vem do grupo de comédia Monty Python, e não da cobra. Ela suporta programação procedural, orientada a objetos e funcional, e a sintaxe usa indentação para delimitar blocos, o que obriga todo código a ter a mesma cara.

print("Olá, Python")

Olá, Python

Uma linha basta para um programa completo. Em Java, o equivalente exige uma classe, um método main e uma chamada longa. Essa economia é a primeira razão pela qual Python é uma boa primeira linguagem.

Compilado ou interpretado: os dois

A explicação popular diz que Python é "interpretado, linha por linha". Ela é útil para começar e errada em um detalhe que importa. O que o CPython (a implementação de referência) faz é:

1. Lê o arquivo inteiro e compila para bytecode, uma representação intermediária.
2. Executa esse bytecode na máquina virtual do Python.

Por isso um erro de sintaxe na última linha impede que a primeira linha rode. O Python nem chega a executar nada.

codigo = "print('primeira linha')\nprint('segunda linha'"

try:
    compile(codigo, "<exemplo>", "exec")
except SyntaxError as erro:
    print("Nada foi executado. Erro de sintaxe:", erro.msg)

Nada foi executado. Erro de sintaxe: '(' was never closed

Já os erros de lógica, de tipo e de valor só aparecem quando a linha problemática é executada:

def dividir(a, b):
    return a / b

print("esta linha roda normalmente")
try:
    dividir(1, 0)
except ZeroDivisionError as erro:
    print("erro só apareceu na execução:", erro)

esta linha roda normalmente
erro só apareceu na execução: division by zero

Se você quiser ver o bytecode, o módulo dis mostra. O resultado muda de versão para versão do Python, por isso eu não fixo a saída aqui. Rode no seu computador:

import dis


def soma(a, b):
    return a + b


dis.dis(soma)

Onde cada erro aparece

Guarde essa tabela. No capítulo de exceções eu mostro que os dois grupos pertencem à mesma família de classes, mas a diferença de quando o erro aparece continua valendo.

Onde Python entra no seu trabalho

Python aparece em automação e scripts, em análise de dados, em APIs e sistemas web (Django, Flask e FastAPI), em testes e em quase toda a camada de orquestração de projetos de inteligência artificial. Vale uma observação honesta sobre este último caso: as bibliotecas de IA fazem o trabalho pesado em código compilado (C, C++, CUDA), e Python é a cola que as conecta. Essa é a forma mais saudável de pensar na linguagem: ela é excelente para expressar a intenção e boa o bastante em desempenho quando o gargalo está em outra camada.

Qual versão instalar

Instale a série estável mais recente, que quando escrevi era a 3.14, e nunca baixe nada abaixo da 3.12 para um projeto novo. O Python 3.10 sai de suporte em outubro de 2026.

Uma regra que me poupa dor de cabeça: o Python que veio com o sistema é do sistema. Ele serve ao macOS ou à sua distribuição Linux, que dependem de uma versão específica. Para os seus projetos, instale um Python à parte.

Instalar por sistema operacional

brew install python
python3 --version

winget install 9NQ7512CXL7T

py install 3.14
py list
py --version

sudo apt update
sudo apt install python3 python3-pip python3-venv
python3 --version

sudo dnf install python3 python3-pip
python3 --version

sudo pacman -S python python-pip
python3 --version

Conferir a instalação

Antes de qualquer coisa, confirme a versão no terminal. Use python3 --version no macOS e no Linux, e py --version no Windows. Depois, rode este script, que mostra de onde o seu Python vem:

import platform
import sys

print("Versão:", platform.python_version())
print("Implementação:", platform.python_implementation())
print("Executável:", sys.executable)
print("Sistema:", platform.system())

Versão: 3.14.6
Implementação: CPython
Executável: /opt/homebrew/bin/python3
Sistema: Darwin

O bloco acima é um exemplo de um Mac com Homebrew. A sua saída vai variar, e é isso mesmo que você quer observar: o caminho do executável diz qual Python você está usando de fato.

Os comandos python, python3 e py

O modo interativo (REPL)

Digitar python3 (ou py) sem argumentos abre o modo interativo, ótimo para testar uma expressão rápida:

>>> 2 + 2
4
>>> "python".upper()
'PYTHON'
>>> exit()

O problema que o pyenv resolve

Um projeto antigo roda no Python 3.12, um novo pede 3.14, e a biblioteca que você testa só funciona na 3.13. O pyenv instala todas elas lado a lado e escolhe a versão certa conforme a pasta em que você está, usando um arquivo .python-version.

brew install pyenv
xcode-select --install

curl -fsSL https://pyenv.run | bash

sudo apt update
sudo apt install build-essential libssl-dev zlib1g-dev libbz2-dev \
  libreadline-dev libsqlite3-dev curl git libncursesw5-dev xz-utils \
  tk-dev libxml2-dev libxmlsec1-dev libffi-dev liblzma-dev

py list
py install 3.13

Ativar o pyenv no shell

No macOS e no Linux, o pyenv precisa interceptar o comando python. Adicione estas linhas ao ~/.zshrc (zsh) ou ao ~/.bashrc (bash) e abra um terminal novo:

export PYENV_ROOT="$HOME/.pyenv"
[[ -d $PYENV_ROOT/bin ]] && export PATH="$PYENV_ROOT/bin:$PATH"
eval "$(pyenv init -)"

Instalar e escolher versões

pyenv install --list | grep -E "^\s*3\.1[234]\."
pyenv install 3.13
pyenv versions
pyenv global 3.13

Dentro da pasta de um projeto, pyenv local grava o arquivo .python-version, que deve ir para o Git:

cd meu-projeto
pyenv local 3.12
python --version

O pyenv escolhe a versão ativa seguindo uma ordem de prioridade:

Para garantir no próprio código que a versão é a esperada, o script abaixo falha cedo e com uma mensagem clara:

import sys

assert sys.version_info >= (3, 12), "Este livro exige Python 3.12 ou superior"
print("versão ok")

versão ok

Por que um ambiente virtual

Se você instala tudo no mesmo Python, dois projetos que precisam de versões diferentes da mesma biblioteca se atropelam. Um ambiente virtual é uma pasta com um interpretador e um conjunto próprio de pacotes. Instalar ali não afeta nada fora dela.

Criar e ativar

Crie o ambiente dentro da pasta do projeto, com o nome .venv, que é a convenção que as ferramentas e os editores reconhecem sozinhos:

python3 -m venv .venv
source .venv/bin/activate
python --version

python3 -m venv .venv
source .venv/bin/activate
python --version

py -m venv .venv
.venv\Scripts\Activate.ps1
python --version

Como saber se você está dentro de um venv

O prompt do terminal ganha o prefixo (.venv). Dentro do Python, dá para checar comparando dois caminhos:

import sys

dentro_de_venv = sys.prefix != sys.base_prefix
print("Dentro de um venv:", dentro_de_venv)

Dentro de um venv: True

Dentro do ambiente virtual a saída é True. Fora dele, imprime False.

O pip

O pip instala pacotes do PyPI. Eu sempre uso python -m pip em vez de pip puro, porque assim o pip é obrigatoriamente o do interpretador ativo:

python -m pip install requests
python -m pip install "requests>=2.32,<3"
python -m pip list
python -m pip show requests
python -m pip uninstall requests

Para registrar as dependências e reinstalá-las em outra máquina:

python -m pip freeze > requirements.txt
python -m pip install -r requirements.txt

Especificadores de versão

A pasta .venv nunca vai para o Git. Coloque .venv/ no .gitignore. Quem clona o projeto recria o ambiente a partir da lista de dependências.

Aplicação não é biblioteca

Uma biblioteca (requests, por exemplo) você usa dentro do seu código, então ela mora no venv do projeto. Uma ferramenta de linha de comando (ruff, poetry, httpie) você executa no terminal em qualquer lugar. Instalar isso com pip global polui o Python e causa conflito. O pipx cria um venv por ferramenta e expõe só o comando.

Instalação

brew install pipx
pipx ensurepath

py -m pip install --user pipx
py -m pipx ensurepath

sudo apt install pipx
pipx ensurepath

sudo dnf install pipx
pipx ensurepath

O pipx ensurepath adiciona a pasta dos executáveis do pipx ao seu PATH. Feche e abra o terminal depois.

Uso no dia a dia

pipx install ruff
pipx list
pipx upgrade ruff
pipx upgrade-all
pipx uninstall ruff

Para rodar uma ferramenta uma única vez, sem instalar, use pipx run. Ela vive num ambiente temporário:

pipx run ruff --version

Para escolher a versão do Python que a ferramenta usa:

pipx install --python 3.13 ruff

Para adicionar um plugin ao ambiente de uma ferramenta já instalada, use pipx inject:

pipx inject poetry poetry-plugin-export

Quais ferramentas estão no seu PATH

O módulo shutil ajuda a ver, a partir do Python, o que está instalado e onde:

import shutil

for ferramenta in ["python3", "pipx", "uv", "poetry", "pyenv"]:
    caminho = shutil.which(ferramenta)
    situacao = f"instalado em {caminho}" if caminho else "não encontrado"
    print(f"{ferramenta:8} {situacao}")

python3  instalado em /opt/homebrew/bin/python3
pipx     instalado em /Users/ana/.local/bin/pipx
uv       instalado em /Users/ana/.local/bin/uv
poetry   instalado em /Users/ana/.local/bin/poetry
pyenv    não encontrado

O bloco acima é um exemplo. A sua saída depende do que você instalou.

O que o Poetry resolve

O pip instala. O Poetry gerencia: declara as dependências do projeto no pyproject.toml, resolve a árvore completa de dependências indiretas, grava as versões exatas em poetry.lock e cria o ambiente virtual para você. Dois colegas que rodam poetry install obtêm exatamente os mesmos pacotes.

Um ponto de atenção da versão 2: o Poetry passou a respeitar a seção [project] do pyproject.toml, que é o padrão da comunidade (PEP 621). O comando poetry shell foi movido para um plugin, e o substituto é poetry env activate.

Instalar

O caminho que eu recomendo é instalar o Poetry com o pipx, para que ele fique isolado:

pipx install poetry
poetry --version

O instalador oficial também funciona:

curl -sSL https://install.python-poetry.org | python3 -

curl -sSL https://install.python-poetry.org | python3 -

(Invoke-WebRequest -Uri https://install.python-poetry.org -UseBasicParsing).Content | py -

Criar um projeto

O Poetry cria a estrutura e o pyproject.toml. Nas versões atuais, o código já vai para a pasta src/ por padrão, que é o layout que eu recomendo no capítulo de empacotamento. A opção --src, que você ainda vê em tutoriais antigos, está sendo descontinuada justamente por ter virado o comportamento padrão:

poetry new meu-projeto
cd meu-projeto

Para transformar uma pasta existente em projeto Poetry, use poetry init, que faz perguntas no terminal. Depois de poetry add requests e poetry add --group dev pytest, o arquivo fica assim. Repare que o grupo de desenvolvimento vai para [dependency-groups], o mesmo padrão que o uv usa, e que os campos de autor vêm com valores de exemplo para você trocar:

[project]
name = "meu-projeto"
version = "0.1.0"
description = ""
authors = [
    {name = "Your Name",email = "you@example.com"}
]
readme = "README.md"
requires-python = ">=3.12"
dependencies = [
    "requests (>=2.34.2,<3.0.0)"
]

[tool.poetry]
packages = [{include = "meu_projeto", from = "src"}]

[build-system]
requires = ["poetry-core>=2.0.0,<3.0.0"]
build-backend = "poetry.core.masonry.api"

[dependency-groups]
dev = [
    "pytest (>=9.1.1,<10.0.0)"
]

Os comandos do dia a dia

poetry add requests
poetry add --group dev pytest
poetry remove requests
poetry install
poetry sync
poetry run python -m meu_projeto
poetry run pytest
poetry show --tree
poetry update
poetry lock

A diferença entre install e sync: o install garante que o necessário esteja instalado. O sync faz o ambiente ficar idêntico ao lockfile, removendo o que sobrar.

Ativar o ambiente

Você pode sempre usar poetry run, sem ativar nada. Se preferir ativar o ambiente na sua sessão, no Poetry 2 o comando imprime a instrução de ativação, e você a executa. No macOS e no Linux, eval $(poetry env activate) faz as duas coisas de uma vez:

poetry env activate
poetry env info --path
poetry env use 3.13

. /caminho/do/projeto/.venv/bin/activate

O bloco acima mostra o que o primeiro comando imprime em um projeto com .venv dentro da pasta.

Para que o Poetry crie o .venv dentro da pasta do projeto (o que os editores detectam sozinhos), configure uma vez:

poetry config virtualenvs.in-project true

Ler o pyproject.toml pelo Python

Desde o Python 3.11 existe o módulo tomllib na biblioteca padrão, que lê TOML:

import tomllib

texto = """
[project]
name = "meu-projeto"
dependencies = ["requests>=2.32"]
"""

dados = tomllib.loads(texto)
print(dados["project"]["name"])
print(dados["project"]["dependencies"])

meu-projeto
['requests>=2.32']

Por que eu uso o uv

O uv é feito pela Astral (os criadores do ruff) e escrito em Rust. O que me convenceu foi a combinação de três coisas: ele substitui pyenv, venv, pip, pipx e boa parte do Poetry; ele baixa Pythons prontos em vez de compilar; e ele tem uma interface compatível com o pip para quando você já tem um fluxo montado.

Instalar

curl -LsSf https://astral.sh/uv/install.sh | sh

curl -LsSf https://astral.sh/uv/install.sh | sh

powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

Também é possível instalar com pipx install uv ou pip install uv. Se você instalou pelo instalador oficial, atualize com:

uv self update

Gerenciar versões de Python

O uv baixa e guarda as versões que você pedir. Não precisa de compilador nem de Python prévio:

uv python install 3.12 3.13 3.14
uv python list
uv python pin 3.13

O uv python pin grava o arquivo .python-version na pasta, o mesmo arquivo que o pyenv usa.

Criar e gerenciar um projeto

uv init meu-app
cd meu-app
uv add requests
uv add --dev pytest
uv run python main.py
uv run pytest

O uv add altera o pyproject.toml e atualiza o arquivo uv.lock. O uv run garante que o ambiente exista e esteja em dia antes de executar, então você não precisa ativar nada. O pyproject.toml fica assim:

[project]
name = "meu-app"
version = "0.1.0"
description = "Exemplo de projeto gerenciado pelo uv"
readme = "README.md"
requires-python = ">=3.12"
dependencies = [
    "requests>=2.34.2",
]

[dependency-groups]
dev = [
    "pytest>=9.1.1",
]

Outros comandos que eu uso o tempo todo:

uv remove requests
uv sync
uv lock
uv tree

Scripts com dependências embutidas

Para um script solto que precisa de uma biblioteca, o uv aceita metadados no próprio arquivo (um padrão chamado PEP 723). Ele cria um ambiente temporário só para aquela execução:

# /// script
# requires-python = ">=3.12"
# dependencies = ["rich"]
# ///
from rich import print

print("[bold]Olá[/bold] de um script com dependências embutidas")

uv run exemplos/uv/script_inline.py

Para adicionar uma dependência a um script existente: uv add --script script.py requests.

Ferramentas de linha de comando

uv tool install ruff
uvx ruff check .
uv tool list
uv tool upgrade --all

O uvx é um atalho para uv tool run: roda a ferramenta num ambiente temporário, como o pipx run.

Compatibilidade com o pip

Se você já tem requirements.txt e não quer migrar agora, use a interface compatível:

uv venv
uv pip install -r requirements.txt

Comparação

Minha recomendação

Eu escolheria uv para projetos novos, porque ele cobre o ciclo inteiro com uma ferramenta só. Escolheria Poetry se o time já o usa e o poetry.lock está em produção: trocar de gerenciador por modismo é custo sem retorno. Escolheria pip e venv para aprender e para ambientes restritos em que só o Python do sistema está disponível: o que você aprende ali serve em todo o resto. Escolheria pyenv se eu precisasse de uma compilação específica do Python. Escolheria pipx para ferramentas globais em máquinas onde o uv não está disponível.

Editor

O VS Code com a extensão Python da Microsoft resolve a maior parte dos casos. Depois de abrir a pasta do projeto, escolha o interpretador pelo comando Python: Select Interpreter (a paleta de comandos abre com Ctrl+Shift+P, ou Cmd+Shift+P no macOS) e aponte para o .venv do projeto. O PyCharm é uma alternativa completa se você prefere um IDE.

A estrutura mínima de um projeto

meu-projeto/
  pyproject.toml
  README.md
  .python-version
  .gitignore
  src/
    meu_projeto/
      __init__.py
      __main__.py
  tests/
    test_basico.py

Todo ponto de entrada deve poder ser importado sem executar nada. O padrão é um main() protegido:

def main() -> None:
    print("projeto funcionando")


if __name__ == "__main__":
    main()

projeto funcionando

Explico o motivo dessa proteção no capítulo de módulos.

uv init meu-primeiro-projeto
cd meu-primeiro-projeto
uv python pin 3.13
uv add requests
uv run python -c "import sys; print(sys.prefix != sys.base_prefix)"

mkdir meu-primeiro-projeto && cd meu-primeiro-projeto
python3 -m venv .venv
source .venv/bin/activate
python -m pip install requests
python -c "import sys; print(sys.prefix != sys.base_prefix)"

Comentários

Comentários são notas para quem lê o código. O Python ignora tudo o que vem depois de um #, até o fim da linha.

# Comentário de uma linha
idade = 30  # comentário no fim da linha

"""
Isto é uma string de várias linhas.
O Python a avalia e descarta, mas ela não é um comentário de verdade.
"""
print(idade)

30

Python não tem comentário de várias linhas. O que as pessoas fazem é usar uma string de três aspas como se fosse comentário. Funciona, mas é uma string solta no código. Quando essa string é a primeira instrução de uma função, classe ou módulo, ela vira uma docstring, a documentação oficial daquele objeto:

def area_quadrado(lado):
    """Devolve a área de um quadrado de lado dado."""
    return lado * lado


print(area_quadrado.__doc__)

Devolve a área de um quadrado de lado dado.

Eu escrevo comentários para explicar por quê, nunca o quê. O código já diz o que faz. O comentário diz o motivo da decisão.

Variáveis são nomes

Em Python, idade = 30 não "guarda 30 dentro de idade". Ela cria o objeto inteiro 30 e faz o nome idade apontar para ele. O tipo pertence ao objeto, não ao nome. Por isso o mesmo nome pode apontar para tipos diferentes ao longo do programa:

nome = "Ana"
idade = 30
cidade = "Recife"
print(nome, idade, cidade)

valor = 10
print(type(valor))
valor = "dez"
print(type(valor))

Ana 30 Recife
<class 'int'>
<class 'str'>

Essa visão de etiqueta (nome apontando para objeto) vai ser decisiva quando chegarmos em listas e funções. Guarde-a.

Atribuições múltiplas e a troca de valores entre duas variáveis ficam naturais:

a, b = 1, 2
a, b = b, a
print(a, b)

x = y = 0
print(x, y)

2 1
0 0

Nomes válidos e convenções

Um nome começa com letra ou sublinhado, contém letras, números e sublinhados, diferencia maiúsculas de minúsculas e não pode ser uma palavra reservada. O módulo keyword conhece todas as palavras reservadas:

import keyword

print(keyword.iskeyword("class"))
print(keyword.iskeyword("nome"))
print(len(keyword.kwlist) > 30)

True
False
True

a, b = 3, 7
a, b = b, a
assert (a, b) == (7, 3)
print("ok")

ok

Os tipos básicos

print(type(42), type(3.14), type(3 + 4j), type("oi"), type(True), type(None))

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

Inteiros sem limite, decimais com limite

O int do Python cresce até a memória acabar. O underscore ajuda a ler números grandes:

print(2 ** 100)
print(1_000_000)

1267650600228229401496703205376
1000000

O float segue o padrão binário IEEE 754 e não representa exatamente a maioria das frações decimais. Isso vale para qualquer linguagem, e é o motivo pelo qual você nunca deve comparar dinheiro com ==:

from decimal import Decimal
import math

print(0.1 + 0.2)
print(math.isclose(0.1 + 0.2, 0.3))
print(Decimal("0.1") + Decimal("0.2"))

0.30000000000000004
True
0.3

Para comparar decimais use math.isclose. Para dinheiro, use Decimal (ou trabalhe com centavos em inteiros).

bool é um tipo de int

Por razões históricas, bool é uma subclasse de int. Isso explica uma pegadinha clássica e importa ao testar tipos:

print(True + True)
print(isinstance(True, int))

2
True

None

None é o único valor do tipo NoneType e significa "sem valor". A comparação correta é sempre com is:

resultado = None
print(resultado is None)

True

def tipo_de(valor):
    if valor is None:
        return "nulo"
    if isinstance(valor, bool):
        return "booleano"
    if isinstance(valor, int):
        return "inteiro"
    if isinstance(valor, float):
        return "decimal"
    if isinstance(valor, str):
        return "texto"
    return "outro"


assert tipo_de(True) == "booleano"
assert tipo_de(7) == "inteiro"
assert tipo_de(2.5) == "decimal"
assert tipo_de("a") == "texto"
assert tipo_de(None) == "nulo"
assert tipo_de([1]) == "outro"
print("ok")

ok

Índices e fatias

Cada caractere tem uma posição, que começa em zero. Índices negativos contam a partir do fim. A fatia [início:fim:passo] exclui o índice final:

texto = "Python"
print(texto[0], texto[-1], texto[1:4], texto[::-1])

P n yth nohtyP

Strings não mudam

Nenhuma operação altera uma string existente. Elas sempre criam uma nova:

try:
    texto[0] = "J"
except TypeError as erro:
    print(erro)

novo = "J" + texto[1:]
print(novo)

'str' object does not support item assignment
Jython

Os métodos do dia a dia

Estes são os métodos que eu uso toda semana. Todos devolvem uma string nova (ou outro valor) e deixam a original intacta:

frase = "  Aprender Python é divertido  "
print(frase.strip())
print(frase.strip().lower())
print(frase.strip().upper())
print(frase.strip().split())
print("-".join(["a", "b", "c"]))
print(frase.replace("Python", "Go").strip())
print(frase.find("Python"))
print(frase.strip().startswith("Aprender"))
print(frase.count("e"))
print("Python" in frase)

Aprender Python é divertido
aprender python é divertido
APRENDER PYTHON É DIVERTIDO
['Aprender', 'Python', 'é', 'divertido']
a-b-c
Aprender Go é divertido
11
True
3
True

O find devolve -1 quando não acha. O index faz o mesmo, mas levanta ValueError. Para decidir se uma string contém outra, use o operador in.

f-strings

As f-strings são a forma moderna de montar texto. Depois dos dois pontos vai o formato do valor:

nome = "Ana"
preco = 1234.5
quantidade = 3
print(f"{nome} comprou {quantidade} itens")
print(f"Preço: {preco:,.2f}")
print(f"Total: {preco * quantidade:.2f}")
print(f"[{nome:>8}] [{nome:<8}] [{nome:^8}]")
print(f"{quantidade=}")

Ana comprou 3 itens
Preço: 1,234.50
Total: 3703.50
[     Ana] [Ana     ] [  Ana   ]
quantidade=3

O formato :,.2f usa vírgula para milhares e ponto para decimais, que é o padrão americano. Para o formato brasileiro, troque os símbolos:

preco = 1234.5
americano = f"{preco:,.2f}"
brasileiro = americano.replace(",", "_").replace(".", ",").replace("_", ".")
print(brasileiro)

1.234,50

Para aplicações reais, o módulo locale ou a biblioteca Babel fazem isso por região. Para um script, a troca acima resolve.

Unicode e bytes

Uma string é uma sequência de pontos de código Unicode. Os bytes só entram quando você grava em disco ou envia pela rede, e aí a codificação importa:

print(ord("A"), chr(97))
palavra = "ação"
print(len(palavra))
dados = palavra.encode("utf-8")
print(dados)
print(len(dados))
print(dados.decode("utf-8"))

65 a
4
b'a\xc3\xa7\xc3\xa3o'
6
ação

A palavra ação tem 4 caracteres e ocupa 6 bytes em UTF-8, porque ç e ã usam dois bytes cada. Sempre diga a codificação explicitamente ao ler e gravar arquivos. Retomo isso no capítulo de arquivos.

def eh_palindromo(texto):
    limpo = texto.lower().replace(" ", "")
    return limpo == limpo[::-1]


assert eh_palindromo("Anotaram a data da maratona")
assert eh_palindromo("radar")
assert not eh_palindromo("python")
print("ok")

ok

def inverter_palavras(frase):
    return " ".join(frase.split()[::-1])


assert inverter_palavras("python é bom") == "bom é python"
print("ok")

ok

Conversão explícita

As funções int(), float(), str() e bool() convertem de forma explícita. Duas surpresas: int() trunca em direção ao zero, e round() arredonda para o número par mais próximo quando o valor está exatamente no meio:

print(int("42") + 1)
print(float("3.5") * 2)
print(str(10) + " anos")
print(int(3.9), int(-3.9))
print(round(3.5), round(4.5), round(3.14159, 2))

43
7.0
10 anos
3 -3
4 4 3.14

Quando o texto não é conversível, o Python levanta ValueError, e a mensagem diz exatamente qual era o valor:

try:
    int("abc")
except ValueError as erro:
    print(erro)

invalid literal for int() with base 10: 'abc'

Conversão implícita

O Python converte sozinho quando a conta pede, sempre para o tipo mais "largo". O operador / é um caso à parte: ele sempre devolve float, mesmo quando as duas pontas são inteiras. Para divisão inteira use //:

print(1 + 2.5)
print(True + 1)
print(type(6 / 2), type(6 // 2))

3.5
2
<class 'float'> <class 'int'>

Valores falsy

Em uma condição, o Python converte o valor com bool(). A regra é curta: valores "vazios" ou "zero" são falsos, e todo o resto é verdadeiro. Esta é a lista completa dos que você mais encontra:

valores = [None, False, 0, 0.0, "", [], (), {}, set(), range(0)]
print([bool(v) for v in valores])

[False, False, False, False, False, False, False, False, False, False]

Todos dão False. Repare que None está na lista, e é o falso mais frequente em código real. Já estes são verdadeiros, e surpreendem:

print(bool("0"), bool("False"), bool([0]), bool(" "))

True True True True

A string "0", a string "False", uma lista que contém zero e uma string com espaço são todas verdadeiras, porque não estão vazias.

Falsy não é o mesmo que None

O idioma if not valor mistura "vazio" com "zero" com "ausente". Quando a distinção importa, compare com None explicitamente:

def descricao(quantidade):
    if quantidade is None:
        return "não informado"
    if not quantidade:
        return "zero"
    return f"{quantidade} unidades"


print(descricao(None))
print(descricao(0))
print(descricao(5))

não informado
zero
5 unidades

Se eu escrevesse apenas if not quantidade, None e 0 caíam no mesmo ramo, e o sistema trataria "não informado" como "zero". Em estoque, isso é um bug de verdade.

def para_float(texto):
    return float(texto.replace(".", "").replace(",", "."))


assert para_float("12,5") == 12.5
assert para_float("1.234,56") == 1234.56
print("ok")

ok

print

O print aceita vários valores e dois parâmetros que eu uso muito: sep (separador) e end (o que vem no fim, a quebra de linha por padrão):

print("a", "b", "c", sep="-")
print("sem quebra", end=" ")
print("de linha")

a-b-c
sem quebra de linha

input

O input mostra uma pergunta, espera a pessoa digitar e devolve sempre uma string. Se você precisa de número, converta:

nome = input("Qual é o seu nome? ")
idade = int(input("Quantos anos você tem? "))
print(f"Olá, {nome}. Em 5 anos você terá {idade + 5} anos.")

Qual é o seu nome? Ana
Quantos anos você tem? 30
Olá, Ana. Em 5 anos você terá 35 anos.

Operadores aritméticos

print(10 / 3)
print(10 // 3)
print(-7 // 2)
print(10 % 3)
print(2 ** 8)
print(divmod(17, 5))

3.3333333333333335
3
-4
1
256
(3, 2)

Cuidado com -7 // 2: a divisão inteira arredonda para baixo, então o resultado é -4, e não -3. O divmod devolve quociente e resto de uma vez só.

Comparação e operadores lógicos

As comparações podem ser encadeadas, como na matemática:

x = 7
print(1 < x < 10)
print(x == 7.0)
print("a" < "b")

True
True
True

Os operadores and, or e not têm duas características que a maioria dos cursos não conta. Primeiro, and e or devolvem um dos operandos, não necessariamente True ou False. Segundo, eles fazem curto-circuito: param assim que o resultado está decidido.

nome = "" or "anônimo"
print(nome)
print(0 and 5)
print(3 and 5)
print(not [])

anônimo
0
5
True

O idioma valor or padrao é comum para definir um valor padrão. Use com cuidado: ele também troca 0 e "", que podem ser valores válidos.

Pertencimento e identidade

Os operadores in e not in perguntam se um item está em uma coleção. Os operadores is e is not perguntam se dois nomes apontam para o mesmo objeto. Use is apenas com None, True e False:

print("py" in "python", 3 not in [1, 2])
valor = None
print(valor is None, valor is not None)

True True
True False

Atribuição composta e o operador morsa

Os operadores +=, -=, *=, //= e companhia modificam e atribuem de uma vez. O operador := (chamado de morsa, disponível desde o Python 3.8) atribui dentro de uma expressão:

total = 10
total += 5
total *= 2
total //= 4
print(total)

if (n := len("python")) > 5:
    print(f"{n} caracteres")

7
6 caracteres

Quando uma expressão mistura operadores, a precedência decide a ordem: primeiro **, depois * / // %, depois + -, depois comparações, depois not, and e or. Eu nunca decoro a tabela inteira: uso parênteses sempre que a ordem não é óbvia à primeira leitura.

def decompor(segundos):
    horas, resto = divmod(segundos, 3600)
    minutos, segundos = divmod(resto, 60)
    return horas, minutos, segundos


assert decompor(3725) == (1, 2, 5)
assert decompor(59) == (0, 0, 59)
print("ok")

ok

if, elif e else

O Python testa as condições de cima para baixo e executa somente o primeiro bloco verdadeiro. A indentação define o bloco:

def classificar(nota):
    if nota >= 9:
        return "excelente"
    elif nota >= 7:
        return "bom"
    elif nota >= 5:
        return "regular"
    else:
        return "insuficiente"


print(classificar(9.5))
print(classificar(7))
print(classificar(5))
print(classificar(2))

excelente
bom
regular
insuficiente

Expressão condicional

Para escolher entre dois valores em uma linha, existe a forma valor_se_verdadeiro if condicao else valor_se_falso:

idade = 20
situacao = "adulto" if idade >= 18 else "menor"
print(situacao)

adulto

match: casamento de padrões

Desde o Python 3.10 existe o match, que é muito mais do que um switch. Ele casa a forma do dado, e pode capturar partes dele:

def responder(comando):
    match comando.split():
        case ["parar"]:
            return "parando"
        case ["mover", direcao]:
            return f"movendo para {direcao}"
        case ["mover", direcao, passos] if passos.isdigit():
            return f"movendo {passos} passos para {direcao}"
        case _:
            return "comando desconhecido"


print(responder("parar"))
print(responder("mover norte"))
print(responder("mover sul 3"))
print(responder("voar"))

parando
movendo para norte
movendo 3 passos para sul
comando desconhecido

O case _ é o caso padrão. Eu uso match quando o dado tem estrutura (comandos, mensagens, árvores). Para comparar um valor com poucas opções simples, if e elif continuam mais diretos.

Idiomas que deixam o código limpo

O retorno antecipado (guard clause) trata os casos de saída primeiro e deixa o caminho principal sem indentação extra:

def desconto(preco, cliente_vip):
    if preco <= 0:
        return 0
    if not cliente_vip:
        return 0
    return preco * 0.1


print(desconto(200, True))

20.0

def eh_bissexto(ano):
    return ano % 400 == 0 or (ano % 4 == 0 and ano % 100 != 0)


assert eh_bissexto(2024)
assert eh_bissexto(2000)
assert not eh_bissexto(1900)
assert not eh_bissexto(2023)
print("ok")

ok

def descrever(temperatura):
    if temperatura < 10:
        return "frio"
    elif temperatura < 28:
        return "agradável"
    return "quente"


assert descrever(-5) == "frio"
assert descrever(25) == "agradável"
assert descrever(45) == "quente"
print("ok")

ok

for em qualquer iterável

O for do Python não conta: ele percorre os itens de qualquer objeto iterável (string, lista, arquivo, dicionário):

for letra in "abc":
    print(letra)

for fruta in ["maçã", "pera"]:
    print(fruta)

a
b
c
maçã
pera

range

Quando você precisa de uma sequência de números, use range. Ele aceita range(fim), range(inicio, fim) e range(inicio, fim, passo), e o fim nunca é incluído. Ele é preguiçoso: não cria a lista na memória. O list() abaixo serve só para mostrar o conteúdo:

print(list(range(5)))
print(list(range(1, 6)))
print(list(range(0, 10, 2)))
print(list(range(5, 0, -1)))

[0, 1, 2, 3, 4]
[1, 2, 3, 4, 5]
[0, 2, 4, 6, 8]
[5, 4, 3, 2, 1]

enumerate e zip

Não escreva for i in range(len(lista)) para obter a posição. O enumerate entrega posição e item juntos. O zip percorre duas sequências em paralelo:

nomes = ["Ana", "Bia", "Caio"]
for posicao, nome in enumerate(nomes, start=1):
    print(posicao, nome)

notas = [9, 8, 7]
for nome, nota in zip(nomes, notas):
    print(f"{nome}: {nota}")

1 Ana
2 Bia
3 Caio
Ana: 9
Bia: 8
Caio: 7

break, continue e else

O break encerra o laço. O continue pula para a próxima volta. O else do laço é pouco conhecido e muito útil: ele roda somente se o laço terminou sem break.

for numero in range(1, 11):
    if numero == 3:
        continue
    if numero == 6:
        break
    print(numero)
else:
    print("terminou sem break")

1
2
4
5

O else do laço brilha em buscas. Para saber se um número é primo, procure um divisor. Se achar, break. Se o laço acabar sem achar, o else confirma:

numero = 17
for divisor in range(2, numero):
    if numero % divisor == 0:
        print(f"{numero} não é primo")
        break
else:
    print(f"{numero} é primo")

17 é primo

Laços aninhados e padrões

Um laço dentro de outro executa o interno por completo a cada volta do externo. É a base de tabelas, matrizes e padrões desenhados com texto:

for linhas in range(1, 5):
    print("*" * linhas)

*
**
***
****

for i in range(1, 4):
    for j in range(1, 4):
        print(f"{i} x {j} = {i * j}", end="  ")
    print()

1 x 1 = 1  1 x 2 = 2  1 x 3 = 3  
2 x 1 = 2  2 x 2 = 4  2 x 3 = 6  
3 x 1 = 3  3 x 2 = 6  3 x 3 = 9  

A multiplicação de uma string por um inteiro ("*" * 3) repete o texto, e é o truque que evita um segundo laço em muitos desenhos.

def fatorial(n):
    resultado = 1
    for i in range(2, n + 1):
        resultado *= i
    return resultado


assert fatorial(5) == 120
assert fatorial(0) == 1
print("ok")

ok

def diamante(n):
    linhas = []
    for i in range(n):
        linhas.append(" " * (n - i - 1) + "*" * (2 * i + 1))
    for i in range(n - 2, -1, -1):
        linhas.append(" " * (n - i - 1) + "*" * (2 * i + 1))
    return linhas


assert diamante(3) == ["  *", " ***", "*****", " ***", "  *"]
print("\n".join(diamante(4)))

   *
  ***
 *****
*******
 *****
  ***
   *

def primos_ate(n):
    primos = []
    for candidato in range(2, n + 1):
        for divisor in range(2, candidato):
            if candidato % divisor == 0:
                break
        else:
            primos.append(candidato)
    return primos


assert primos_ate(20) == [2, 3, 5, 7, 11, 13, 17, 19]
print("ok")

ok

while

O while repete enquanto a condição for verdadeira. A condição precisa, em algum momento, virar falsa, caso contrário o programa nunca termina:

contagem = 3
while contagem > 0:
    print(contagem)
    contagem -= 1
print("Fogo!")

3
2
1
Fogo!

while True com break

Quando você não sabe quantas vezes vai repetir, o padrão while True com um break na saída é o mais claro. Ele é o jeito certo de validar entrada:

while True:
    texto = input("Digite um número positivo: ")
    if texto.isdigit() and int(texto) > 0:
        break
    print("Valor inválido, tente de novo.")
print(f"Você digitou {int(texto)}")

Digite um número positivo: abc
Valor inválido, tente de novo.
Digite um número positivo: -3
Valor inválido, tente de novo.
Digite um número positivo: 42
Você digitou 42

Dígitos de um número

A combinação de while com divmod(n, 10) extrai um dígito por vez, do último para o primeiro. É a base de somar dígitos, inverter números e testar palíndromos numéricos:

numero = 1234
while numero > 0:
    numero, digito = divmod(numero, 10)
    print(digito)

4
3
2
1

original = 12345
invertido = 0
while original > 0:
    original, digito = divmod(original, 10)
    invertido = invertido * 10 + digito
print(invertido)

54321

Um jogo de adivinhação

O módulo random sorteia números. O randint(1, 100) inclui os dois extremos:

import random

print(random.randint(1, 100) in range(1, 101))

True

No jogo abaixo eu fixei o segredo em 63 para a saída ser previsível. Troque por random.randint(1, 100) para jogar de verdade:

segredo = 63
tentativas = 0
while True:
    palpite = int(input("Seu palpite: "))
    tentativas += 1
    if palpite < segredo:
        print("Muito baixo")
    elif palpite > segredo:
        print("Muito alto")
    else:
        print(f"Acertou em {tentativas} tentativas")
        break

Seu palpite: 50
Muito baixo
Seu palpite: 75
Muito alto
Seu palpite: 63
Acertou em 3 tentativas

def soma_digitos(n):
    total = 0
    while n > 0:
        n, digito = divmod(n, 10)
        total += digito
    return total


assert soma_digitos(1234) == 10
assert soma_digitos(0) == 0
print("ok")

ok

def collatz(n):
    passos = 0
    while n != 1:
        n = n // 2 if n % 2 == 0 else 3 * n + 1
        passos += 1
    return passos


assert collatz(6) == 8
assert collatz(1) == 0
print("ok")

ok

Definir, chamar e devolver

Uma função se define com def, recebe parâmetros e devolve um valor com return. Se não houver return, ela devolve None:

def saudacao(nome):
    """Devolve uma saudação."""
    return f"Olá, {nome}!"


def sem_retorno():
    pass


print(saudacao("Ana"))
print(sem_retorno())

Olá, Ana!
None

Uma confusão comum: print mostra na tela, return devolve o valor para quem chamou. Uma função que só imprime não pode ter o resultado usado em outra conta.

Parâmetros e argumentos

Parâmetro é o nome na definição. Argumento é o valor passado na chamada. Há quatro formas de passar:

• Posicional: a ordem importa.
• Nomeada: nome=valor, em qualquer ordem.
• Padrão: o parâmetro tem um valor caso não seja passado.
• Somente posicional (/) e somente nomeado (*): você controla como a função pode ser chamada.

def criar_usuario(nome, /, email, *, ativo=True):
    return {"nome": nome, "email": email, "ativo": ativo}


print(criar_usuario("Ana", "ana@exemplo.com"))
print(criar_usuario("Bia", email="bia@exemplo.com", ativo=False))
try:
    criar_usuario(nome="Caio", email="c@exemplo.com")
except TypeError as erro:
    print(erro)

{'nome': 'Ana', 'email': 'ana@exemplo.com', 'ativo': True}
{'nome': 'Bia', 'email': 'bia@exemplo.com', 'ativo': False}
criar_usuario() got some positional-only arguments passed as keyword arguments: 'nome'

Eu uso parâmetros somente nomeados (depois do *) para opções booleanas, porque formatar(texto, True) não diz nada e formatar(texto, maiusculo=True) diz tudo.

*args e **kwargs

Para aceitar uma quantidade variável de argumentos, *args junta os posicionais em uma tupla e **kwargs junta os nomeados em um dicionário. Na chamada, o mesmo símbolo faz o caminho inverso: desempacota:

def somar(*numeros):
    return sum(numeros)


def descrever(**atributos):
    for chave, valor in atributos.items():
        print(f"{chave}: {valor}")


print(somar(1, 2, 3, 4))
descrever(nome="Ana", cidade="Recife")

valores = [10, 20, 30]
print(somar(*valores))
dados = {"nome": "Bia", "cidade": "Natal"}
descrever(**dados)

10
nome: Ana
cidade: Recife
60
nome: Bia
cidade: Natal

Vários valores de retorno

Uma função pode devolver uma tupla, e quem chama desempacota na hora:

def minimo_maximo(numeros):
    return min(numeros), max(numeros)


menor, maior = minimo_maximo([4, 8, 2, 9])
print(menor, maior)

2 9

Funções são objetos

Em Python, uma função é um valor como qualquer outro: pode ser guardada em variável e passada como argumento. Essa ideia é a base dos decoradores e da programação funcional que vêm no nível intermediário:

def aplicar(funcao, valor):
    return funcao(valor)


print(aplicar(len, "python"))
print(aplicar(str.upper, "python"))

6
PYTHON

Documentação e type hints

A docstring explica o contrato. As anotações de tipo (type hints) o tornam legível por ferramentas. O Python não verifica as anotações ao executar:

def soma(a: int, b: int) -> int:
    """Soma dois inteiros e devolve o resultado."""
    return a + b


print(soma(2, 3))
print(soma("a", "b"))

5
ab

A segunda chamada funciona e junta duas strings, apesar de a anotação dizer int. Quem verifica é uma ferramenta externa, como o mypy, que eu apresento no nível intermediário.

def media(*numeros):
    return sum(numeros) / len(numeros)


assert media(10, 20, 30) == 20
assert media(5) == 5
print("ok")

ok

def formatar_nome(nome, sobrenome, *, maiusculo=False):
    completo = f"{nome} {sobrenome}"
    return completo.upper() if maiusculo else completo


assert formatar_nome("Ana", "Lima") == "Ana Lima"
assert formatar_nome("Ana", "Lima", maiusculo=True) == "ANA LIMA"
print("ok")

ok

Escopo: onde um nome vale

O Python procura um nome em quatro lugares, nesta ordem, que a comunidade chama de LEGB: Local (dentro da função), Enclosing (função externa), Global (módulo) e Built-in (nomes embutidos, como len).

mensagem = "global"


def externa():
    mensagem = "local da externa"

    def interna():
        print(mensagem)

    interna()
    print(mensagem)


externa()
print(mensagem)

local da externa
local da externa
global

Para alterar uma variável global dentro de uma função, é preciso declarar global. Eu evito: estado global torna o código difícil de testar e de entender. Prefira receber o valor como parâmetro e devolver o novo:

contador = 0


def incrementar():
    global contador
    contador += 1


incrementar()
incrementar()
print(contador)

2

UnboundLocalError

Se você atribui a um nome dentro da função, o Python o trata como local na função inteira, inclusive nas linhas anteriores à atribuição. Por isso o erro abaixo acontece mesmo existindo um total global:

total = 10


def quebrado():
    total += 1


try:
    quebrado()
except UnboundLocalError as erro:
    print(erro)

cannot access local variable 'total' where it is not associated with a value

O valor padrão mutável

Esta é a armadilha mais famosa da linguagem. O valor padrão de um parâmetro é criado uma única vez, quando a função é definida. Se for uma lista, todas as chamadas compartilham a mesma lista:

def adicionar(item, lista=[]):
    lista.append(item)
    return lista


print(adicionar(1))
print(adicionar(2))
print(adicionar.__defaults__)

[1]
[1, 2]
([1, 2],)

A segunda chamada devolve [1, 2], embora você não tenha passado lista nenhuma: o 1 ficou guardado no próprio valor padrão. A solução é usar None como sentinela e criar a lista dentro da função:

def adicionar_correto(item, lista=None):
    if lista is None:
        lista = []
    lista.append(item)
    return lista


print(adicionar_correto(1))
print(adicionar_correto(2))

[1]
[2]

A regra que eu sigo: nunca use lista, dicionário ou conjunto como valor padrão. Linters como o ruff acusam esse erro automaticamente (regra B006).

Efeitos colaterais

Uma função que altera os argumentos que recebe tem um efeito colateral. Isso não é proibido, mas deve ser explícito no nome e na documentação. Compare:

def ordenar_no_lugar(lista):
    lista.sort()


def ordenada(lista):
    return sorted(lista)


original = [3, 1, 2]
nova = ordenada(original)
print(original, nova)
ordenar_no_lugar(original)
print(original)

[3, 1, 2] [1, 2, 3]
[1, 2, 3]

Recursão

Uma função pode chamar a si mesma. Toda função recursiva precisa de um caso base que pare a recursão. O Python limita a profundidade (1000 chamadas por padrão) e não otimiza recursão de cauda, então para problemas profundos prefira um laço:

import sys


def fatorial(n):
    return 1 if n <= 1 else n * fatorial(n - 1)


print(fatorial(5))
print(sys.getrecursionlimit())


def sem_fim(n):
    return sem_fim(n + 1)


try:
    sem_fim(0)
except RecursionError:
    print("limite de recursão atingido")

120
1000
limite de recursão atingido

def registrar(evento, historico=[]):
    historico.append(evento)
    return historico

def registrar(evento, historico=None):
    if historico is None:
        historico = []
    historico.append(evento)
    return historico


assert registrar("a") == ["a"]
assert registrar("b") == ["b"]
assert registrar("c", ["x"]) == ["x", "c"]
print("ok")

ok

Criar, acessar e fatiar

Uma lista é uma sequência ordenada e mutável de itens de qualquer tipo. Os índices e as fatias funcionam como nas strings, mas aqui você pode alterar os itens:

frutas = ["maçã", "banana", "manga"]
print(frutas[0], frutas[-1], frutas[0:2])
frutas[1] = "uva"
print(frutas)

maçã manga ['maçã', 'banana']
['maçã', 'uva', 'manga']

Métodos principais

numeros = [3, 1, 4, 1, 5]
numeros.append(9)
numeros.insert(0, 0)
numeros.extend([2, 6])
print(numeros)
numeros.remove(1)
ultimo = numeros.pop()
print(numeros, ultimo)
print(numeros.index(4), numeros.count(1))

[0, 3, 1, 4, 1, 5, 9, 2, 6]
[0, 3, 4, 1, 5, 9, 2] 6
2 1

Quase todos os métodos que alteram a lista devolvem None. O erro clássico é escrever lista = lista.sort() e ficar com None. Compare com sorted(), que devolve uma lista nova e não mexe na original:

valores = [3, 1, 2]
print(sorted(valores))
print(valores)
resultado = valores.sort()
print(resultado, valores)
valores.sort(reverse=True)
print(valores)

[1, 2, 3]
[3, 1, 2]
None [1, 2, 3]
[3, 2, 1]

Atribuir não é copiar

b = a não cria uma lista nova: cria um segundo nome para a mesma lista. Para copiar, use copy(). E a cópia é rasa: os itens internos continuam compartilhados. Para listas dentro de listas, é preciso copy.deepcopy:

a = [1, 2, 3]
b = a
b.append(4)
print(a)
c = a.copy()
c.append(5)
print(a, c)

[1, 2, 3, 4]
[1, 2, 3, 4] [1, 2, 3, 4, 5]

import copy

matriz = [[1, 2], [3, 4]]
rasa = matriz.copy()
rasa[0][0] = 99
print(matriz)
profunda = copy.deepcopy(matriz)
profunda[0][0] = 0
print(matriz, profunda)

[[99, 2], [3, 4]]
[[99, 2], [3, 4]] [[0, 2], [3, 4]]

Operações úteis

n = [4, 8, 2, 9]
print(len(n), min(n), max(n), sum(n))
print(n + [1], n * 2)
print(8 in n)
print(list(reversed(n)))
del n[0]
print(n)
n[1:3] = [0, 0, 0]
print(n)

4 2 9 23
[4, 8, 2, 9, 1] [4, 8, 2, 9, 4, 8, 2, 9]
True
[9, 2, 8, 4]
[8, 2, 9]
[8, 0, 0, 0]

Pilha e fila

Uma lista funciona bem como pilha (último a entrar, primeiro a sair), com append e pop no fim, que são rápidos. Como fila, ela é ruim: pop(0) precisa deslocar todos os itens. Para filas, use collections.deque:

from collections import deque

pilha = []
pilha.append("a")
pilha.append("b")
print(pilha.pop())

fila = deque(["x", "y", "z"])
fila.append("w")
print(fila.popleft(), list(fila))

b
x ['y', 'z', 'w']

def segundo_maior(numeros):
    unicos = sorted(set(numeros))
    return unicos[-2]


assert segundo_maior([4, 8, 2, 9, 1]) == 8
assert segundo_maior([5, 5, 3]) == 3
print("ok")

ok

def esta_ordenada(numeros):
    return numeros == sorted(numeros)


assert esta_ordenada([1, 3, 5])
assert not esta_ordenada([3, 1, 4])
assert esta_ordenada([])
print("ok")

ok

Tuplas

Uma tupla é uma sequência imutável. Use para dados que formam um registro fixo (coordenadas, pares de valores, retornos de função):

dias = ("seg", "ter", "qua")
print(dias[0], len(dias))
try:
    dias[0] = "dom"
except TypeError as erro:
    print(erro)

seg 3
'tuple' object does not support item assignment

Uma pegadinha de sintaxe: o que forma a tupla é a vírgula, não o parêntese. Uma tupla de um elemento precisa da vírgula final:

um = (1,)
nao_tupla = (1)
print(type(um), type(nao_tupla))

<class 'tuple'> <class 'int'>

O desempacotamento é onde a tupla mais aparece. O * captura "o resto" em uma lista:

ponto = (3, 4)
x, y = ponto
primeiro, *resto = [10, 20, 30, 40]
print(x, y)
print(primeiro, resto)

3 4
10 [20, 30, 40]

Quando você quer uma tupla com nomes nos campos, use namedtuple:

from collections import namedtuple

Ponto = namedtuple("Ponto", ["x", "y"])
p = Ponto(3, 4)
print(p, p.x + p.y)

Ponto(x=3, y=4) 7

A imutabilidade da tupla é rasa: ela garante que os itens não sejam trocados, mas se um item for mutável, ele continua podendo mudar:

registro = ("ana", [1, 2])
registro[1].append(3)
print(registro)

('ana', [1, 2, 3])

Conjuntos

Um conjunto guarda itens únicos, sem ordem garantida, e responde "este item está aqui?" em tempo praticamente constante. As operações seguem a teoria dos conjuntos:

s = {1, 2, 2, 3, 3, 3}
print(s, len(s))
vazio = set()
print(type({}), type(vazio))
a = {1, 2, 3, 4}
b = {3, 4, 5, 6}
print(a | b, a & b, a - b, a ^ b)
print(3 in a)

{1, 2, 3} 3
<class 'dict'> <class 'set'>
{1, 2, 3, 4, 5, 6} {3, 4} {1, 2} {1, 2, 5, 6}
True

{} cria um dicionário vazio, não um conjunto. Para um conjunto vazio, use set().

Os itens de um conjunto precisam ser hashable, o que na prática significa imutáveis. Uma lista não pode entrar, mas uma tupla pode. O frozenset é a versão imutável do conjunto:

try:
    {[1, 2]}
except TypeError as erro:
    print(erro)

congelado = frozenset([1, 2])
print(congelado)

unhashable type: 'list'
frozenset({1, 2})

Qual estrutura usar

def sem_duplicados(itens):
    vistos = set()
    resultado = []
    for item in itens:
        if item not in vistos:
            vistos.add(item)
            resultado.append(item)
    return resultado


assert sem_duplicados([3, 1, 3, 2, 1]) == [3, 1, 2]
print("ok")

ok

def em_comum(a, b):
    return sorted(set(a) & set(b))


assert em_comum([1, 2, 3, 4], [3, 4, 5]) == [3, 4]
print("ok")

ok

Chaves e valores

Um dicionário guarda pares chave: valor. Desde o Python 3.7, ele preserva a ordem de inserção. As chaves precisam ser hashable (strings, números, tuplas) e únicas:

pessoa = {"nome": "Ana", "idade": 30}
print(pessoa["nome"])
pessoa["cidade"] = "Recife"
pessoa["idade"] = 31
del pessoa["nome"]
print(pessoa)

Ana
{'idade': 31, 'cidade': 'Recife'}

Acessar com segurança

Ler uma chave que não existe levanta KeyError. O método get devolve um valor padrão no lugar, e o operador in pergunta se a chave existe:

try:
    pessoa["email"]
except KeyError as erro:
    print("KeyError:", erro)
print(pessoa.get("email"))
print(pessoa.get("email", "sem email"))
print("idade" in pessoa)

KeyError: 'email'
None
sem email
True

Percorrer e alterar

estoque = {"maçã": 10, "pera": 0, "uva": 25}
for fruta, quantidade in estoque.items():
    print(f"{fruta}: {quantidade}")
print(list(estoque.keys()))
print(list(estoque.values()))
estoque.update({"pera": 5, "kiwi": 3})
print(estoque.pop("kiwi"))
print(estoque.setdefault("manga", 0))
print(estoque)

maçã: 10
pera: 0
uva: 25
['maçã', 'pera', 'uva']
[10, 0, 25]
3
0
{'maçã': 10, 'pera': 5, 'uva': 25, 'manga': 0}

Para juntar dois dicionários, o operador | (Python 3.9 ou superior) e o desempacotamento com ** dão o mesmo resultado, e em caso de chave repetida vence o da direita:

a = {"x": 1, "y": 2}
b = {"y": 20, "z": 30}
print(a | b)
print({**a, **b})

{'x': 1, 'y': 20, 'z': 30}
{'x': 1, 'y': 20, 'z': 30}

Contar e agrupar

Contar ocorrências é uma das tarefas mais comuns. A versão manual usa get. A biblioteca padrão tem ferramentas prontas, Counter e defaultdict:

from collections import Counter, defaultdict

palavras = ["a", "b", "a", "c", "b", "a"]

contagem = {}
for palavra in palavras:
    contagem[palavra] = contagem.get(palavra, 0) + 1
print(contagem)

print(Counter(palavras))
print(Counter(palavras).most_common(1))

por_inicial = defaultdict(list)
for nome in ["Ana", "Alice", "Bia", "Caio", "Beto"]:
    por_inicial[nome[0]].append(nome)
print(dict(por_inicial))

{'a': 3, 'b': 2, 'c': 1}
Counter({'a': 3, 'b': 2, 'c': 1})
[('a', 3)]
{'A': ['Ana', 'Alice'], 'B': ['Bia', 'Beto'], 'C': ['Caio']}

Dados aninhados

Dicionários e listas se combinam livremente. É assim que chegam os dados de uma API em JSON:

pedido = {
    "cliente": "Ana",
    "itens": [
        {"produto": "caneta", "qtd": 2},
        {"produto": "caderno", "qtd": 1},
    ],
}
total_itens = 0
for item in pedido["itens"]:
    total_itens += item["qtd"]
print(total_itens)

3

def frequencia(itens):
    resultado = {}
    for item in itens:
        resultado[item] = resultado.get(item, 0) + 1
    return resultado


assert frequencia(["a", "b", "a", "c", "b", "a"]) == {"a": 3, "b": 2, "c": 1}
print("ok")

ok

def somar_dicts(d1, d2):
    resultado = dict(d1)
    for chave, valor in d2.items():
        resultado[chave] = resultado.get(chave, 0) + valor
    return resultado


assert somar_dicts({"a": 5, "b": 3}, {"b": 4, "c": 2}) == {"a": 5, "b": 7, "c": 2}
print("ok")

ok

Nomes, objetos e id

Lembra da etiqueta do primeiro capítulo? Cada objeto tem uma identidade (o id), e dois nomes podem apontar para o mesmo objeto. O operador == compara valores. O operador is compara identidades:

a = [1, 2]
b = [1, 2]
c = a
print(a == b, a is b, a is c)
print(id(a) == id(c))