Why should you care about contextlib?
If you’ve ever written Python, you’re likely familiar with with open('data.txt') as f:. This is a Context Manager. It helps you open files and automatically close them without worry, preventing memory leaks or hung connections.
When I first started in automation, I used to write code that opened files and intended to close() them at the end of the function. As a result, during a script run that logged continuously, I forgot to close a socket inside a loop. After just 4 hours, the server threw a “Too many open files” error and crashed the entire service. That painful lesson made me realize: manual resource management is suicide.
Normally, creating a Context Manager requires writing a class with __enter__ and __exit__, which is quite verbose. contextlib was born to eliminate that bulk. It provides tools to create context managers with just a few lines of code. Your code will be both clean and “Pythonic.”
I often use contextlib for tasks like temporarily changing the working directory or silencing logs during tests. It also ensures database connections are always returned to the pool, even if the script encounters an issue midway.
Creating Context Managers Instantly with @contextmanager
The good news is that contextlib is built into Python’s standard library. You just need to import it—no messy pip install required. The most valuable tool here is the @contextmanager decorator.
Instead of creating a class, you can turn a generator function into a Context Manager. Check out how I created this extremely handy execution timer below:
import time
from contextlib import contextmanager
@contextmanager
def execution_timer(label):
start = time.perf_counter()
try:
# Code inside the 'with' block will run here
yield
finally:
end = time.perf_counter()
print(f"[{label}] Completed in: {end - start:.4f} seconds")
# Practical usage
with execution_timer("Calculating 10 million rows of data"):
time.sleep(1.2) # Simulating heavy task
print("Processing...")
In this example, the part before yield acts as the setup, while the part in finally is the cleanup. Placing yield inside a try...finally block is mandatory. It ensures the cleanup code always runs, whether the code inside with crashes or not.
3 “Secret Weapons” for Cleaner Code
Few people know that contextlib also possesses excellent utility functions that help eliminate repetitive code blocks.
1. contextlib.suppress: Ignoring Unimportant Errors
Sometimes you want to delete a temporary file but don’t want the script to stop if the file doesn’t exist. Instead of using a lengthy try...except FileNotFoundError: pass, use suppress.
import os
from contextlib import suppress
# Delete old file if it exists; no error if it doesn't
with suppress(FileNotFoundError):
os.remove("cache_temp.tmp")
2. contextlib.closing: Automatically Closing Legacy Objects
Some older objects have a close() method but don’t support the with keyword. You can use closing to “force” them to follow the Context Manager protocol.
from contextlib import closing
from urllib.request import urlopen
with closing(urlopen('https://www.google.com')) as page:
content = page.read()
print(f"Downloaded {len(content)} bytes")
# Connection closes automatically upon exiting the with block
3. contextlib.ExitStack: Managing Multiple Resources
This is my favorite feature. Suppose you need to open 10 log files at once to merge data. Nesting 10 with blocks would create a “pyramid” of code that’s very hard to read. ExitStack helps you manage a dynamic list of resources in a flat and clean way.
from contextlib import ExitStack
def merge_logs(log_files, output_path):
with ExitStack() as stack:
# Open all files in the list simultaneously
files = [stack.enter_context(open(fname)) for fname in log_files]
with open(output_path, 'w') as out:
for f in files:
out.write(f.read())
# All files are closed neatly when the function ends
Handling Errors Like a Pro
When writing a Context Manager, it’s crucial not to let the script “hang” when an exception occurs. If an error happens inside the with block, it will be thrown right at the yield position in your generator.
You can catch this error to roll back a database or log information before letting it propagate further:
@contextmanager
def db_transaction(conn):
print("Starting Transaction...")
try:
yield conn
conn.commit()
except Exception as e:
conn.rollback()
print(f"Error: {e}. Data rolled back.")
raise
finally:
conn.close()
A small tip is to combine this with the logging module instead of using print. This helps you track if any resources are being held for too long in a production environment.
Remember the golden rule: Clean up where you open. Never assume that the code inside with will always run smoothly. Always wrapping yield in try...finally is the best way to protect your system.
In short, contextlib doesn’t just make your code look better; it’s a shield that makes your application more stable. If you’re building systems that run 24/7, start using contextlib today to avoid unfortunate resource leaks.
