Vad är kontexthanterare och with-satsen?

Question

Accepted Answer

En **kontexthanterare** är ett objekt som definierar setup- och teardown-logik, använt med **`with`**-satsen. Det garanterar att rensning (stängning av filer, frigivning av lås, återställning av transaktioner) sker automatiskt — även om ett fel uppstår.

## Problemet den löser

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

`with`-blocket säkerställer att `f.close()` körs när blocket avslutas, antingen normalt eller via ett undantag — vilket eliminerar läckta resurser från glömd eller överhoppad rensning.

## Vanliga kontexthanterare

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

## Skriva din egen — klassmetoden

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

En kontexthanterare implementerar `__enter__` (setup) och `__exit__` (rensning, som mottar eventuell undantagsinformation).

## Det enklare sättet — 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()
```

`@contextmanager`-dekoratorn förvandlar en generator till en kontexthanterare — setup före `yield`, rensning efter (i `finally` för säkerhet).

## Varför det spelar roll

Kontexthanterare och `with` är det pythoniska sättet att hantera **resurshantering säkert** — garantera att filer stängs, lås frigörs, anslutningar returneras och transaktioner slutförs, även när undantag uppstår.

Detta förhindrar resursläckor och inkonsekvent tillstånd, en vanlig källa till fel vid manuell rensning.

De används konstant (alla filoperationer bör använda `with`), och att veta hur man skriver sin egen (via `__enter__`/`__exit__` eller den enklare `@contextmanager`) låter dig kapsla in alla setup/teardown-mönster på ett rent och tillförlitligt sätt.