Flexible Exception Handling and Context Management with `contextlib`

1. contextlib.suppress: The Pythonic Way to Ignore Exceptions

It's common to encounter situations where an exception is an expected, non-fatal event. A classic example is deleting a file that might not exist. Your Java background might incline you towards a defensive pre-check (LBYL: Look Before You Leap), but a more common Python pattern is to just try the operation and handle the error (EAFP: Easier to Ask for Forgiveness than Permission).

The traditional EAFP approach for ignoring an error looks like this:

import os




# The 'bad' way: Verbose and the intent isn't perfectly clear
try:
    os.remove('some_temporary_file.txt')
except FileNotFoundError:



    # We don't care if the file wasn't there to begin with.
    pass 

This works, but contextlib.suppress makes your intent more explicit and the code more concise. It's a context manager that takes one or more exception types and silences them if they occur within its with block.

Here is the same operation using suppress:

The code becomes a clear, declarative statement: "Execute the following code, and suppress a FileNotFoundError if it happens."

Performance and Behavior Nuances

As you appreciate a deeper, more "brutally honest" look at the tools you use, it's worth knowing that suppress is not a zero-cost abstraction. It adds a small amount of overhead compared to a raw try/except block. For most applications, this is negligible and well worth the improved readability. However, in extremely performance-critical hot loops, a standard try/except block would be faster.

2. contextlib.ExitStack: Managing Dynamic Contexts

The with statement is excellent for a fixed number of resources:

with open('log.txt', 'w') as logfile, open('data.csv', 'r') as datafile:



    # work with both files
    ...

But what if you need to open a list of files, and you don't know how many there are until runtime? A naive for loop is a resource leak waiting to happen:

# The 'bad' way: This leaks file handles if an error occurs!
files_to_open = ['a.txt', 'b.txt', 'non_existent.txt', 'd.txt']
open_files = []
try:
    for filename in files_to_open:
        open_files.append(open(filename, 'w'))



    # ... process files ...
except FileNotFoundError:
    print("One of the files could not be opened.")
finally:
    for f in open_files:
        f.close() # This will close a.txt and b.txt, but what about non_existent.txt?



                  # The exception happened during open(), so the error handling is complex.

If open('non_existent.txt') fails, the handles for a.txt and b.txt remain open until the finally block runs, or potentially longer if an unexpected error occurs.

contextlib.ExitStack is the robust and Pythonic solution to this problem. It's a context manager that contains a stack of other context managers. It ensures that if any step in the setup fails, all resources acquired before the failure are properly cleaned up.

The key method is stack.enter_context(cm), which enters the provided context manager (cm) and registers its __exit__ method on the stack for future cleanup.

To deepen your conceptual understanding, it's helpful to see ExitStack not just as a utility, but as a fundamental pattern for resource management.

Exercise: Robustly Process and Clean Up Files

Let's combine these two tools to build a robust script. Your task is to write a function that opens multiple files for reading, logs the word count of each, and then attempts to delete them.

Requirements:

1. Create a function process_and_delete(filenames) that takes a list of filenames.
2. Use contextlib.ExitStack to safely open all files. If any file fails to open (e.g., FileNotFoundError), the function should raise that error, but not before cleanly closing any files that were already opened.
3. If all files are opened successfully, iterate through the list of file handles. For each file, read its content, count the words, and print a log message (e.g., a.txt: 15 words).
4. After all files have been processed and the ExitStack block has been exited (closing all files), loop through the original filenames list and delete each file.
5. Use contextlib.suppress to ensure that the deletion process does not fail if a file has already been removed by some other means.

Setup/Starter Code:

import os
from contextlib import ExitStack, suppress

def setup_test_files(filenames):
    """Helper to create dummy files for the exercise."""
    for name, content in filenames.items():
        with open(name, 'w') as f:
            f.write(content)
    print("Created test files:", list(filenames.keys()))

