Mis apuntes · Aprende Python desde PHP

Se guardan solos en este navegador mientras escribes. Puedes usar Markdown. Al descargarlos, la primera línea es tu enlace personal al curso.

Lección 29 de 47 · Errores y funciones ✦ WebMCP implementado

Gestores de contexto: with y __enter__

9 min de lectura 4 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.
contextlib = inglés context (contexto) + lib (library, biblioteca)
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(); }.

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:

PHP 8.5index.php
<?php
declare(strict_types=1);

$flujo = fopen("php://memory", "w+");
try {
    fwrite($flujo, "Comprar pan" . PHP_EOL);
    fwrite($flujo, "Llamar al banco" . PHP_EOL);
    rewind($flujo);
    echo stream_get_contents($flujo);
} finally {
    fclose($flujo);
}
Pythonmain.py
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
class Candado:
    def __init__(self, nombre):
        self.nombre = nombre

    def __enter__(self):
        print(f"cojo el candado {self.nombre}")
        return self

    def __exit__(self, tipo, error, traza):
        print(f"suelto el candado {self.nombre}")
        return False


with Candado("tareas") as candado:
    print("trabajo con", candado.nombre)

print("--- ahora con un error ---")

try:
    with Candado("tareas"):
        print("voy a fallar")
        raise ValueError("algo salió mal")
except ValueError as 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
TrueEl error se traga: el programa sigue después del with
Pythonmain.py
class IgnoraValueError:
    def __enter__(self):
        return self

    def __exit__(self, tipo, error, traza):
        return tipo is not None and issubclass(tipo, ValueError)


with IgnoraValueError():
    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__.

Pythonmain.py
from contextlib import contextmanager


@contextmanager
def bloque(nombre):
    print(f"empiezo {nombre}")
    try:
        yield nombre.upper()
    finally:
        print(f"termino {nombre}")


with bloque("tareas") as nombre:
    print("dentro:", nombre)

try:
    with bloque("fallo"):
        raise RuntimeError("ups")
except RuntimeError as error:
    print("atrapado:", error)
  1. Todo lo que va antes del yield se ejecuta al entrar.
  2. El valor del yield es lo que recibe as nombre.
  3. 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.
  4. 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


@contextmanager
def cronometro(etiqueta):
    inicio = time.perf_counter()
    try:
        yield
    finally:
        segundos = time.perf_counter() - inicio
        print(f"{etiqueta}: terminado ({segundos < 5})")


with cronometro("guardar tareas"):
    tareas = [f"tarea {n}" for n in range(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]); }
with suppress(KeyError):
    del tareas[9]
    print("esto no se imprime")

with suppress(KeyError):
    del tareas[1]

print(tareas)
PHP 8.5index.php
<?php
declare(strict_types=1);

$tareas = [1 => "Comprar pan", 2 => "Llamar al banco"];

try {
    if (!array_key_exists(9, $tareas)) {
        throw new OutOfBoundsException("no existe");
    }
    unset($tareas[9]);
} catch (OutOfBoundsException) {
}
print_r($tareas);
Pythonmain.py
from contextlib import suppress

tareas = {1: "Comprar pan", 2: "Llamar al banco"}

with suppress(KeyError):
    del tareas[9]

print(tareas)
GestorPara qué sirveEn PHP
open(ruta)Cierra el fichero al salirfopen + finally { fclose }
suppress(KeyError)Ignora ese error y sigue después del withtry { ... } catch (X) {}
threading.Lock()Coge y suelta un candado (módulo 08)flock() + finally
sqlite3.connect()Confirma (commit) o deshace (rollback) la transacciónbeginTransaction() + commit() + rollBack()
tempfile.TemporaryDirectory()Borra la carpeta temporal al salirsys_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.

PHPPythonQuié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 tryAutomático al salir del withEl que abre el recurso, una sola vez
No existe__enter__() devuelve el valor de asEl bloque with
try / catch vacíosuppress(Tipo) o __exit__ que devuelve TrueSolo el tipo que indicas

Hora de practicar

Retos · 0/4 resueltos

Reto 1 de 4

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

Resumen

Lo que te llevas de esta lección

  1. with recurso as x: cierra el recurso al salir, con o sin error (en PHP, try { ... } finally { fclose(); } a mano).
  2. Un gestor es un objeto con __enter__ (valor de as) y __exit__(tipo, error, traza); PHP no tiene ese contrato.
  3. Si __exit__ devuelve True, se traga el error; con False o None el error sigue subiendo (como un catch que relanza).
  4. @contextmanager + un yield dentro de try/finally crea un gestor sin clase; sin el finally, un error se salta la limpieza.
  5. 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.