Saltearse al contenido

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.

with garantiza el __exit__ aunque el bloque falle, y por eso sustituye a un try/finally que todo el mundo olvida escribir.

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 recibe as.
  • __exit__ se ejecuta siempre: con éxito, con excepción o con return dentro del bloque.
  • Devolver True en __exit__ silencia la excepción; devolver False o None la propaga.
Coste de un bloque de contexto
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.

Para el 90 % de los casos no hace falta una clase: un generador decorado hace lo mismo.

from contextlib import contextmanager
@contextmanager
def 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 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 todo

La 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.

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.

  • Para una sola llamada. f = open(...); f.close() en tres líneas seguidas no necesita protocolo; el with sigue siendo mejor, pero no hace falta inventar uno.
  • Si la limpieza depende del resultado. El with no 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.

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 os
from contextlib import contextmanager
@contextmanager
def 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.

  • Ramalho, L. Fluent Python, 2ª ed. Capítulo 18: with, match y else.
  • CPython 3.13: Python/ceval.c (WITH_EXCEPT_START).
  • Mediciones: mediciones/03-05-08-iteracion.py.
  • 06 · Generadores: la base de @contextmanager.
  • 03 · Decoradores: la otra forma de envolver código.
  • 05 · Iterables: el with en los generadores de archivos.