Context managers आणि with statement म्हणजे काय?

Question

Accepted Answer

एक **context manager** एक object आहे जो setup आणि teardown logic परिभाषित करतो, **`with`** statement सह वापरले जाते. हे हमी देतो की cleanup (files बंद करणे, locks सोडणे, 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 हे सुनिश्चित करतो की `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 प्राप्त करतो) लागू करतो.

## सोपी पद्धत — 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, `finally` मध्ये cleanup (सुरक्षेसाठी).

## महत्व का आहे

Context managers आणि `with` हा Python मार्ग आहे **resource management सुरक्षितपणे** हाताळण्यासाठी — files बंद होणे, locks सोडणे, connections परत केल्या जाणे, आणि transactions अंतिम होणे हमी देतो, अगदी exceptions घडल्यासही.

हे resource leaks आणि inconsistent state दूर करतो, manual cleanup सह bugs चा सामान्य स्त्रोत.

ते सतत वापरले जातात (प्रत्येक file operation ला `with` वापरायला हवे), आणि आपले स्वतःचे लिहिणे कसे करायचे हे जाणून (via `__enter__`/`__exit__` किंवा सोपा `@contextmanager`) कोणताही setup/teardown pattern स्वच्छपणे आणि विश्वसनीयपणे encapsulate करू शकते.