Lección 29 de 47 · Errores y funciones✦ WebMCP implementado
Gestores de contexto: with y __enter__
9 min de lectura4 retos
Abrir algo (un fichero, una conexión, un candado) y acordarte de cerrarlo es de los fallos más típicos al programar. En PHP lo resuelves con try/finally y a mano; Python tiene with, que cierra por ti pase lo que pase. Aquí ves cómo funciona por dentro (__enter__ y __exit__) y cómo crear el tuyo.
¿De dónde vienen los nombres?
with = inglés with (con)
«Haz esto con este recurso abierto». Al salir del bloque, el recurso se cierra solo.
__enter__ = inglés enter (entrar), con guiones bajos dobles
El método que Python llama al entrar al with. Lo que devuelve es lo que va detrás de as.
__exit__ = inglés exit (salir), con guiones bajos dobles
El método que Python llama al salir del with, siempre: sin errores o con ellos.
El módulo de la biblioteca estándar con herramientas para crear gestores de contexto sin escribir una clase.
suppress = inglés suppress (suprimir, silenciar)
Un gestor que se traga un tipo de error concreto, sin escribir try/except/pass.
En 4 ideas
1/4
with recurso as x: abre un recurso y garantiza que se cierra al salir, haya o no un error. En PHP lo harías con un try { ... } finally { cerrar(); }.
Un gestor de contexto es cualquier objeto con __enter__ (al entrar) y __exit__ (al salir). PHP no tiene nada igual: lo más cercano son finally y __destruct().
@contextmanager convierte una función con un solo yield en un gestor: lo de antes del yield es la entrada y lo de después (en un finally) es la salida.
contextlib.suppress(KeyError) ignora un error concreto en una línea; es el try { ... } catch (...) {} vacío de PHP, pero explícito y limitado a un tipo.
1 · El problema: cerrar siempre lo que abres
Piensa en una nevera. Si la abres para coger la leche y te suena el teléfono, la nevera se queda abierta y se echa a perder todo. Lo correcto es cerrarla siempre, incluso si algo interrumpe. Con un fichero, una conexión a la base de datos o un candado pasa igual.
En PHP lo haces con try/finally: el finally corre pase lo que pase. Funciona, pero depende de que te acuerdes de escribirlo cada vez:
import io
with io.StringIO() as flujo:
flujo.write("Comprar pan\n")
flujo.write("Llamar al banco\n")
print(flujo.getvalue(), end="")
print("¿cerrado?", flujo.closed)
Lo que ves en Python: no hay fclose ni finally. Al salir del with, el flujo se cierra solo. Y como la última línea comprueba, flujo.closed vale True.
¿Por qué? · En PHP no existe
¿Por qué existe with? En PHP no existe
El fallo de PHP que evita: olvidarte del fclose() o del unlock(). Si cierras en la última línea de la función y una línea del medio lanza un error, la última no se ejecuta y el recurso se queda abierto. Con try/finally está resuelto, pero tienes que escribirlo tú, cada vez.
with mueve la limpieza al propio objeto: quien crea la clase Conexion decide una vez cómo se cierra, y todos los que la usan solo escriben with Conexion() as c:. No hay forma de olvidarlo.
Y ojo con __destruct(): en PHP se ejecuta cuando nadie usa ya el objeto, y no sabes cuándo exactamente. En Python, __del__ es todavía menos fiable (depende del intérprete). Por eso with marca el punto exacto de cierre.
2 · Por dentro: __enter__ y __exit__
Un gestor de contexto es una clase con dos métodos. Python llama a __enter__ al abrir el with y a __exit__ al cerrarlo. Mira el orden con un ejemplo que solo imprime:
Pythonmain.py
classCandado:
def__init__(self, nombre):
self.nombre = nombre
def__enter__(self):
print(f"cojo el candado {self.nombre}")
returnselfdef__exit__(self, tipo, error, traza):
print(f"suelto el candado {self.nombre}")
returnFalsewithCandado("tareas") as candado:
print("trabajo con", candado.nombre)
print("--- ahora con un error ---")
try:
withCandado("tareas"):
print("voy a fallar")
raiseValueError("algo salió mal")
exceptValueErroras error:
print("atrapado:", error)
Fíjate: en el segundo caso el candado se suelta aunque haya un error. Después, el error sigue su camino hasta el except.
__exit__ recibe tres argumentos: el tipo del error, el error y su traza (los tres valen None si no hubo error). Lo que devuelva decide qué pasa con el error:
__exit__ devuelve…
Qué ocurre con el error
False o None (lo normal)
El error sigue subiendo: el with solo limpia
True
El error se traga: el programa sigue después del with
Pythonmain.py
classIgnoraValueError:
def__enter__(self):
returnselfdef__exit__(self, tipo, error, traza):
return tipo isnotNoneandissubclass(tipo, ValueError)
withIgnoraValueError():
int("abc")
print("esta línea nunca se imprime")
print("el programa sigue")
3 · contextlib.contextmanager: un gestor sin clase
Escribir una clase con dos métodos para algo pequeño es mucho. El decorador @contextmanager deja escribir lo mismo con una función y un yield en medio: lo de antes del yield es el __enter__, lo de después es el __exit__.
Todo lo que va antes del yield se ejecuta al entrar.
El valor del yield es lo que recibe as nombre.
Lo que va después del yield se ejecuta al salir. Si el bloque lanza un error, el error aparece en el yield: por eso se escribe try/finally alrededor, para limpiar aunque haya error.
Sin try/finally, si el bloque falla, la limpieza no se ejecuta.
¿Por qué? · En PHP no existe
¿Por qué hay que escribir try/finally alrededor del yield?
Con @contextmanager, el yield hace de puerta: Python se queda en pausa ahí mientras corre el with. Si dentro hay un error, Python lo relanza justo en el yield, como si el bloque entero fuese una línea de tu función.
Sin try/finally, ese error corta la función y lo que va debajo del yield no se ejecuta: es el mismo fallo del fclose() olvidado de PHP. Con él, la limpieza corre siempre.
Un ejemplo útil de la app de tareas: medir cuánto tarda un bloque (usamos un reloj falso para que la salida sea siempre la misma):
Pythonmain.py
import time
from contextlib import contextmanager
@contextmanagerdefcronometro(etiqueta):
inicio = time.perf_counter()
try:
yieldfinally:
segundos = time.perf_counter() - inicio
print(f"{etiqueta}: terminado ({segundos < 5})")
withcronometro("guardar tareas"):
tareas = [f"tarea {n}"for n inrange(1000)]
4 · suppress y otros gestores de la biblioteca estándar
La biblioteca estándar trae varios ya hechos. El más cómodo para ignorar errores concretos es contextlib.suppress:
Pythonmain.py
from contextlib import suppress
tareas = {1: "Comprar pan", 2: "Llamar al banco"}
# En PHP: if (isset($tareas[9])) { unset($tareas[9]); }withsuppress(KeyError):
del tareas[9]
print("esto no se imprime")
withsuppress(KeyError):
del tareas[1]
print(tareas)
from contextlib import suppress
tareas = {1: "Comprar pan", 2: "Llamar al banco"}
withsuppress(KeyError):
del tareas[9]
print(tareas)
Gestor
Para qué sirve
En PHP
open(ruta)
Cierra el fichero al salir
fopen + finally { fclose }
suppress(KeyError)
Ignora ese error y sigue después del with
try { ... } catch (X) {}
threading.Lock()
Coge y suelta un candado (módulo 08)
flock() + finally
sqlite3.connect()
Confirma (commit) o deshace (rollback) la transacción
beginTransaction() + commit() + rollBack()
tempfile.TemporaryDirectory()
Borra la carpeta temporal al salir
sys_get_temp_dir() + borrar a mano
Equivalencia POO · PHP → Python
Los gestores de contexto no tienen equivalente directo en PHP. Esto es lo más cercano.
PHP
Python
Quién lo ve
try { ... } finally { ... }
with recurso:
El código dentro del bloque
__destruct()
__exit__() (y, solo de apoyo, __del__())
Se llama al salir del with, no cuando el objeto se olvida
fclose() al final del try
Automático al salir del with
El que abre el recurso, una sola vez
No existe
__enter__() devuelve el valor de as
El bloque with
try / catch vacío
suppress(Tipo) o __exit__ que devuelve True
Solo el tipo que indicas
Hora de practicar
Retos · 0/4 resueltos
Reto 1 de 4 · ✓ Resuelto
Entrar y salir
Completa la clase Registro para que sea un gestor de contexto: al entrar añade "entra" a la lista log y al salir añade "sale" (también si hay un error, sin tragárselo). Es un try { ... } finally { ... } de PHP, convertido en objeto.
Al pulsar Comprobar, unos tests ocultos prueban tu código en tu navegador, con Python 3.14.
Pythonmain.py · editable
Pista. Añade __enter__(self) que apunte "entra" y devuelva self, y __exit__(self, tipo, error, traza) que apunte "sale" y devuelva False.
Reto 2 de 4 · ✓ Resuelto
Un gestor con contextmanager
Escribe con @contextmanager el gestor bloque(log, nombre): al entrar añade "abre <nombre>" a log, y al salir (siempre, con o sin error) añade "cierra <nombre>". Debe dar nombre en el as.
Al pulsar Comprobar, unos tests ocultos prueban tu código en tu navegador, con Python 3.14.
Pythonmain.py · editable
Pista. Pon @contextmanager encima de la función; el yield nombre va dentro de un try y el log.append("cierra ...") en el finally.
Reto 3 de 4 · ✓ Resuelto
Borrar sin miedo
Escribe borra_si_existe(tareas, id): tareas es un diccionario {id: titulo}. Borra esa tarea con delsin comprobar antes si existe, usando contextlib.suppress(KeyError). Devuelve cuántas tareas quedan. Es el unset($tareas[$id]) de PHP, que no se queja si falta.
Al pulsar Comprobar, unos tests ocultos prueban tu código en tu navegador, con Python 3.14.
Pythonmain.py · editable
Pista.with suppress(KeyError): y dentro del tareas[id]; el return len(tareas) va fuera del with.
Reto 4 de 4 · ✓ Resuelto
Tragar solo un tipo de error
Escribe la clase IgnoraValueError, un gestor de contexto que se traga los ValueError pero deja pasar cualquier otro error (un TypeError, por ejemplo). Recuerda: __exit__ devuelve True para tragarse el error.
Al pulsar Comprobar, unos tests ocultos prueban tu código en tu navegador, con Python 3.14.
Pythonmain.py · editable
Pista.__exit__ debe devolver True solo si tipo no es None y es ValueError (o hijo): issubclass(tipo, ValueError).
Resumen
Lo que te llevas de esta lección
with recurso as x: cierra el recurso al salir, con o sin error (en PHP, try { ... } finally { fclose(); } a mano).
Un gestor es un objeto con __enter__ (valor de as) y __exit__(tipo, error, traza); PHP no tiene ese contrato.
Si __exit__ devuelve True, se traga el error; con False o None el error sigue subiendo (como un catch que relanza).
@contextmanager + un yield dentro de try/finally crea un gestor sin clase; sin el finally, un error se salta la limpieza.
suppress(KeyError) ignora un tipo de error de forma explícita (en PHP, un catch vacío).
Para recordarlo: «Entra, trabaja, sale»
EEntra __enter__ o lo de antes del yield
TTrabaja el bloque with
SSale __exit__ o el finally tras el yield
Un with siempre hace tres pasos: Entra, Trabaja y Sale, y el último nunca se salta. Como la nevera: la abres, coges la leche y la cierras.