Hva er kontekstbehandlere og with-setningen?

Question

Accepted Answer

En **kontekstbehandler** er et objekt som definerer oppsetts- og nedrivingslogikk, brukt med **`with`**-setningen. Den garanterer at opprydding (lukking av filer, frigjøring av låser, tilbakerulling av transaksjoner) skjer automatisk — selv om en feil oppstå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
```

Den `with`-blokken sikrer at `f.close()` kjøres når blokken avsluttes, enten normalt eller via et unntak — og eliminerer lekket ressurser fra glemt eller utelatt opprydding.

## Vanlige kontekstbehandlere

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

## Skrive din egen — klassemetoden

```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 kontekstbehandler implementerer `__enter__` (oppsett) og `__exit__` (nedrigging, som mottar eventuelle unntaksinformasjoner).

## Den enklere måten — 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()
```

Den `@contextmanager`-dekoratøren gjør en generator til en kontekstbehandler — oppsett før `yield`, nedrigging etterpå (i `finally` for sikkerhet).

## Hvorfor det betyr noe

Kontekstbehandlere og `with` er den pythoniske måten å håndtere **ressursadministrasjon sikkert** — og garanterer at filer lukkes, låser frigjøres, tilkoblinger returneres, og transaksjoner fullføres, selv når unntak oppstår.

Dette forhindrer ressurslekk og inkonsistent tilstand, en vanlig kilde til feil med manuell opprydding.

De brukes hele tiden (hver filoperasjon bør bruke `with`), og det å vite hvordan du skriver dine egne (via `__enter__`/`__exit__` eller den enklere `@contextmanager`) lar deg innkapsle ethvert oppsetts-/nedrivingsmønster rent og pålitelig.