Apakah itu context manager dan pernyataan with?

Question

Accepted Answer

**Context manager** ialah objek yang mentakrifkan logik persediaan dan pembersihan, digunakan dengan pernyataan **`with`**. Ia menjamin bahawa pembersihan (menutup fail, melepaskan kunci, mengundur transaksi) berlaku secara automatik — walaupun jika berlaku ralat.

## Masalah yang diselesaikannya

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

Blok `with` memastikan `f.close()` dijalankan apabila blok keluar, sama ada secara normal atau melalui pengecualian — menghapuskan sumber yang bocor akibat pembersihan yang terlupa atau dilangkau.

## Context manager yang biasa

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

## Menulis context manager anda sendiri — cara kelas

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

Sebuah context manager melaksanakan `__enter__` (persediaan) dan `__exit__` (pembersihan, yang menerima sebarang maklumat pengecualian).

## Cara yang lebih mudah — 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()
```

Decorator `@contextmanager` menukar sebuah generator menjadi context manager — persediaan sebelum `yield`, pembersihan selepasnya (dalam `finally` untuk keselamatan).

## Mengapa ia penting

Context manager dan `with` ialah cara ber-Python untuk mengendalikan **pengurusan sumber dengan selamat** — menjamin fail ditutup, kunci dilepaskan, sambungan dipulangkan, dan transaksi dimuktamadkan, walaupun apabila berlaku pengecualian.

Ini menghalang kebocoran sumber dan keadaan yang tidak konsisten, satu punca pepijat yang biasa dengan pembersihan manual.

Ia digunakan secara berterusan (setiap operasi fail patut menggunakan `with`), dan mengetahui cara menulis context manager anda sendiri (melalui `__enter__`/`__exit__` atau `@contextmanager` yang lebih ringkas) membolehkan anda merangkum sebarang corak persediaan/pembersihan dengan kemas dan boleh dipercayai.