Apa itu manajer konteks dan pernyataan with?

Question

Accepted Answer

**Manajer konteks** adalah objek yang mendefinisikan logika pengaturan dan pembongkaran, digunakan dengan pernyataan **`with`**. Ini menjamin bahwa pembersihan (menutup file, melepaskan kunci, membatalkan transaksi) terjadi secara otomatis — bahkan jika kesalahan terjadi.

## Masalah yang dipecahkannya

```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()` berjalan ketika blok keluar, baik secara normal maupun melalui pengecualian — menghilangkan kebocoran sumber daya dari pembersihan yang terlupakan atau terlewat.

## Manajer konteks umum

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

Manajer konteks mengimplementasikan `__enter__` (pengaturan) dan `__exit__` (pembersihan, yang menerima informasi pengecualian apa pun).

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

Dekorator `@contextmanager` mengubah generator menjadi manajer konteks — pengaturan sebelum `yield`, pembersihan setelahnya (di `finally` untuk keamanan).

## Mengapa ini penting

Manajer konteks dan `with` adalah cara Pythonic untuk menangani **manajemen sumber daya dengan aman** — menjamin bahwa file ditutup, kunci dilepaskan, koneksi dikembalikan, dan transaksi diselesaikan, bahkan ketika pengecualian terjadi.

Ini mencegah kebocoran sumber daya dan status yang tidak konsisten, sumber bug umum dengan pembersihan manual.

Mereka digunakan terus-menerus (setiap operasi file harus menggunakan `with`), dan mengetahui cara menulis milik Anda sendiri (melalui `__enter__`/`__exit__` atau `@contextmanager` yang lebih sederhana) memungkinkan Anda untuk membungkus pola pengaturan/pembongkaran apa pun dengan bersih dan andal.