સંદર્ભ સંચાલક અને with કથન શું છે?

Question

IT Interview Practice · 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` એ **સંસાધન સંચાલનને સુરક્ષિતપણે** સંચાલવાનો પાયથોનિક રીત છે — ફાઇલો બંધ કરવામાં આવશે, લૉક્સ રીલીજ કરવામાં આવશે, કનેક્શન પરત કરવામાં આવશે, અને લેનદેન સમાપ્ત કરવામાં આવશે, તમે અપવાદો કરો કે તમે ન કરો।

યह संसાधન રસેডો અને અસંગત સ્થિતિ અટકાવે છે, જે સામાન્ય સફાઈ સાથે બગ્સનો સામાન્ય સ્ત્રોત છે।

તેઓ સતત ઉપયોગમાં આવે છે (દરેક ફાઇલ ક્રિયા `with` ને વાપરવી જોઈએ), અને તમારું પોતાનું લખવા માટે કેવી રીતે જાણવું ("__enter__"/"__exit__" દ્વારા અથવા સરળ `@contextmanager` દ્વારા) તમને કોઈપણ સેટআપ/ટીયરડાઉન પેટર્ન સ્વચ્છતથી અને વિશ્વસનીયતાથી આવર્જિત કરવા દે છે।

તે જે સમસ્યાને હલ કરે છે

સામાન્ય સંદર્ભ સંચાલક

તમારું પોતાનું લખવું — વર્ગ રીતે

સહજ રીત — contextlib

તે શા માટે મહત્વપૂર્ણ છે

સંબંધિત પ્રશ્નો