Stop Writing Boilerplate Python: Python Context Managers That Don't Suck

Photo by Pixabay on Pexels

We’ve all been there: staring at a massive wall of try-finally blocks, frantically trying to remember if we closed our database connection, flushed our file buffer, or unlocked our thread locks before an unhandled exception ruined our Tuesday. Enter Python context managers—your ticket to cleaner code, fewer memory leaks, and looking like an absolute wizard in front of your juniors.

Welcome back to the Old Lane 17 workshop. Today, we’re cutting through the enterprise bloat and diving straight into the magic of the with statement.

The Problem: The try-finally Hangover

Picture this classic, slightly tragic Python snippet. You’re opening a file, doing some work, and making damn sure you clean up after yourself.

pythonCopy
# The Old, Sad Way
file = open("data.txt", "w")
try:
    file.write("Hello, Old Lane 17 readers!")
    # Imagine an exception happens right here...
    raise ValueError("Oops, something went wrong.")
finally:
    file.close()
    print("Phew, file closed.")

Sure, it works. But it’s verbose, ugly, and looks like Java wandered into your Python script looking for a corporate-mandated meeting. If you forget that finally block, your OS will eventually get annoyed with your open file descriptors.

The Clean Fix: The Built-in with Statement

Python’s with statement handles resource management under the hood. It guarantees teardown execution—even if your code bursts into flames halfway through.

pythonCopy
# The Clean, Modern Way
with open("data.txt", "w") as file:
    file.write("Hello, Old Lane 17 readers!")
    # Even if an exception drops here, Python safely closes the file.

Clean. Readable. No finally in sight.

Writing Your Own Context Manager (Without Over-Engineering It)

The real fun begins when you need to manage your own custom resources—like timing database queries or temporarily changing a working directory. You don’t need a massive class with __enter__ and __exit__ methods unless you’re feeling particularly masochistic.

Instead, import contextmanager from contextlib and write a generator:

pythonCopy
import time
from contextlib import contextmanager

@contextmanager
def timer(label: str):
    start_time = time.perf_counter()
    try:
        yield # Control goes back to your 'with' block
    finally:
        end_time = time.perf_counter()
        duration = end_time - start_time
        print(f"⏱️ [{label}] took {duration:.4f} seconds.")

# Look how nice this is to use:
with timer("Heavy Data Processing"):
    # Pretend we are doing hard work here
    time.sleep(1.5)

The Real-World Gotcha: Swallowing Exceptions

Here is a quick warning from the trenches. When writing custom context managers with try...finally, remember that exceptions inside the with block are paused at the yield statement, bubble up through the generator, and resume after your cleanup runs.

If you catch exceptions inside your context manager using a try...except block instead of try...finally, you might accidentally swallow critical bugs, leaving you staring at logs wondering why your app silently passed on a KeyError. Always clean up with finally, or explicitly re-raise if you catch an error.

Keep your terminal clean, your scripts concise, and your finally blocks where they belong—hidden safely behind a context manager. Until next time!

Published by the Old Lane Developer Desk.

Disclaimer: This article was generated and formatted with the assistance of Artificial Intelligence.