Kas yra konteksto vadybininkai ir with sakinys?

Question

Accepted Answer

**Konteksto vadybininkas** yra objektas, kuris apibrėžia sąrankos ir uždarymo logiką, naudojamas su **`with`** sakiniu. Jis garantuoja, kad valymas (failų uždarymas, užrakinimų atlaisvinimas, operacijų grąžinimas) vyksta automatiškai — net jei įvyksta klaida.

## Problema, kurią jis sprendžia

```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` blokas užtikrina, kad `f.close()` vykdomas kai blokas baigiasi, nesvarbu normaliai ar per išimtį — pašalinant nuoteklius iš pamiršto ar praleisto valymo.

## Paprastai naudojami konteksto vadybininkai

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

## Savo rašymas — klasės būdas

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

Konteksto vadybininkas įgyvendina `__enter__` (sąranka) ir `__exit__` (valymas, kuris gauna bet kokią išimties informaciją).

## Lengvesnis būdas — 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` dekoratorius paverčia generatorių konteksto vadybininku — sąranka prieš `yield`, valymas po (saugumo sumetimais `finally`).

## Kodėl tai svarbu

Konteksto vadybininkai ir `with` yra Pythoniška **išteklių valdymo** saugaus būdo — garantuojantis, kad failai uždaryti, užrakinimų atlaisvintos, ryšiai grąžinti ir operacijos finalizuotos, net kai įvyksta išimtys.

Tai nuo apsaugo nuo išteklių nutekėjimo ir nenuoseklumo, kurie yra dažnos rankinių valymų klaidos šaltinis.

Jie naudojami nuolat (kiekviena failų operacija turėtų naudoti `with`), ir žinojimas, kaip rašyti savo (per `__enter__`/`__exit__` arba paprastesnį `@contextmanager`) leidžia jums švariai ir patikimai atskirti bet kokį sąrankos/valymo šabloną.