What are context managers and the with statement?

Question

IT Interview Practice · Accepted Answer

A **context manager** is an object that defines setup and teardown logic, used with the **`with`** statement. It guarantees that cleanup (closing files, releasing locks, rolling back transactions) happens automatically — even if an error occurs.

## The problem it solves

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

The `with` block ensures `f.close()` runs when the block exits, whether normally or via an exception — eliminating leaked resources from forgotten or skipped cleanup.

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

## Writing your own — the class way

```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 implements `__enter__` (setup) and `__exit__` (cleanup, which receives any exception info).

## The easier way — 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()
```

The `@contextmanager` decorator turns a generator into a context manager — setup before `yield`, cleanup after (in `finally` for safety).

## Why it matters

Context managers and `with` are the Pythonic way to handle **resource management safely** — guaranteeing files are closed, locks released, connections returned, and transactions finalized, even when exceptions occur.

This prevents resource leaks and inconsistent state, a common source of bugs with manual cleanup.

They're used constantly (every file operation should use `with`), and knowing how to write your own (via `__enter__`/`__exit__` or the simpler `@contextmanager`) lets you encapsulate any setup/teardown pattern cleanly and reliably.

The problem it solves

Common context managers

Writing your own — the class way

The easier way — contextlib

Why it matters

Related questions