Context Managers

Introduction

Whenever your code opens a file, connects to a database, or acquires a lock, it needs to release that resource afterward — no matter what happens in between. Forgetting to do this "cleanup" step is one of the most common sources of bugs: files that stay locked, connections that leak, and programs that slowly run out of resources.

Python solves this problem with context managers: objects that know how to set something up and guarantee it gets cleaned up afterward, even if an error occurs partway through. You have already used one without necessarily naming it — the with statement when opening files. In this lesson, you will learn exactly how that mechanism works and how to build your own.

The Problem: Guaranteed Cleanup

Imagine opening a file manually, without a context manager. You must remember to call close() yourself — and if an error happens before that line, close() never runs.

f = open("notes.txt", "w")
f.write("Hello")
result = 10 / 0   # an error happens here
f.close()          # this line never runs!

Traceback (most recent call last):
  ...
ZeroDivisionError: division by zero
# notes.txt is left open — close() was skipped

You could fix this with a try/finally block, ensuring close() always runs, but writing that every single time is repetitive and easy to forget.

f = open("notes.txt", "w")
try:
    f.write("Hello")
    result = 10 / 0
finally:
    f.close()   # this always runs, even after an error

Traceback (most recent call last):
  ...
ZeroDivisionError: division by zero
# but this time f.close() ran before the error propagated

Context managers exist to package up exactly this "always clean up" pattern into something reusable and much shorter to write.

The with Statement Recap

You have already seen the with statement used for file handling. It automatically closes the file for you once the indented block finishes, whether the block succeeds or raises an error.

with open("notes.txt", "w") as f:
    f.write("Hello")
    result = 10 / 0

print("File is guaranteed to be closed here")

Traceback (most recent call last):
  ...
ZeroDivisionError: division by zero
# f is closed automatically before the error propagates
# "File is guaranteed to be closed here" never prints because
# the exception stops execution first — but the file was still closed

The with statement is not magic reserved only for open(). It works with any object that follows the context manager protocol — which you can implement yourself.

How with Works Under the Hood

A context manager is simply an object that defines two special dunder methods: __enter__ and __exit__.

In other words, this code:

with open("notes.txt") as f:
    data = f.read()

is roughly equivalent to Python doing this behind the scenes:

manager = open("notes.txt")
f = manager.__enter__()
try:
    data = f.read()
finally:
    manager.__exit__(None, None, None)

Writing a Custom Context Manager (Class)

You can create your own context manager by writing a class with __enter__ and __exit__ methods. Here is a simple one that logs when a resource opens and closes.

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

    def __enter__(self):
        print(f"Opening {self.filename}")
        self.file = open(self.filename, self.mode)
        return self.file

    def __exit__(self, exc_type, exc_val, exc_tb):
        print(f"Closing {self.filename}")
        self.file.close()


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

Opening notes.txt
Closing notes.txt

__enter__ runs first and returns the file object, which gets bound to f. Once the indented block finishes, __exit__ automatically runs and closes the file — no matter what happened inside the block.

Handling Exceptions in __exit__

If an error occurs inside the with block, Python passes information about it to __exit__ through the exc_type, exc_val, and exc_tb parameters. This lets your context manager react to — or even suppress — the error.

class SafeDivision:
    def __enter__(self):
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        if exc_type is ZeroDivisionError:
            print(f"Caught an error: {exc_val}")
            return True   # True means: suppress the exception
        return False       # False (or None) means: let it propagate


with SafeDivision():
    print(10 / 0)

print("Program continues normally")

Caught an error: division by zero
Program continues normally

The @contextmanager Decorator

Writing a full class with __enter__ and __exit__ is powerful, but often overkill for simple cases. The contextlib module provides a @contextmanager decorator that lets you write a context manager as a single generator function using yield.

from contextlib import contextmanager

@contextmanager
def managed_file(filename, mode):
    print(f"Opening {filename}")
    f = open(filename, mode)
    try:
        yield f
    finally:
        print(f"Closing {filename}")
        f.close()


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

Opening notes.txt
Closing notes.txt

Everything before yield acts like __enter__ — it runs when the with block starts. The yielded value becomes the "as" variable. Everything after yield (inside finally) acts like __exit__ — it runs when the block ends, guaranteed, because it lives in a finally clause.

import time
from contextlib import contextmanager

@contextmanager
def timer(label):
    start = time.time()
    yield
    elapsed = time.time() - start
    print(f"{label} took {elapsed:.4f} seconds")


with timer("Sum calculation"):
    total = sum(range(1_000_000))

print("Total:", total)

Sum calculation took 0.0123 seconds
Total: 499999500000

Other Built-in Context Managers

The with statement is used throughout Python's standard library wherever a resource needs guaranteed cleanup.

import threading

lock = threading.Lock()

def update_shared_value():
    with lock:
        # only one thread can be inside this block at a time
        print("Updating safely...")

update_shared_value()

Updating safely...

Multiple Context Managers

You can open more than one context manager in a single with statement by separating them with commas. This is often used to work with two files at once.

with open("source.txt", "w") as src, open("backup.txt", "w") as bkp:
    src.write("original data")
    bkp.write("original data")

print("Both files closed automatically")

Both files closed automatically

Common Mistakes

Best Practices

Frequently Asked Questions

Key Takeaways

Summary

Context managers turn the repetitive "set up, then always clean up" pattern into something Python handles automatically through the with statement. Whether you write a full class with __enter__ and __exit__, or a quick generator function with @contextmanager, the result is the same: resources like files, locks, and connections are always released properly, even when errors happen.