Ni nini viongeza muktadha na kauli ya with?

Question

Accepted Answer

A **context manager** ni kitu ambacho kinafafanua mantiki ya kuandaa na kusafisha, kinachotumiwa na kauli ya **`with`**. Kinashangilia kwamba kusafisha (kufunga faili, kutolowa kufuli, kurudi nyuma kwa miamala) hutokea kiatomiki — hata kama hitilafu itatokea.

## Matatizo ambayo inasuluhisha

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

Block ya `with` inahakikisha kwamba `f.close()` inaendeshwa wakati block inapoishia, ama kawaida au kupitia pembetatu — ambayo huondoa rasilimali zilizolalika kutokana na kusafisha kilichosahauliwa au kupunguzwa.

## Viongeza muktadha vya kawaida

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

## Kuandika lako — njia ya darasa

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

Context manager inatekeleza `__enter__` (kuandaa) na `__exit__` (kusafisha, ambayo hupokeleza taarifa yoyote ya pembetatu).

## Njia rahisi — 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()
```

Kiboreshaji cha `@contextmanager` hubadilisha jenereta kuwa muongeza muktadha — kuandaa kabla ya `yield`, kusafisha baada ya hayo (katika `finally` kwa usalama).

## Kwa nini inashangilia

Viongeza muktadha na `with` ni njia ya Pythonic ya kuandaa **usimamizi wa rasilimali kwa usalama** — kuhakikisha kwamba faili zinafungwa, kufuli zinatolewa, manundu yanarudishwa, na miamala inakamilishwa, hata wakati pembetatu zitatokea.

Hii inapokea rasilimali zilizolalika na hali isiyofanana, chanzo cha kawaida cha hitilafu na kusafisha kwa mikono.

Zinatumiwa mara kwa mara (kila operesheni ya faili inapaswa kutumia `with`), na kujua jinsi ya kuandika lako (kupitia `__enter__`/`__exit__` au `@contextmanager` rahisi) inakuruhusu kutoshea muundo wowote wa kuandaa/kusafisha kwa njia safi na kutegemeka.