సందర్భ నిర్వాహకులు మరియు with స్టేట్‌మెంట్ ఏమిటి?

Question

Accepted Answer

A **context manager** అనేది setup మరియు teardown లాజిక్‌ను నిర్వచించే ఒక వస్తువు, ఇది **`with`** స్టేట్‌మెంట్‌తో ఉపయోగించబడుతుంది. ఇది cleanup (ఫైల్‌లను మూసివేయడం, లాక్‌లను విడుదల చేయడం, లేනిదేనను రోల్‌బ్యాక్ చేయడం) ఆటోమేటిక్‌గా జరుగుతుందని నిర్ధారిస్తుంది — ఎటువంటి లోపం సంభవించినప్పటికీ.

## ఇది పరిష్కరించే సమస్య

```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()` అమలు చేయబడుందని నిర్ధారిస్తుంది — మరచిపోయిన లేదా దాటిపోయిన cleanup నుండి లీక్ చేసిన వనరులను తొలగిస్తుంది.

## సాధారణ సందర్భ నిర్వాహకులు

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

ఒక context manager `__enter__` (setup) మరియు `__exit__` (cleanup, ఇది ఏదైనా మినహాయింపు సమాచారాన్ని అందుకుంటుంది)ని అమలు చేస్తుంది.

## సులభమైన విధానం — 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` ముందు setup, తర్వాత cleanup (సురక్షత కోసం `finally` లో).

## ఇది ఎందుకు ముఖ్యమైనది

సందర్భ నిర్వాహకులు మరియు `with` **వనరుల నిర్వహణను సురక్షితంగా** నిర్వహించడానికి Pythonic మార్గం — ఫైల్‌లు మూసివేయబడటం, లాక్‌లు విడుదల చేయబడటం, కనెక్షన్‌లు రిటర్న్ చేయబడటం మరియు లేనిదేని ఖరారు చేయబడటం, మినహాయింపులు సంభవించినప్పటికీ నిర్ధారిస్తుంది.

ఇది వనరుల లీక్‌లను మరియు సస్థితి లేని స్థితిని నిరోధిస్తుంది, ఇది manual cleanup కోసం సాధారణ బగ్ ఆధారం.

వాటిని నిరంతరం ఉపయోగిస్తారు (ప్రతిটి ఫైల్ ఆపరేషన్ `with` ఉపయోగించాలి), మరియు మీ సొంతమైనవాటిని ఎలా వ్రాయాలో తెలుసుకోవడం (`__enter__`/`__exit__` లేదా సరళమైన `@contextmanager` ద్వారా) ఏదైనా setup/teardown నమూనాను చистంగా మరియు నమ్మకంగా కపసుల్ చేయడానికి మీరు అనుమతిస్తుంది.