def process_and_delete(filenames):
    print("\n--- Starting processing ---")
    



    # TODO: Implement the logic using ExitStack and suppress
    
    print("--- Finished processing and cleanup ---")





# --- Test Cases ---
# 1. Successful run
all_files = {
    'file1.txt': 'this is the first file',
    'file2.txt': 'and this is the second',
}
setup_test_files(all_files)
process_and_delete(list(all_files.keys()))



# Verify files are gone
for f in all_files:
    assert not os.path.exists(f)
print("Verified files were deleted.")




# 2. Run with a non-existent file
print("\n--- Testing with a missing file ---")
files_with_error = ['file1.txt', 'non_existent.txt', 'file2.txt']
setup_test_files({'file1.txt': 'content', 'file2.txt': 'content'})
try:
    process_and_delete(files_with_error)
except FileNotFoundError as e:
    print(f"Caught expected error: {e}")



# Verify files that weren't part of the failed operation still exist
assert os.path.exists('file1.txt')
assert os.path.exists('file2.txt')
os.remove('file1.txt')
os.remove('file2.txt')
print("Verified resource cleanup on error.")

import os
from contextlib import ExitStack, suppress

def setup_test_files(filenames):
    """Helper to create dummy files for the exercise."""
    for name, content in filenames.items():
        with open(name, 'w') as f:
            f.write(content)
    print("Created test files:", list(filenames.keys()))

def process_and_delete(filenames):
    print("\n--- Starting processing ---")
    



    # 1. Use ExitStack to safely manage file handles
    with ExitStack() as stack:



        # 2. Open all files and register them with the stack
        files = [stack.enter_context(open(name)) for name in filenames]
        
        print("All files opened successfully.")
        



        # 3. Process each opened file
        for f in files:
            content = f.read()
            word_count = len(content.split())
            print(f"{f.name}: {word_count} words")
            



    # The 'with' block is now exited, and ExitStack has closed all files.
    
    print("Attempting to delete files...")



    # 4. Loop through original filenames and delete them
    for name in filenames:



        # 5. Use suppress to ignore errors if a file is already gone
        with suppress(FileNotFoundError):
            os.remove(name)
            print(f"Deleted {name}")

    print("--- Finished processing and cleanup ---")





# --- Test Cases ---
# 1. Successful run
all_files = {
    'file1.txt': 'this is the first file',
    'file2.txt': 'and this is the second',
}
setup_test_files(all_files)
process_and_delete(list(all_files.keys()))



# Verify files are gone
for f in all_files:
    assert not os.path.exists(f)
print("Verified files were deleted.")




# 2. Run with a non-existent file
print("\n--- Testing with a missing file ---")
files_with_error = ['file1.txt', 'non_existent.txt', 'file2.txt']
setup_test_files({'file1.txt': 'content', 'file2.txt': 'content'})
try:
    process_and_delete(files_with_error)
except FileNotFoundError as e:
    print(f"Caught expected error: {e}")



# Verify files that weren't part of the failed operation still exist
assert os.path.exists('file1.txt')
assert os.path.exists('file2.txt')
os.remove('file1.txt')
os.remove('file2.txt')
print("Verified resource cleanup on error.")

Conclusion

You have now added two powerful, idiomatic tools from contextlib to your arsenal for managing control flow and resources.

Key Takeaways:

• contextlib.suppress(ExceptionType): Use this to replace try...except...pass blocks. It makes your intention to ignore a specific, expected exception explicit and your code more readable.
• contextlib.ExitStack(): This is the definitive tool for managing a dynamic or variable number of resources. It guarantees that all acquired resources are cleaned up, even if an error occurs midway through the acquisition process, preventing resource leaks.
• The stack.enter_context() method is the key to adding context managers to the stack dynamically and safely.

In our next lesson, we will explore another pattern for flattening control flow: replacing long if/elif/else chains with a more scalable and testable dictionary-of-callables, a form of the Strategy pattern. We will also touch on how to model simple state machines using generators.