Context Manager in Python

Description
A context manager is an object in Python used to manage resources (such as files, network connections, locks), ensuring that resources are properly released after use. It is invoked via the with statement, and its core mechanism relies on the __enter__ and __exit__ methods.

Why do we need context managers?
Taking file operations as an example, the traditional approach requires manually closing the file:

f = open("file.txt", "r")
try:
    data = f.read()
finally:
    f.close()  # Must manually release the resource

If you forget to close the file, it may lead to resource leaks. Context managers automatically handle resource allocation and release via the with statement.

Implementation Principle

1. __enter__ method: Executed at the beginning of the with statement, returning the resource to be managed (e.g., a file object).
2. __exit__ method: Automatically called when the with block finishes execution or when an exception occurs, used to release resources and handle exceptions.

Example: Custom Context Manager
Assuming we need to manage a database connection:

class DatabaseManager:
    def __enter__(self):
        print("Connecting to the database")
        return self  # Return the resource object
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        print("Closing the database connection")
        if exc_type:  # Handle exceptions
            print(f"Exception type: {exc_type}")
        return True  # If True is returned, the exception is suppressed; otherwise, it continues to propagate

# Using the with statement to automatically manage resources
with DatabaseManager() as db:
    print("Performing database operations")
    # If an exception occurs here, __exit__ will still close the connection normally

Output:

Connecting to the database
Performing database operations
Closing the database connection

Using the Standard Library contextlib to Simplify Implementation
For simple scenarios, the contextlib.contextmanager decorator can be used to generate a context manager:

from contextlib import contextmanager

@contextmanager
def file_manager(filename, mode):
    f = open(filename, mode)
    try:
        yield f  # Code before yield is like __enter__, code after is like __exit__
    finally:
        f.close()

with file_manager("test.txt", "w") as f:
    f.write("Hello Context Manager")

• Code before yield executes when entering the with block (similar to __enter__).
• Code after yield executes when exiting the with block (similar to __exit__), even if an exception occurs.

Key Features

1. Exception Handling: The __exit__ method receives exception parameters (exc_type, exc_val, exc_tb) and can decide whether to suppress the exception.
2. Resource Safety: Regardless of whether an exception occurs inside the with block, __exit__ ensures that resources are released.
3. Common Applications: File operations (open), locks (threading.Lock), database connections (sqlite3.connect), etc., all have built-in context managers.

Common Interview Questions

• Question: How does the with statement ensure resource release?
  Answer: By calling the context manager's __exit__ method, which is guaranteed to be called when the with block finishes execution or when an exception occurs.
• Question: How to prevent an exception in __exit__ from overriding the original exception?
  Answer: If __exit__ returns True, the exception is suppressed; if it returns False or None (default), the original exception continues to propagate.

Through context managers, Python implements a more elegant resource management paradigm, avoiding the tediousness and potential errors of manually releasing resources.