Context Managers in Python: Stop Writing Try-Finally Blocks (Part 2)

Photo by Jakub Zerdzicki on Pexels

We’ve all been there: staring at a messy block of try...except...finally boilerplate just to make sure a file or a database connection gets closed properly, secretly praying we didn’t forget the cleanup step and invoke the wrath of the memory leak demons. Welcome to Old Lane 17, where we prefer our code clean, our terminal workflows snappy, and our weekend plans unburdened by debugging production crashes; thankfully, Python’s context managers are here to save us from our own forgetfulness.

The Real-World Gotcha: The Leaky Resource

Picture this: You are writing a script to process some logs. You open a file, do some heavy lifting, and maybe—just maybe—an exception gets thrown halfway through. If you forgot your cleanup logic, your file handle stays open, OS resources bleed out, and your script starts throwing Too many open files errors like it’s handing out party favors.

Here is the old-school, enterprise-bloated way we used to write this disaster:

pythonCopy
# Please don't write code like this anymore
f = open("production_nightmare.log", "w")
try:
    f.write("Everything is fine.")
    # Oh no, an unexpected error!
    raise ValueError("System meltdown")
finally:
    # Remember to close it! Except you forgot this part sometimes.
    f.close()

Enter the with Statement

Python gives us the with statement out of the box. It wraps a block of code within a context manager, guaranteeing that setup and teardown operations happen no matter what—even if your code throws a tantrum and crashes mid-execution.

Here is how you actually handle a file in the modern era:

pythonCopy
# Clean, readable, and virtually leak-proof
with open("production_nightmare.log", "w") as f:
    f.write("Ah, much better.")
    # Even if an exception happens here, Python automatically closes the file for you.

Roll Your Own Context Manager

What happens when you need to manage something custom, like a database transaction, a temporary directory, or a timer that judges how long your messy script took to run?

You can write your own context manager using Python’s built-in contextlib module. It saves you from writing whole classes with __enter__ and __exit__ methods when a simple generator will do.

pythonCopy
from contextlib import contextmanager
import time

@contextmanager
def time_it(task_name):
    start = time.time()
    print(f"[{task_name}] Starting...")
    try:
        yield
    finally:
        elapsed = time.time() - start
        print(f"[{task_name}] Done in {elapsed:.4f} seconds. Phew.")

# Using your custom context manager
with time_it("Querying the monolith"):
    # Pretend we are doing hard work here
    time.sleep(1.5)

Run that snippet in your terminal, and watch how satisfying clean resource management feels. No extra baggage, no forgotten close() calls, just pure, maintainable code that lets you get back to arguing about tab sizes.

Published by the Old Lane Developer Desk.

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