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.

En la mayoría 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.

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"
  • 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.