Context Managers and the with Statement in Python 3

Every time you open a file, acquire a database connection, or grab a thread lock, you need a reliable way to release that resource when you are done — even if your code raises an exception midway through. Context managers give you exactly that guarantee through the with statement. Once you see how they work, you will use them everywhere.

What a Context Manager Does

A context manager wraps a block of code with two operations:

Setup — runs before your block executes (open the file, acquire the lock, start a timer)
Teardown — runs after your block finishes, regardless of whether an exception was raised

# The teardown (file close) is guaranteed — even if an exception occurs inside
with open("data.txt", "r") as file:
    content = file.read()
    process(content)
# file.close() is called here automatically

Without a context manager you would need a try / finally block every time — more lines, more chances to forget the cleanup.

How `with` Works: `enter` and `exit`

Any object that implements __enter__ and __exit__ can be used with with. Python calls them automatically:

# Conceptual expansion of:
#
#   with SomeManager() as value:
#       do_work(value)
#
# …is equivalent to:

manager = SomeManager()
value = manager.__enter__()
try:
    do_work(value)
except Exception as exc:
    manager.__exit__(type(exc), exc, exc.__traceback__)
else:
    manager.__exit__(None, None, None)

The value returned by __enter__ is bound to the variable after as.

Writing Your Own Context Manager: Class-Based

class ManagedDatabase:
    def __init__(self, db_url: str):
        self.db_url = db_url
        self.connection = None

    def __enter__(self):
        print(f"Connecting to {self.db_url}")
        self.connection = {"url": self.db_url, "open": True}  # simulated
        return self.connection

    def __exit__(self, exc_type, exc_value, traceback):
        print("Closing database connection")
        self.connection["open"] = False
        # Return False (or None) to let exceptions propagate
        return False

with ManagedDatabase("postgres://localhost/mydb") as db:
    print(f"Running query on: {db['url']}")
    # query results here...

# Output:
# Connecting to postgres://localhost/mydb
# Running query on: postgres://localhost/mydb
# Closing database connection

If you return True from __exit__, Python suppresses any exception that was raised inside the with block. Return False (or None) to let exceptions propagate normally.

Writing Your Own Context Manager: Generator-Based

For most use cases, the @contextmanager decorator from contextlib is simpler than writing a full class. You write a generator function, yield the value, and Python handles the rest.

from contextlib import contextmanager

@contextmanager
def managed_db(db_url: str):
    print(f"Connecting to {db_url}")
    connection = {"url": db_url, "open": True}
    try:
        yield connection            # everything before yield = __enter__
    finally:
        connection["open"] = False  # everything after yield = __exit__
        print("Connection closed")

with managed_db("postgres://localhost/mydb") as db:
    print(f"Query on: {db['url']}")

# Connecting to postgres://localhost/mydb
# Query on: postgres://localhost/mydb
# Connection closed

The finally block runs even when an exception is raised inside the with block, giving you the same guarantee as __exit__.

Exception Handling Inside the Generator

When an exception escapes the with block, Python injects it back into the generator at the suspended yield using generator.throw(). You can catch it inside the generator:

from contextlib import contextmanager

@contextmanager
def safe_operation(label: str):
    print(f"[{label}] Starting")
    try:
        yield
        print(f"[{label}] Completed successfully")
    except Exception as e:
        print(f"[{label}] Error caught: {e}")
        # Don't re-raise — exception is suppressed
    finally:
        print(f"[{label}] Cleanup always runs")

with safe_operation("upload"):
    raise ValueError("Network timeout")

# [upload] Starting
# [upload] Error caught: Network timeout
# [upload] Cleanup always runs

Built-In Context Managers

File I/O

open() returns a context manager that closes the file handle on exit — even if an exception occurs mid-read.

with open("report.txt", "w") as f:
    f.write("Monthly report\n")

Thread Locks

threading.Lock() acquires the lock on enter and releases it on exit, preventing deadlocks.

import threading

lock = threading.Lock()

with lock:
    # Only one thread runs this block at a time
    shared_counter += 1

Temporary Directory

tempfile.TemporaryDirectory() creates a temp dir and deletes it (with all contents) when the block exits.

import tempfile, os

with tempfile.TemporaryDirectory() as tmpdir:
    path = os.path.join(tmpdir, "scratch.txt")
    with open(path, "w") as f:
        f.write("temporary data")
# tmpdir is gone here

Decimal precision

decimal.localcontext() temporarily changes arithmetic precision within a block without affecting global settings.

from decimal import Decimal, localcontext

with localcontext() as ctx:
    ctx.prec = 50
    result = Decimal("1") / Decimal("3")
    print(result)  # 50 significant digits

Timing Code with a Context Manager

A context manager makes a clean, reusable timer:

import time
from contextlib import contextmanager

@contextmanager
def timer(label: str = ""):
    start = time.perf_counter()
    try:
        yield
    finally:
        elapsed = time.perf_counter() - start
        tag = f"[{label}] " if label else ""
        print(f"{tag}Elapsed: {elapsed:.4f}s")

with timer("data load"):
    data = list(range(10_000_000))

# [data load] Elapsed: 0.3841s

How FastAPI Uses the Same Pattern

FastAPI’s Depends() system lets you use generator-based context managers as dependencies. FastAPI calls next() to run the setup, injects the yielded value into your endpoint, and then resumes the generator after the endpoint returns — guaranteeing cleanup before the HTTP response is sent.

from fastapi import Depends, FastAPI

app = FastAPI()

def get_db():
    db = connect_to_database()   # setup
    try:
        yield db                 # value injected into the endpoint
    finally:
        db.close()               # cleanup — runs before response is sent

@app.get("/users/{user_id}")
def get_user(user_id: int, db = Depends(get_db)):
    return db.query(User).filter(User.id == user_id).first()

This is exactly the same yield + finally pattern you write with @contextmanager — FastAPI just automates the wiring.

When to Reach for a Context Manager

Any resource that must be released

Files, database connections, network sockets, thread locks, GPU memory — anything that needs cleanup belongs in a context manager.

Wrapping setup/teardown around a block

Starting a transaction, entering a profiler, redirecting stdout — anything with a matching before/after pair.

Suppressing or logging specific exceptions

contextlib.suppress(FileNotFoundError) is a one-liner context manager that silently ignores specific exceptions.

from contextlib import suppress

with suppress(FileNotFoundError):
    os.remove("maybe_exists.tmp")

Core Python

Advanced Python

Pydantic

Context Managers and the with Statement in Python 3

What a Context Manager Does

How `with` Works: `enter` and `exit`

Writing Your Own Context Manager: Class-Based

Writing Your Own Context Manager: Generator-Based

Exception Handling Inside the Generator

Built-In Context Managers

File I/O

Thread Locks

Temporary Directory

Decimal precision

Timing Code with a Context Manager

How FastAPI Uses the Same Pattern

When to Reach for a Context Manager

​What a Context Manager Does

​How with Works: __enter__ and __exit__

​Writing Your Own Context Manager: Class-Based

​Writing Your Own Context Manager: Generator-Based

​Exception Handling Inside the Generator

​Built-In Context Managers

File I/O

Thread Locks

Temporary Directory

Decimal precision

​Timing Code with a Context Manager

​How FastAPI Uses the Same Pattern

​When to Reach for a Context Manager

What a Context Manager Does

How `with` Works: `enter` and `exit`

Writing Your Own Context Manager: Class-Based

Writing Your Own Context Manager: Generator-Based

Exception Handling Inside the Generator

Built-In Context Managers

Timing Code with a Context Manager

How FastAPI Uses the Same Pattern

When to Reach for a Context Manager