Context Managers

Context managers provide a clean way to manage resources that need setup and cleanup. Using the with statement ensures resources are properly acquired and released, even if exceptions occur. This eliminates the need for try/finally blocks and makes your code more readable and robust!

The with Statement

The with statement is Python's way of using context managers. When you use with, Python automatically calls setup code (enter) before the block and cleanup code (exit) after, even if an exception occurs. The most common example is file handling!

Click Run to execute your code

The Context Manager Protocol

To create a custom context manager, you need a class that implements __enter__() and __exit__() methods. The __enter__ method runs setup code and optionally returns a value. The __exit__ method handles cleanup.

Click Run to execute your code

Multiple Context Managers

You can use multiple context managers in a single with statement, either on separate lines or using commas. This is perfect for managing multiple resources simultaneously!

Click Run to execute your code

Using @contextmanager

The contextlib module provides the @contextmanager decorator, which lets you create context managers using generator functions. This is often simpler than creating a full class!

Click Run to execute your code

Common Mistakes

# Wrong - file might not close if exception occurs
file = open("data.txt")
content = file.read()
# What if exception happens here?
file.close()  # Might not execute!

# Correct - use with statement
with open("data.txt") as file:
    content = file.read()
# File automatically closed, even if exception occurs

# Wrong - cleanup might fail and hide original exception
class MyContext:
    def __enter__(self):
        return self
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        self.cleanup()  # If this raises, original exception lost!

# Correct - handle cleanup exceptions
class MyContext:
    def __enter__(self):
        return self
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        try:
            self.cleanup()
        except Exception:
            pass  # Log but don't raise
        return False  # Don't suppress original exception

# Wrong - suppresses all exceptions!
class SuppressContext:
    def __enter__(self):
        return self
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        return True  # Suppresses ALL exceptions!

with SuppressContext():
    raise ValueError("This error is hidden!")  # Won't propagate!

# Correct - only suppress specific exceptions
class SuppressContext:
    def __enter__(self):
        return self
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        if exc_type == ValueError:  # Only suppress ValueError
            return True  # Suppress this specific exception
        return False  # Let others propagate

Exercise: Create a Timer Context Manager

Click Run to execute your code

import time

class Timer:
    """Context manager for measuring execution time."""
    def __enter__(self):
        self.start = time.time()
        return self
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        self.end = time.time()
        elapsed = self.end - self.start
        print(f"Elapsed time: {elapsed:.4f} seconds")
        return False  # Don't suppress exceptions


# Test the Timer context manager
with Timer():
    time.sleep(0.5)  # Simulate some work

with Timer() as timer:
    total = sum(range(1000000))
    print(f"Sum result: {total}")

Summary

What's Next?

Context managers are essential for proper resource management! Next, we'll explore regular expressions (regex), powerful pattern matching tools that let you search, extract, and manipulate text with complex patterns. Regex is invaluable for text processing, validation, and data extraction!