Context managers र with statement के हुन्?

Question

Accepted Answer

एक **context manager** एक object हो जसले setup र teardown logic को परिभाषा गर्दछ, **`with`** statement सँग प्रयोग गरिन्छ। यसले guarantee गर्दछ कि cleanup (files बन्द गर्ने, locks release गर्ने, transactions rollback गर्ने) स्वचालित रूपमा हुन्छ — भले नै कोनै error आए पनि।

## समस्या जो यसले समाधान गर्दछ

```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` block ले ensure गर्दछ कि `f.close()` block exit हँदा चल्दछ, चाहे सामान्य तरिकामा वा exception को माध्यमबाट — भुलेर वा छोडिएको cleanup बाट leaked resources लाई हटाउँदै।

## सामान्य context managers

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

## आफ्नो लेख्न — class तरिका

```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 ले `__enter__` (setup) र `__exit__` (cleanup, जसले कुनै पनि exception info प्राप्त गर्दछ) लाई implement गर्दछ।

## सजिलो तरिका — 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` decorator ले एक generator लाई context manager मा परिवर्तन गर्दछ — `yield` अघि setup, `yield` पछि cleanup (safety को लागि `finally` मा)।

## किन यो महत्त्वपूर्ण छ

Context managers र `with` **resource management सुरक्षित** गर्ने Pythonic तरिका हुन् — files बन्द गरिएको, locks released गरिएको, connections returned गरिएको, र transactions finalized गरिएको guarantee गर्दै, भले नै exceptions आए पनि।

यसले resource leaks र inconsistent state लाई रोक्दछ, जो manual cleanup सँग bugs को सामान्य स्रोत हो।

तिनीहरू सधैं प्रयोग गरिन्छन् (हरेक file operation ले `with` प्रयोग गर्नु पर्दछ), र आफ्नो लेख्न गर्न जान्नु (via `__enter__`/`__exit__` वा सरल `@contextmanager` को माध्यमबाट) तपाईंलाई कुनै पनि setup/teardown pattern लाई स्वच्छ र भरपर्दो तरिकामा encapsulate गर्न दिन्छ।