Python Context Managers and the with Statement

A context manager is an object that defines what should happen when entering and leaving a block of code, and it is used through the with statement. The most common example is file handling: with open("file.txt") as f: guarantees the file gets closed automatically when the block ends, even if an exception occurs inside it — something that's easy to forget when managing a file handle manually with try/finally.

Context managers exist to make "setup, use, then guaranteed cleanup" patterns concise and reliable, wherever that pattern applies: files, network connections, database transactions, locks, or temporarily changed settings.

Why it matters

Files, database connections, locks and network sockets must all be released when you have finished with them, including when an error interrupts the code. The with statement guarantees it. Writing your own context manager lets you give the same guarantee for anything that has a set-up and a clean-up step.

The with Statement and __enter__/__exit__

Any object that defines both __enter__ and __exit__ methods can be used with the with statement. When the with block begins, Python calls __enter__, and whatever it returns is bound to the variable after as (if present). When the block ends — normally or due to an exception — Python calls __exit__, passing it details about any exception that occurred (or three None values if the block completed normally). If __exit__ returns True, any exception that occurred inside the block is suppressed; if it returns a falsy value (the default), the exception propagates normally after cleanup runs.

Writing a Context Manager with contextlib.contextmanager

Writing a full class with __enter__ and __exit__ is sometimes more ceremony than necessary for a simple case. The contextlib.contextmanager decorator lets you write a context manager as a single generator function instead: code before the yield statement acts as __enter__, the yielded value becomes what's bound after as, and code after the yield (typically inside a finally block) acts as __exit__, running even if the caller's code inside the with block raises an exception.

Why This Matters for Resource Safety

Resources like open files, network sockets, and database connections are typically limited and must be explicitly released. Relying on a programmer to remember a matching "close" call every time is fragile — an exception raised between "open" and "close" would skip the cleanup entirely unless it's wrapped in try/finally. Context managers move that responsibility into the object itself, so correct cleanup happens automatically every time the with block is used, regardless of how the block exits.

Examples

class ManagedFile:
    def __init__(self, filename, mode):
        self.filename = filename
        self.mode = mode

    def __enter__(self):
        self.file = open(self.filename, self.mode)
        return self.file

    def __exit__(self, exc_type, exc_value, traceback):
        self.file.close()
        print("File closed automatically.")
        return False  # do not suppress exceptions

with ManagedFile("notes.txt", "w") as f:
    f.write("Hello, context managers!")
print("Block finished.")

File closed automatically.
Block finished.

from contextlib import contextmanager

@contextmanager
def managed_file(filename, mode):
    f = open(filename, mode)
    try:
        yield f          # code before yield = __enter__, f is bound to "as f"
    finally:
        f.close()        # code after yield = __exit__, always runs
        print("File closed automatically.")

with managed_file("notes.txt", "w") as f:
    f.write("Hello again!")
print("Block finished.")

File closed automatically.
Block finished.

Exercise

Using contextlib.contextmanager, write a context manager tag that prints an opening tag before the block runs and a closing tag after it.

Expected output: <b>, hello, </b> (one per line)

from contextlib import contextmanager


# TODO: a context manager tag(name) that prints <name>, runs the block, then prints </name>


with tag("b"):
    print("hello")

from contextlib import contextmanager


@contextmanager
def tag(name):
    print(f"<{name}>")
    try:
        yield
    finally:
        print(f"</{name}>")


with tag("b"):
    print("hello")

Quick quiz

Interview questions