Wat zijn context managers en de with statement?

Question

Accepted Answer

Een **context manager** is een object dat setup- en teardown-logica definieert, gebruikt met de **`with`** statement. Het garandeert dat cleanup (het sluiten van bestanden, het vrijgeven van locks, het terugdraaien van transacties) automatisch gebeurt — zelfs als een fout optreedt.

## Het probleem dat het oplost

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

De `with` blok zorgt ervoor dat `f.close()` wordt uitgevoerd wanneer het blok afgesloten wordt, ongeacht of dat normaal is of via een uitzondering — waardoor verloren resources door vergeten of overgeslagen cleanup worden voorkomen.

## Veelgebruikte context managers

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

## De klassenmanier — je eigen context manager schrijven

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

Een context manager implementeert `__enter__` (setup) en `__exit__` (cleanup, die uitzonderingsinformatie ontvangt).

## De eenvoudigere manier — 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()
```

De `@contextmanager` decorator transformeert een generator in een context manager — setup voor `yield`, cleanup erna (in `finally` voor veiligheid).

## Waarom het belangrijk is

Context managers en `with` zijn de Pythonische manier om **resource management veilig** af te handelen — garanderend dat bestanden worden gesloten, locks worden vrijgegeven, verbindingen worden geretourneerd en transacties worden afgerond, zelfs wanneer uitzonderingen optreden.

Dit voorkomt resource leaks en inconsistente toestand, een veel voorkomende bron van bugs bij handmatige cleanup.

Ze worden constant gebruikt (elke bestandsbewerking zou `with` moeten gebruiken), en het weten hoe je je eigen kunt schrijven (via `__enter__`/`__exit__` of de eenvoudiger `@contextmanager`) stelt je in staat om elk setup/teardown patroon schoon en betrouwbaar in te kapselen.