Ce sunt managerele de context și instrucțiunea with?

Question

Accepted Answer

Un **manager de context** este un obiect care definește logica de setup și teardown, folosit cu instrucțiunea **`with`**. El garantează că curățarea (închiderea fișierelor, eliberarea blocajelor, revenirea tranzacțiilor) se întâmplă automat — chiar dacă apare o eroare.

## Problema pe care o rezolvă

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

Bloclul `with` asigură că `f.close()` se execută când blocul se termină, indiferent dacă normal sau prin excepție — eliminând resursele scurse din curățarea uitată sau omisă.

## Manageri de context comuni

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

## Scriind al tău — modul cu clasă

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

Un manager de context implementează `__enter__` (setup) și `__exit__` (curățare, care primește informații despre excepție).

## Modul mai ușor — 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()
```

Decoratorul `@contextmanager` transformă un generator într-un manager de context — setup înainte de `yield`, curățare după (în `finally` pentru siguranță).

## De ce este important

Managerii de context și `with` sunt modul pythonic de **gestionare sigură a resurselor** — garantând că fișierele sunt închise, blocajele sunt eliberate, conexiunile sunt returnate și tranzacțiile sunt finalizate, chiar și când apar excepții.

Aceasta previne scurgerea resurselor și starea inconsecventă, o sursă comună de erori cu curățare manuală.

Sunt folosiți constant (fiecare operație pe fișier ar trebui să folosească `with`), și știind cum să-ți scrii ale tale (via `__enter__`/`__exit__` sau mai simplu `@contextmanager`) te permite să încapsulezi orice model setup/teardown curat și fiabil.