संदर्भ प्रबंधक और with कथन क्या हैं?

Question

Accepted Answer

एक **संदर्भ प्रबंधक** एक वस्तु है जो सेटअप और टीयरडाउन तर्क को परिभाषित करती है, जिसका उपयोग **`with`** कथन के साथ किया जाता है। यह गारंटी देता है कि सफाई (फाइलें बंद करना, लॉक जारी करना, लेनदेन वापस लेना) स्वचालित रूप से होता है — भले ही कोई त्रुटि हो।

## समस्या जिसे यह हल करता है

```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` ब्लॉक सुनिश्चित करता है कि `f.close()` तब चलता है जब ब्लॉक बाहर निकलता है, सामान्य रूप से या अपवाद के माध्यम से — भूल गई या छोड़ी गई सफाई से संसाधन रिसाव को समाप्त करता है।

## सामान्य संदर्भ प्रबंधक

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

## अपना स्वयं का लिखना — क्लास तरीका

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

एक संदर्भ प्रबंधक `__enter__` (सेटअप) और `__exit__` (सफाई, जो किसी भी अपवाद जानकारी प्राप्त करता है) को लागू करता है।

## आसान तरीका — 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` सजावट एक जनरेटर को संदर्भ प्रबंधक में बदल देता है — `yield` से पहले सेटअप, उसके बाद सफाई (`finally` में सुरक्षा के लिए)।

## यह क्यों महत्वपूर्ण है

संदर्भ प्रबंधक और `with` **संसाधन प्रबंधन सुरक्षित रूप से** करने का Pythonic तरीका है — यह सुनिश्चित करता है कि फाइलें बंद हों, लॉक जारी हों, कनेक्शन वापस लौटाए जाएं, और लेनदेन पूरा हों, भले ही अपवाद हों।

यह संसाधन रिसाव और असंगत स्थिति को रोकता है, मैनुअल सफाई के साथ बग्स का एक सामान्य स्रोत।

इनका उपयोग लगातार किया जाता है (हर फाइल ऑपरेशन को `with` का उपयोग करना चाहिए), और जानना कि अपना स्वयं का कैसे लिखें (`__enter__`/`__exit__` के माध्यम से या सरल `@contextmanager`) आपको किसी भी सेटअप/टीयरडाउन पैटर्न को स्वच्छ और विश्वसनीय रूप से एनकैप्सुलेट करने देता है।