Qu'est-ce que les gestionnaires de contexte et l'instruction with ?

Question

Accepted Answer

Un **gestionnaire de contexte** est un objet qui définit une logique de configuration et de nettoyage, utilisé avec l'instruction **`with`**. Il garantit que le nettoyage (fermeture des fichiers, libération des verrous, annulation des transactions) se produit automatiquement — même en cas d'erreur.

## Le problème qu'il résout

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

Le bloc `with` s'assure que `f.close()` s'exécute lorsque le bloc se termine, que ce soit normalement ou via une exception — éliminant les fuites de ressources causées par un nettoyage oublié ou ignoré.

## Les gestionnaires de contexte courants

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

## Écrire le vôtre — la méthode par 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 gestionnaire de contexte implémente `__enter__` (configuration) et `__exit__` (nettoyage, qui reçoit les informations d'exception).

## Le moyen plus simple — 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()
```

Le décorateur `@contextmanager` transforme un générateur en gestionnaire de contexte — configuration avant `yield`, nettoyage après (en `finally` pour la sécurité).

## Pourquoi c'est important

Les gestionnaires de contexte et `with` sont la façon Pythonic de gérer **la gestion des ressources en toute sécurité** — garantissant que les fichiers sont fermés, les verrous libérés, les connexions renvoyées et les transactions finalisées, même lorsque des exceptions se produisent.

Cela prévient les fuites de ressources et les états incohérents, une source courante de bugs avec le nettoyage manuel.

Ils sont utilisés constamment (chaque opération de fichier devrait utiliser `with`), et savoir comment écrire les vôtres (via `__enter__`/`__exit__` ou le plus simple `@contextmanager`) vous permet d'encapsuler n'importe quel motif de configuration/nettoyage de manière propre et fiable.