DEV Community

Cover image for This One Python Trick Will Make Your Code Look Like a Pro’s
Aaron Rose
Aaron Rose

Posted on

This One Python Trick Will Make Your Code Look Like a Pro’s

#python #coding #softwaredevelopment #tutorial

How I learned to stop worrying about messy code and love the with statement

If you’ve written more than a few lines of Python, you’ve probably used the with statement. It’s that thing you use to open files:

with open('file.txt', 'r') as f:
    content = f.read()
Enter fullscreen mode Exit fullscreen mode

It’s clean, it’s safe, and it automatically handles the cleanup for you. But what if I told you you’re only using 1% of its power?

For a long time, I was too. I thought with was just for files. Then I discovered a tool in Python’s standard library that completely changed how I write code: contextlib.contextmanager.

It lets you build your own with statements. And it’s the easiest way to add a layer of professionalism, safety, and clarity to your scripts.

Let me show you how.

The “Aha!” Moment: A Timer

The best way to learn is by building something useful. Let’s create a context manager that times a block of code. This is perfect for benchmarking and debugging.

Here’s how you do it in just a few lines:

from contextlib import contextmanager
import time

@contextmanager
def timer():
    """A context manager that times a block of code."""
    start = time.perf_counter()  # Start the stopwatch
    try:
        yield  # This is where your code runs
    finally:
        end = time.perf_counter()  # Stop the stopwatch
        print(f"Elapsed time: {end - start:.6f} seconds")

# Using it is beautifully simple
with timer():
    result = sum(x * x for x in range(1_000_0000)) # A computationally expensive operation

print(f"Result: {result}")
Enter fullscreen mode Exit fullscreen mode

When you run this, you’ll get something like:

Elapsed time: 0.042900 seconds
Result: 333333283333335000000
Enter fullscreen mode Exit fullscreen mode

Cool, right? But the real magic isn’t the timer itself—it’s how it works. Let’s break it down.

The Big Picture Flow (The “Vibe”) 🎶

Understanding the flow of execution is key to understanding the power of this pattern. Here’s what happens, step-by-step, when Python runs your with timer() block:

  1. Enter the with block: The timer() function is called and runs until the yield statement.
  2. Setup: It records the high-resolution start time. This is the equivalent of starting a stopwatch.
  3. Pause & Handoff: It hits the yield statement and freezes completely. Your code inside the with block (the sum(...) operation) now runs.
  4. Resume & Cleanup: Once your code finishes (or even if it crashes!), the timer() function thaws and jumps directly into the finally: block. This is the genius part.
  5. Teardown: It records the end time, calculates the difference, and prints the result.

This structure—Setup → Handoff → Guaranteed Teardown—is why context managers are so robust. The try/finally block is the safety net that ensures the "stopwatch" stops no matter what.

Why This is a Game Changer

This pattern isn’t just for timers. Once you understand it, you see applications everywhere:

  • Temporary Changes: Change a setting, run your code, and guarantee it changes back.
  • Resource Locking: Acquire a lock, run your code, and guarantee the lock is released.
  • Database Transactions: Start a transaction, run your queries, and then automatically commit or roll back.

It’s the ultimate tool for writing clean, reliable, and professional-looking Python. It moves your code from “it works” to “it’s well-engineered.”

The Key Takeaway

You don’t need a fancy framework to write better code. Often, the most powerful tools are already in Python’s standard library, waiting for you to discover them.

The @contextmanager decorator is one of those tools. It teaches you a deeper principle of good software design: separating setup and teardown logic from your main business logic. This makes your code easier to read, test, and maintain.

So next time you find yourself writing repetitive setup and cleanup code, stop. Ask yourself: “Could this be a with statement?”

You might just unlock a new level of Python mastery.

Ready to Try It?

The best way to learn is to do. Take the timer() example and run it. Then, try to build your own. Maybe a context manager that temporarily changes the working directory, or one that automatically commits a database transaction.

If you build something cool, share it in the comments!

Aaron Rose is a software engineer and technology writer at tech-reader.blog and the author of Think Like a Genius.

Top comments (0)