Menene masu sarrafa mahalarta da bayananin with?

Question

Accepted Answer

A **sarrafa mahalarta** jiki ne wanda ya bayyana jarin saita da rusa, wanda ake amfani da shi tare da **`with`** bayani. Yana tabbatarwa cewa tsaftarwa (rufe fayiloli, sake guduma kulle, cire jiya harkokin) yana faruwa kai tsaye — koda da kuma kukaɗi ya faru.

## Matsalar da ya warware

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

Bajajjanin `with` yana tabbatarwa cewa `f.close()` yana gudu lokacin da baje ya fitar, ba ko ta hanya ko kuma ta keɓa — yana kawar da barkatu daga masu aiwatar da galibi ko tsaye.

## Manyan masu sarrafa mahalarta

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

## Rubuta naka - hanyar ajiya

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

Sarrafa mahalarta yana aiwatar `__enter__` (saita) da `__exit__` (tsaftarwa, wanda ke karɓar bayanan kuskure duk wane).

## Sauƙi - 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()
```

Mantari `@contextmanager` yana sauƙaita janareta zuwa sarrafa mahalarta — saita kafin `yield`, tsaftarwa bayan (a `finally` don tsaro).

## Me ya sa ya zama mahimmanci

Masu sarrafa mahalarta da `with` sune hanyar Python ta sarrafa **albarkatu da nasara** — tabbatarwa cewa fayiloli a rufe, kulle a sake, haɗi da dawo, da kaɗai aiki a gama, koda da kuma kuskure ya faru.

Yana dakatar da asarar albarkatu da rashin daidaituwa na jiya, tushe ta hanya ta kukaɗi tare da tsaftarwa jiya.

Anan jiya ake amfani (kowa fayilon da ya kamata a amfani da `with`), da sanin yadda ake rubutawa (ta hanyar `__enter__`/`__exit__` ko mafi sauƙi `@contextmanager`) yana ba ka damar rubutawa duk wani tsarin saita/rusa a tsarkakakke da aminci.