Context managers
with open(...) as f se aprende el primer día y se entiende el segundo año. El with no es una forma bonita de try/finally: es un protocolo con dos métodos que permite que cualquier objeto defina qué pasa al entrar y al salir. Eso convierte la limpieza de recursos en algo que se escribe una vez y no se puede olvidar.
En una línea
Sección titulada «En una línea»with garantiza el __exit__ aunque el bloque falle, y por eso sustituye a un try/finally que todo el mundo olvida escribir.
El protocolo
Sección titulada «El protocolo»class Transaccion: def __enter__(self): self.db.begin() return self
def __exit__(self, exc_type, exc_value, traceback): if exc_type is None: self.db.commit() else: self.db.rollback() return False # no silencia la excepción__enter__se ejecuta al entrar y su valor es el que recibeas.__exit__se ejecuta siempre: con éxito, con excepción o conreturndentro del bloque.- Devolver
Trueen__exit__silencia la excepción; devolverFalseoNonela propaga.
| Forma | Por bloque |
|---|---|
with con __enter__/__exit__ |
235 ns |
try/finally vacío |
15 ns |
python mediciones/03-05-08-iteracion.py
Quince veces más caro, y aun así son 235 nanosegundos: irrelevante fuera de un bucle de millones. Lo que compras con ese coste es que el cierre no dependa de que alguien se acuerde.
contextlib: no escribas la clase
Sección titulada «contextlib: no escribas la clase»En la mayoría de los casos no hace falta una clase: un generador decorado hace lo mismo.
from contextlib import contextmanager
@contextmanagerdef cronometrado(nombre): inicio = time.perf_counter() try: yield finally: print(f"{nombre}: {time.perf_counter() - inicio:.3f}s")Lo anterior al yield es __enter__; lo posterior, __exit__. Si el bloque lanza, la excepción se inyecta en el yield y el finally corre igual.
Otras tres herramientas que ahorran clases:
with contextlib.suppress(FileNotFoundError): os.remove("temporal.txt")
with contextlib.closing(recurso) as r: # llama a r.close() ...
with contextlib.ExitStack() as pila: # varios recursos dinámicos archivos = [pila.enter_context(open(f)) for f in rutas]ExitStack es la respuesta cuando el número de recursos no se conoce hasta ejecutar: abre N y los cierra todos en orden inverso.
El patrón de transacción
Sección titulada «El patrón de transacción»El uso más valioso no es cerrar archivos, es agrupar operaciones que deben ser atómicas:
with transaccion() as tx: tx.insertar(pedido) tx.insertar(lineas) tx.actualizar(stock) # si algo falla, rollback de todoLa lógica de commit/rollback vive en el context manager, no repartida por cada función. Es la razón por la que los ORMs lo usan.
Anidar y combinar
Sección titulada «Anidar y combinar»Varios with en una línea se ejecutan de izquierda a derecha al entrar y al revés al salir:
with open("a.txt") as a, open("b.txt") as b: ...Eso equivale a dos with anidados, y el orden de cierre importa cuando hay dependencias: si el segundo recurso depende del primero, debe cerrarse antes. La regla es la de la pila: lo último que se abre es lo primero que se cierra.
Si el segundo __enter__ lanza, el primero ya se abrió y su __exit__ se ejecuta: no queda a medias. Es la razón por la que with es preferible a un try/finally escrito a mano, donde ese caso se olvida con facilidad.
La trampa
Sección titulada «La trampa»Cuándo no aplica
Sección titulada «Cuándo no aplica»- Para una sola llamada.
f = open(...); f.close()en tres líneas seguidas no necesita protocolo; elwithsigue siendo mejor, pero no hace falta inventar uno. - Si la limpieza depende del resultado. El
withno distingue éxito de fallo salvo por la excepción; si la lógica es «commit si el valor es válido», eso es código normal. - Si oculta el flujo de control. Un context manager que abre conexiones de red y reintenta puede convertir un error claro en un timeout de treinta segundos.
Ejercicio
Sección titulada «Ejercicio»Escribe un context manager cambiando_directorio(ruta) que cambie el directorio de trabajo y lo restaure aunque el bloque lance una excepción. Hazlo primero con contextlib.contextmanager y explica qué pasaría si la restauración estuviera después del yield sin try/finally.
Solución
import osfrom contextlib import contextmanager
@contextmanagerdef cambiando_directorio(ruta): anterior = os.getcwd() os.chdir(ruta) try: yield finally: os.chdir(anterior)Sin el try/finally, una excepción dentro del bloque se inyecta en el yield y la línea siguiente no se ejecuta: el directorio quedaría cambiado para el resto del proceso. El finally garantiza la restauración.
Ese es exactamente el motivo por el que @contextmanager exige que envuelvas el yield si hay limpieza. El with garantiza llamar a __exit__, pero no que tu código de limpieza esté protegido: eso es responsabilidad de quien lo escribe.
La versión con clase sería equivalente, con __enter__ guardando os.getcwd() y __exit__ restaurando en un try/finally interno.
Comprobación con datos de ejemplo:
import tempfile
inicial = os.getcwd()with tempfile.TemporaryDirectory() as tmp: with cambiando_directorio(tmp): print("dentro:", os.path.samefile(os.getcwd(), tmp)) print("restaurado:", os.getcwd() == inicial) try: with cambiando_directorio(tmp): raise RuntimeError("fallo dentro del bloque") except RuntimeError as error: print("excepcion:", error) print("restaurado tras excepcion:", os.getcwd() == inicial) assert os.getcwd() == inicial, "el finally debe restaurar el directorio"Referencias
Sección titulada «Referencias»- Ramalho, L. Fluent Python, 2ª ed. Capítulo 18:
with,matchyelse. - CPython 3.13:
Python/ceval.c(WITH_EXCEPT_START). - Mediciones:
mediciones/03-05-08-iteracion.py.
Capítulos relacionados
Sección titulada «Capítulos relacionados»- 06 · Generadores: la base de
@contextmanager. - 03 · Decoradores: la otra forma de envolver código.
- 05 · Iterables: el
withen los generadores de archivos.