Hvad er context managers og with-sætningen?

Question

Accepted Answer

En **context manager** er et objekt, der definerer setup- og teardown-logik, brugt med **`with`**-sætningen. Det garanterer, at cleanup (lukning af filer, frigivelse af låse, tilbagegang af transaktioner) sker automatisk — selv hvis der opstår en fejl.

## Problemet, det 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
```

Blokken `with` sikrer, at `f.close()` køres, når blokken afsluttes, enten normalt eller via en undtagelse — hvilket eliminerer ressourcelækager fra glemte eller udeladte cleanup.

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

## Skrivning af din egen — klassevej

```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 context manager implementerer `__enter__` (setup) og `__exit__` (cleanup, som modtager eventuel undtagelsesinformation).

## Den nemme vej — 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()
```

Dekoratøren `@contextmanager` omdanner en generator til en context manager — setup før `yield`, cleanup efter (i `finally` for sikkerhed).

## Hvorfor det betyder noget

Context managers og `with` er den pythoniske måde at håndtere **ressourcestyring sikkert** på — garantere, at filer lukkes, låse frigives, forbindelser returneres og transaktioner afsluttes, selv når der opstår undtagelser.

Dette forhindrer ressourcelækager og inkonsistent tilstand, en almindelig kilde til fejl med manuel cleanup.

De bruges konstant (enhver filoperation bør bruge `with`), og at vide, hvordan man skriver sine egne (via `__enter__`/`__exit__` eller den simplere `@contextmanager`) giver dig mulighed for at indkapsle ethvert setup/teardown-mønster rent og pålideligt.