Mik a környezet kezelők és a with utasítás?

Question

Accepted Answer

A **kontextuskezelő** egy objektum, amely definiálja a beállítási és lebontási logikát, és a **`with`** utasítással használható. Garantálja, hogy a tisztítás (fájlok bezárása, zárak feloldása, tranzakciók visszavonása) automatikusan megtörténik — még akkor is, ha hiba történik.

## Az általa megoldott probléma

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

A `with` blokk biztosítja, hogy az `f.close()` akkor fut le, amikor a blokk kilép, akár normálisan, akár kivételen keresztül — meg előzi az erőforrások szivárgását az elfelejtett vagy kihagyott tisztítástól.

## Gyakori kontextuskezelők

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

## A saját írása — az osztály módja

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

A kontextuskezelő megvalósítja a `__enter__` (beállítás) és `__exit__` (tisztítás, amely bármilyen kivétel információt kap) metódusokat.

## Az egyszerűbb módszer — 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()
```

A `@contextmanager` dekorátor generátort alakít kontextuskezelővé — beállítás a `yield` előtt, tisztítás után (a `finally` biztonsági okból).

## Miért fontos

A kontextuskezelők és a `with` a **biztonságos erőforrás-kezelés** pythonikus módja — garantálja, hogy a fájlok bezárulnak, a zárak feloldódnak, a kapcsolatok visszaadódnak és a tranzakciók befejezódnek, még kivételek esetén is.

Ez megelőzi az erőforrások szivárgását és az inkonzisztens állapotot, amely a kézi tisztítás közös hibaforrása.

Állandóan használják őket (minden fájl műveletnél a `with` használata javasolt), és annak ismerete, hogyan írjon sajátot (`__enter__`/`__exit__` vagy az egyszerűbb `@contextmanager` keresztül) lehetővé teszi, hogy bármilyen beállítási/lebontási mintát tisztán és megbízhatóan beágyazzon.