Context Managers as a Pattern

Context managers guarantee setup and teardown around a block of code. The with statement calls __enter__/__exit__ (or @contextmanager yield) so resources release even when exceptions fire - files close, locks release, and transactions roll back.

Recipe

Quick-reference recipe card - copy-paste ready.

from contextlib import contextmanager
 
@contextmanager
def temporary_setting(obj, attr, value):
    old = getattr(obj, attr)
    setattr(obj, attr, value)
    try:
        yield obj
    finally:
        setattr(obj, attr, old)
 
with temporary_setting(config, "debug", True):
    run_checks()

When to reach for this:

• Acquire/release pairs - files, sockets, locks, DB connections
• Temporary state - env vars, log levels, feature flags for a block
• Transactions - commit on success, rollback on exception
• Timing and profiling - enter starts timer, exit logs duration
• Suppressing expected errors - contextlib.suppress(FileNotFoundError)

Working Example

A class-based manager for database transactions plus a @contextmanager for timing.

import time
from contextlib import contextmanager
from dataclasses import dataclass, field
from typing import Iterator
 
@dataclass
class FakeConnection:
    committed: bool = False
    rolled_back: bool = False
 
    def commit(self) -> None:
        self.committed = True
 
    def rollback(self) -> None:
        self.rolled_back = True
 
class Transaction:
    def __init__(self, conn: FakeConnection) -> None:
        self._conn = conn
 
    def __enter__(self) -> FakeConnection:
        return self._conn
 
    def __exit__(self, exc_type, exc, tb) -> bool:
        if exc_type is None:
            self._conn.commit()
        else:
            self._conn.rollback()
        return False  # do not suppress exceptions
 
@contextmanager
def timer(label: str) -> Iterator[None]:
    start = time.perf_counter()
    try:
        yield
    finally:
        elapsed = time.perf_counter() - start
        print(f"{label}: {elapsed:.3f}s")
 
conn = FakeConnection()
 
with timer("happy path"):
    with Transaction(conn) as db:
        print("write rows", db)
 
print("committed:", conn.committed)
 
conn2 = FakeConnection()
try:
    with Transaction(conn2):
        raise ValueError("boom")
except ValueError:
    pass
print("rolled back:", conn2.rolled_back)

What this demonstrates:

• Class protocol: __enter__ returns the resource, __exit__ cleans up
• Returning False from __exit__ propagates exceptions after rollback
• @contextmanager splits setup (before yield) and teardown (finally)
• finally runs whether the block exits normally or via exception

Deep Dive

How It Works

• with expr as var: evaluates expr, calls __enter__, binds var, runs the suite
• On exit, __exit__(exc_type, exc_val, tb) always runs
• If __exit__ returns a true value, the exception is suppressed
• @contextmanager wraps a generator: code before yield is enter, after is exit
• contextlib.ExitStack composes multiple managers without deep nesting

Common Manager Types

Python Notes

from contextlib import ExitStack, suppress
 
with ExitStack() as stack:
    f1 = stack.enter_context(open("a.txt"))
    f2 = stack.enter_context(open("b.txt"))
    # both close on exit
 
with suppress(FileNotFoundError):
    open("optional.cfg").read()

Gotchas

• Forgetting finally in generators - teardown must be in finally around yield, not after it only on success. Fix: always wrap post-yield code in try/finally.
• Swallowing exceptions accidentally - __exit__ returning True hides bugs. Fix: return False unless suppression is intentional (document it).
• Re-entrant locks - not all managers are re-entrant; nesting the same lock wrong deadlocks. Fix: use threading.RLock or document non-reentrancy.
• Yielding only once - @contextmanager must yield exactly one value. Fix: do not yield in a loop.
• Resource leak on __enter__ failure - if setup partially succeeds then raises, exit may not run. Fix: use ExitStack or keep setup minimal in __enter__.

Alternatives

FAQs

Related

• EAFP vs LBYL - exceptions inside managed blocks
• Factory & Builder Patterns - constructing resources
• Dependency Injection in Python - injecting connections
• Pythonic Patterns Basics - section overview

External Related Links

• Python Standard Library Reference - Complete documentation for built-in modules and functions.
• Official Python Documentation - The definitive source (Tutorial, Library Reference, Language Reference, HOWTOs).
• Real Python - In-depth tutorials, courses, and practical guides.
• Fluent Python (2nd Edition) - Intermediate to advanced Python idioms (Luciano Ramalho).
• The Quick Python Book (4th Edition) - Concise Python overview (Naomi Ceder).

Stack versions: This page was written for Python 3.14.0 (stable 3.14, maintenance 3.13), FastAPI 0.115+, Django 5.2, Flask 3.1, Pydantic 2, PyTorch 2.6+, pandas 2.2+, Polars 1.x, ruff 0.9+, and uv 0.6+.