Gerenciadores de Contexto como um Padrão

Gerenciadores de contexto garantem a configuração e a limpeza em torno de um bloco de código. A instrução with chama __enter__/__exit__ (ou @contextmanager yield) para que os recursos sejam liberados mesmo quando exceções ocorrem - arquivos são fechados, locks são liberados e transações são desfeitas.

Receita

Cartão de receita de referência rápida - pronto para copiar e colar.

from contextlib import contextmanager
 
@contextmanager
def temporary_setting(obj, attr, value):
    old = getattr(obj, attr)
    setattr(obj, attr, value)
    try:
        yield obj
    finally:
        setattr(obj, attr, old)
 
with temporary_setting(config, "debug", True):
    run_checks()

Quando usar isso:

• Pares de aquisição/liberação - arquivos, sockets, locks, conexões de banco de dados
• Estado temporário - variáveis de ambiente, níveis de log, flags de recursos para um bloco
• Transações - commit em caso de sucesso, rollback em caso de exceção
• Tempo e profiling - enter inicia o timer, exit registra a duração
• Supressão de erros esperados - contextlib.suppress(FileNotFoundError)

Exemplo de Trabalho

Um gerenciador baseado em classe para transações de banco de dados mais um @contextmanager para medição de tempo.

import time
from contextlib import contextmanager
from dataclasses import dataclass, field
from typing import Iterator
 
@dataclass
class FakeConnection:
    committed: bool = False
    rolled_back: bool = False
 
    def commit(self) -> None:
        self.committed = True
 
    def rollback(self) -> None:
        self.rolled_back = True
 
class Transaction:
    def __init__(self, conn: FakeConnection) -> None:
        self._conn = conn
 
    def __enter__(self) -> FakeConnection:
        return self._conn
 
    def __exit__(self, exc_type, exc, tb) -> bool:
        if exc_type is None:
            self._conn.commit()
        else:
            self._conn.rollback()
        return False  # não suprimir exceções
 
@contextmanager
def timer(label: str) -> Iterator[None]:
    start = time.perf_counter()
    try:
        yield
    finally:
        elapsed = time.perf_counter() - start
        print(f"{label}: {elapsed:.3f}s")
 
conn = FakeConnection()
 
with timer("caminho feliz"):
    with Transaction(conn) as db:
        print("escreve linhas", db)
 
print("commitado:", conn.committed)
 
conn2 = FakeConnection()
try:
    with Transaction(conn2):
        raise ValueError("boom")
except ValueError:
    pass
print("desfeito:", conn2.rolled_back)

O que isso demonstra:

• Protocolo de classe: __enter__ retorna o recurso, __exit__ limpa
• Retornar False de __exit__ propaga exceções após o rollback
• @contextmanager envolve um gerador: código antes do yield é a entrada, depois é a saída
• finally é executado quer o bloco saia normalmente ou por exceção

Mergulho Profundo

Como Funciona

• with expr as var: avalia expr, chama __enter__, vincula var, executa o bloco
• Na saída, __exit__(exc_type, exc_val, tb) é sempre executado
• Se __exit__ retornar um valor verdadeiro, a exceção é suprimida
• @contextmanager envolve um gerador: código antes do yield é a entrada, depois é a saída
• contextlib.ExitStack compõe múltiplos gerenciadores sem aninhamento profundo

Tipos Comuns de Gerenciadores

Notas Python

from contextlib import ExitStack, suppress
 
with ExitStack() as stack:
    f1 = stack.enter_context(open("a.txt"))
    f2 = stack.enter_context(open("b.txt"))
    # ambos fecham na saída
 
with suppress(FileNotFoundError):
    open("optional.cfg").read()

Armadilhas

• Esquecer finally em geradores - a limpeza deve estar em finally em torno do yield, não apenas depois dele em caso de sucesso. Correção: sempre envolva o código pós-yield em try/finally.
• Suprimir exceções acidentalmente - __exit__ retornando True esconde bugs. Correção: retorne False a menos que a supressão seja intencional (documente-a).
• Locks reentrantes - nem todos os gerenciadores são reentrantes; aninhar o mesmo lock incorretamente causa deadlock. Correção: use threading.RLock ou documente a não reentrância.
• Gerar apenas uma vez - @contextmanager deve gerar exatamente um valor. Correção: não gere em um loop.
• Vazamento de recurso em falha de __enter__ - se a configuração for parcialmente bem-sucedida e depois falhar, a saída pode não ser executada. Correção: use ExitStack ou mantenha a configuração mínima em __enter__.

Alternativas

FAQs

Relacionado

• EAFP vs LBYL - exceções dentro de blocos gerenciados
• Padrões Factory e Builder - construção de recursos
• Injeção de Dependência em Python - injeção de conexões
• Noções Básicas de Padrões Pythonicos - visão geral da seção

Versões de 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+.