Was sind Context Manager und die with-Anweisung?

Question

Accepted Answer

Ein **Context Manager** ist ein Objekt, das Setup- und Teardown-Logik definiert und mit der **`with`**-Anweisung verwendet wird. Es garantiert, dass das Cleanup (Schließen von Dateien, Freigeben von Sperren, Rollback von Transaktionen) automatisch erfolgt — auch wenn ein Fehler auftritt.

## Das Problem, das es löst

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

Der `with`-Block stellt sicher, dass `f.close()` beim Verlassen des Blocks ausgeführt wird, egal ob normal oder durch eine Ausnahme — und verhindert so Ressourcenlecks durch vergessenes oder übersprungenes Cleanup.

## Häufige Context Manager

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

## Eigene schreiben — die Klassen-Methode

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

Ein Context Manager implementiert `__enter__` (Setup) und `__exit__` (Cleanup, das Ausnahmeinformationen erhält).

## Der einfachere Weg — 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()
```

Der `@contextmanager`-Dekorator verwandelt einen Generator in einen Context Manager — Setup vor `yield`, Cleanup danach (in `finally` für Sicherheit).

## Warum es wichtig ist

Context Manager und `with` sind die pythonische Art, um **Ressourcenverwaltung sicher** zu handhaben — garantieren, dass Dateien geschlossen, Sperren freigegeben, Verbindungen zurückgegeben und Transaktionen abgeschlossen werden, auch wenn Ausnahmen auftreten.

Dies verhindert Ressourcenlecks und inkonsistente Zustände, eine häufige Fehlerquelle beim manuellen Cleanup.

Sie werden ständig verwendet (jede Dateioperation sollte `with` verwenden), und zu wissen, wie man eigene schreibt (über `__enter__`/`__exit__` oder das einfachere `@contextmanager`) ermöglicht es dir, jedes Setup/Teardown-Muster sauber und zuverlässig zu kapseln.