Gestores de Contexto como Patrón

Los gestores de contexto garantizan la configuración y la limpieza de un bloque de código. La declaración with llama a __enter__/__exit__ (o @contextmanager yield) para que los recursos se liberen incluso cuando ocurren excepciones: los archivos se cierran, los bloqueos se liberan y las transacciones se revierten.

Receta

Tarjeta de referencia rápida - lista para copiar y pegar.

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()

Cuándo usar esto:

• Pares de adquisición/liberación - archivos, sockets, bloqueos, conexiones de base de datos
• Estado temporal - variables de entorno, niveles de registro, flags de características para un bloque
• Transacciones - confirmar al éxito, revertir ante excepción
• Medición de tiempo y perfilado - enter inicia el temporizador, exit registra la duración
• Suprimir errores esperados - contextlib.suppress(FileNotFoundError)

Ejemplo de Trabajo

Un gestor basado en clases para transacciones de base de datos más un @contextmanager para la medición de tiempo.

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  # no suprimir excepciones
 
@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("ruta feliz"):
    with Transaction(conn) as db:
        print("escribir filas", db)
 
print("confirmado:", conn.committed)
 
conn2 = FakeConnection()
try:
    with Transaction(conn2):
        raise ValueError("boom")
except ValueError:
    pass
print("revertido:", conn2.rolled_back)

Lo que esto demuestra:

• Protocolo de clase: __enter__ devuelve el recurso, __exit__ limpia
• Devolver False desde __exit__ propaga las excepciones después de la reversión
• @contextmanager divide la configuración (antes de yield) y la limpieza (finally)
• finally se ejecuta tanto si el bloque se sale normalmente como si es por una excepción

Inmersión Profunda

Cómo Funciona

• with expr as var: evalúa expr, llama a __enter__, vincula var, ejecuta la suite
• Al salir, __exit__(exc_type, exc_val, tb) siempre se ejecuta
• Si __exit__ devuelve un valor verdadero, la excepción se suprime
• @contextmanager envuelve un generador: el código antes de yield es la entrada, el de después es la salida
• contextlib.ExitStack compone múltiples gestores sin anidamiento profundo

Tipos Comunes de Gestores

Notas de 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 se cierran al salir
 
with suppress(FileNotFoundError):
    open("optional.cfg").read()

Errores Comunes

• Olvidar finally en generadores - la limpieza debe estar en finally alrededor de yield, no solo después si tiene éxito. Solución: siempre envolver el código posterior a yield en try/finally.
• Suprimir excepciones accidentalmente - que __exit__ devuelva True oculta errores. Solución: devolver False a menos que la supresión sea intencional (documentarlo).
• Bloqueos reentrantes - no todos los gestores son reentrantes; anidar el mismo bloqueo incorrectamente causa interbloqueo. Solución: usar threading.RLock o documentar la no reentrancia.
• Generar solo una vez - @contextmanager debe generar exactamente un valor. Solución: no generar en un bucle.
• Fuga de recursos ante fallo de __enter__ - si la configuración tiene éxito parcialmente y luego falla, la salida puede no ejecutarse. Solución: usar ExitStack o mantener la configuración mínima en __enter__.

Alternativas

Preguntas Frecuentes

Relacionado

• EAFP vs LBYL - excepciones dentro de bloques gestionados
• Patrones Factory y Builder - construcción de recursos
• Inyección de Dependencias en Python - inyección de conexiones
• Conceptos Básicos de Patrones Pythonicos - resumen de la sección

Versiones de Stack: Esta página fue escrita para Python 3.14.0 (estable 3.14, mantenimiento 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+, y uv 0.6+.