context managers ਅਤੇ with statement ਕੀ ਹਨ?

Question

Accepted Answer

ਇਕ **context manager** ਇਕ ਵਸਤੂ ਹੈ ਜੋ setup ਅਤੇ teardown logic ਨੂੰ **`with`** statement ਦੇ ਨਾਲ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੀ ਹੈ। ਇਹ ਗ੍ਰੈਂਟੀ ਦਿੰਦਾ ਹੈ ਕਿ cleanup (ਫਾਈਲਾਂ ਨੂੰ ਬੰਦ ਕਰਨਾ, locks ਛੱਡਣੇ, transactions ਨੂੰ wapas ਕਰਨਾ) ਆਟੋਮੈਟਿਕ ਤੌਰ 'ਤੇ ਹੁੰਦਾ ਹੈ — ਭਾਵੇਂ ਕੋਈ ਵੀ 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` ਬਲਾਕ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ `f.close()` ਚਲੇ ਜਦੋਂ ਬਲਾਕ ਬਾਹਰ ਨਿਕਲਦਾ ਹੈ, ਭਾਵੇਂ ਆਮ ਤੌਰ 'ਤੇ ਜਾਂ 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, ਬਾਅਦ ਵਿੱਚ cleanup (safety ਲਈ `finally` ਵਿੱਚ)।

## ਇਹ ਕਿਉਂ ਮਹੱਤਵਪੂਰਨ ਹੈ

Context managers ਅਤੇ `with` **resource management** ਨੂੰ **safely** ਸੰਭਾਲਣ ਦੀ Pythonic ਤਰੀਕਾ ਹਨ — ਗ੍ਰੈਂਟੀ ਕਿ ਫਾਈਲਾਂ ਬੰਦ ਹੋ ਜਾਣ, locks ਛੱਡ ਦਿਏ ਜਾਣ, connections ਵਾਪਸ ਕਰ ਦਿਏ ਜਾਣ, ਅਤੇ transactions ਸਮਾਪਤ ਹੋ ਜਾਣ, ਭਾਵੇਂ exceptions ਆਉਣ।

ਇਹ resource leaks ਅਤੇ inconsistent state ਨੂੰ ਰੋਕਦਾ ਹੈ, manual cleanup ਨਾਲ bugs ਦਾ ਇਕ ਆਮ ਸਰੋਤ।

ਉਹ ਹਮੇਸ਼ਾ ਵਰਤੇ ਜਾਂਦੇ ਹਨ (ਹਰ ਫਾਈਲ ਓਪਰੇਸ਼ਨ ਨੂੰ `with` ਵਰਤਣਾ ਚਾਹੀਦਾ ਹੈ), ਅਤੇ ਆਪਣੇ ਲਿਖਣੇ ਜਾਣਨਾ (`__enter__`/`__exit__` ਜਾਂ ਸਰਲ `@contextmanager` ਦੇ ਵਿਆਰਥੀ) ਤੁਹਾਨੂੰ ਕਿਸੇ ਵੀ setup/teardown pattern ਨੂੰ cleanly ਅਤੇ reliably ਵਿੱਚ encapsulate ਕਰਨ ਦਿੰਦਾ ਹੈ।