Fluxo de Controle

Python expressa ramificação com if/elif/else, correspondência estrutural com match/case e iteração com for e while. Cláusulas else de loop e operadores booleanos de short-circuit são idiomatismos que valem a pena aprender cedo.

Receita

for index, item in enumerate(["a", "b", "c"], start=1):
    if item == "b":
        continue
    print(index, item)
 
match status:
    case 200:
        print("ok")
    case 404 | 410:
        print("ausente")
    case code if 500 <= code < 600:
        print("erro no servidor")

Quando usar isso:

• Ramificação em enums, códigos HTTP ou tipos de comando
• Desestruturação de dados JSON aninhados com match
• Varredura de sequências com saída antecipada (break)
• Combinação de múltiplos iteráveis com zip

Exemplo de Trabalho

from dataclasses import dataclass
 
@dataclass
class Event:
    kind: str
    payload: dict[str, object]
 
def handle(event: Event) -> str:
    match event:
        case Event(kind="user.created", payload={"id": int(uid), "email": str(email)}):
            return f"provisionar {uid} para {email}"
        case Event(kind="user.deleted", payload={"id": int(uid)}):
            return f"limpar {uid}"
        case Event(kind=k):
            return f"ignorado {k}"
        case _:
            return "desconhecido"
 
def find_first_negative(nums: list[int]) -> int | None:
    for n in nums:
        if n < 0:
            return n
    else:
        return None  # nenhum break ocorreu
 
def main() -> None:
    events = [
        Event("user.created", {"id": 1, "email": "a@example.com"}),
        Event("order.placed", {"id": 99}),
    ]
    for ev in events:
        print(handle(ev))
    print(find_first_negative([1, 2, 3]))
 
if __name__ == "__main__":
    main()

O que isso demonstra:

• match vincula variáveis (uid, email) enquanto corresponde à estrutura do dicionário
• Padrões de classe combinam restrições de tipo e atributo
• for/else retorna um sentinela quando nenhum break é atingido
• continue pula para a próxima iteração sem sair do loop

Mergulho Profundo

Como Funciona

• Veracidade impulsiona if - Objetos implementam __bool__ ou __len__.
• Correspondência de padrões - Introduzido em 3.10; os casos são verificados de cima para baixo; a primeira correspondência vence.
• Short-circuit - a and b avalia b apenas se a for verdadeiro; a or b pula b se a for verdadeiro.
• Protocolo de iteração - for chama iter() e depois next() repetidamente até StopIteration.
• while else - Mesmas semânticas de for else - executa quando o loop termina sem break.

Recursos do match em Resumo

Notas Python

# walrus := atribui dentro de expressões (3.8+)
if (line := input()) == "quit":
    pass
 
# zip strict=True (3.10+) levanta erro em comprimentos desiguais
for a, b in zip(xs, ys, strict=True):
    ...

Armadilhas

• Falta de break em while True - Loops infinitos travam workers. Correção: Condição de break explícita ou timeout.
• match sem fall-through - Não há fall-through automático entre casos (diferente do switch em C). Correção: Combinar com | ou lógica compartilhada.
• Confusão no loop else - else executa quando não há break, não em condição falsa. Correção: Comentar a intenção ou refatorar para funções.
• Modificar lista durante iteração - Pula elementos ou levanta erros. Correção: Iterar uma cópia ou construir uma nova lista.
• Contêineres vazios verdadeiros - [0] é verdadeiro porque não está vazio. Correção: Comparar comprimentos ou valores explicitamente quando necessário.

Alternativas

FAQs

Relacionados

• Compreensões e Expressões Geradoras - iteração sem loop
• Funções, Args e Escopo - retorno antecipado em vez de aninhamento profundo
• Enums - match em membros de enum
• Métodos Dunder / Mágicos - personalização da veracidade

Versões da Stack: Esta página foi escrita para Python 3.14.0 (estável 3.14, manutenção 3.13), FastAPI 0.115+, Django 5.2, Flask 3.1, Pydantic 2, PyTorch 2.6+, pandas 2.2+, Polars 1.x, ruff 0.9+, e uv 0.6+.