Apa iku context managers lan statement `with`?

Question

IT Interview Practice · Accepted Answer

A **context manager** yaiku obyek sing ngedefinisikake logika setup lan teardown, digunakake karo statement **`with`**. Iku njamin manawa cleanup (nutup file, nglilirke lock, roll back transaction) bakal kelakon kanthi otomatis — sanajan yen ana error.

## Masalah sing ditatasi

```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` njamin `f.close()` bakal dijalanke nalika blok metu, apa dening cara normal utawa liwat exception — ngilangi resource sing bocor saka cleanup sing lali utawa dilewati.

## Context managers sing 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
    ...
```

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

A context manager nglaksanakake `__enter__` (setup) lan `__exit__` (cleanup, sing narima informasi exception apa wae).

## Cara sing luwih gampang — 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` ngowahi generator dadi context manager — setup sadurunge `yield`, cleanup sawise (ing `finally` kanggo keamanan).

## Mengapa iki penting

Context managers lan `with` yaiku cara Pythonic kanggo nangani **resource management kanthi aman** — njamin manawa file ditutup, lock dilirke, koneksi dikembalekake, lan transaction diselesaekake, sanajan nalika exception kelakon.

Iki nyegah resource leak lan state sing ora konsisten, sumber bug umum karo cleanup manual.

Iku digunakake terus-terusan (saben operasi file kudu nggunakake `with`), lan ngerti cara nulis dhewe (liwat `__enter__`/`__exit__` utawa `@contextmanager` sing luwih gampang) ngidini sampeyan ngenkapsulasi pola setup/teardown apa wae kanthi resik lan andal.

Masalah sing ditatasi

Context managers sing umum

Nulis dhewe — cara kelas

Cara sing luwih gampang — contextlib

Mengapa iki penting

Pitakon sing gegandhengan