¿Qué son los context managers y la sentencia with?

Question

Accepted Answer

Un **context manager** es un objeto que define lógica de configuración y de liberación, usado con la sentencia **`with`**. Garantiza que la limpieza (cerrar archivos, liberar locks, revertir transacciones) ocurra automáticamente — incluso si se produce un error.

## El problema que resuelve

```python
# ❌ manual cleanup — error-prone; if processing throws, the file never closes
f = open("file.txt")
data = f.read()
process(data)        # if this raises, f.close() below is skipped → leaked file handle
f.close()

# ✅ with statement — guarantees the file is closed, no matter what
with open("file.txt") as f:
    data = f.read()
    process(data)
# f is automatically closed here — even if process() raised an exception
```

El bloque `with` asegura que `f.close()` se ejecute cuando el bloque termina, ya sea normalmente o por una excepción — eliminando los recursos filtrados por una limpieza olvidada u omitida.

## Context managers comunes

```python
with open("f.txt") as f: ...           # files (auto-close)
with lock:                              # threading locks (auto-release)
    shared_resource += 1
with db.transaction():                  # DB transactions (auto-commit/rollback)
    ...
with open("a") as a, open("b") as b:    # multiple at once
    ...
```

## Escribir el tuyo — la forma con clase

```python
class Timer:
    def __enter__(self):                 # SETUP — runs at `with` entry
        self.start = time.perf_counter()
        return self                       # the value bound to `as`
    def __exit__(self, exc_type, exc_val, tb):  # TEARDOWN — runs at exit (even on error)
        print(f"took {time.perf_counter() - self.start:.3f}s")
        # return False → propagate any exception; True → suppress it

with Timer():
    do_work()
```

Un context manager implementa `__enter__` (configuración) y `__exit__` (limpieza, que recibe la información de cualquier excepción).

## La forma más fácil — contextlib

```python
from contextlib import contextmanager

@contextmanager
def timer():
    start = time.perf_counter()
    try:
        yield                            # everything before yield = setup; after = teardown
    finally:
        print(f"took {time.perf_counter() - start:.3f}s")

with timer():
    do_work()
```

El decorador `@contextmanager` convierte un generador en un context manager — configuración antes del `yield`, limpieza después (en `finally` por seguridad).

## Por qué es importante

Los context managers y `with` son la forma pythónica de manejar la **gestión de recursos de forma segura** — garantizando que los archivos se cierren, los locks se liberen, las conexiones se devuelvan y las transacciones se finalicen, incluso cuando ocurren excepciones.

Esto previene fugas de recursos y estados inconsistentes, una fuente común de errores con la limpieza manual.

Se usan constantemente (toda operación de archivo debería usar `with`), y saber escribir el tuyo propio (mediante `__enter__`/`__exit__` o el más simple `@contextmanager`) te permite encapsular cualquier patrón de configuración/liberación de forma limpia y confiable.