Cosa sono i gestori di contesto e l'istruzione with?

Question

Accepted Answer

Un **gestore di contesto** è un oggetto che definisce la logica di setup e teardown, utilizzato con l'istruzione **`with`**. Garantisce che la pulizia (chiusura dei file, rilascio dei lock, rollback delle transazioni) avvenga automaticamente — anche se si verifica un errore.

## Il problema che risolve

```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
```

Il blocco `with` assicura che `f.close()` venga eseguito quando il blocco esce, sia normalmente che tramite un'eccezione — eliminando le perdite di risorse da pulizia dimenticata o saltata.

## Gestori di contesto comuni

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

## Scrivere il tuo — il modo della classe

```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 gestore di contesto implementa `__enter__` (setup) e `__exit__` (pulizia, che riceve qualsiasi informazione sull'eccezione).

## Il modo più facile — 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()
```

Il decoratore `@contextmanager` trasforma un generatore in un gestore di contesto — setup prima di `yield`, pulizia dopo (in `finally` per la sicurezza).

## Perché è importante

I gestori di contesto e `with` sono il modo Pythonic per gestire **la gestione delle risorse in sicurezza** — garantendo che i file vengono chiusi, i lock rilasciati, le connessioni restituite e le transazioni finalizzate, anche quando si verificano eccezioni.

Ciò previene le perdite di risorse e stati incoerenti, una fonte comune di bug con la pulizia manuale.

Vengono utilizzati costantemente (ogni operazione su file dovrebbe usare `with`), e sapere come scrivere il tuo (tramite `__enter__`/`__exit__` o il più semplice `@contextmanager`) ti permette di incapsulare qualsiasi pattern di setup/teardown in modo pulito e affidabile.