Context Managers and the with Statement in Python

Writing to Files with Context Managers

# File: examples/file_writing.py
def save_log_entry(log_message):
    with open('application.log', 'a') as log_file:
        log_file.write(f"{get_timestamp()} - {log_message}\n")
    # File is automatically closed, even if writing causes an exception

def get_timestamp():
    from datetime import datetime
    return datetime.now().strftime("%Y-%m-%d %H:%M:%S")

# Usage
save_log_entry("Application started")
save_log_entry("User authentication successful")
                

Database Connections

# File: examples/database_connection.py
import sqlite3

def query_database(query, parameters=()):
    with sqlite3.connect('example.db') as connection:
        cursor = connection.cursor()
        cursor.execute(query, parameters)
        return cursor.fetchall()
    # Connection is automatically closed and committed
    # (or rolled back if an exception occurred)

# Usage
users = query_database("SELECT name, email FROM users WHERE active=?", (True,))
for user in users:
    print(f"User: {user[0]}, Email: {user[1]}")
                

Locks for Thread Synchronization

# File: examples/threading_locks.py
import threading

# A shared resource - for example, a counter
counter = 0
counter_lock = threading.Lock()

def increment_counter():
    global counter
    
    # Using context manager for the lock
    with counter_lock:
        # This section is thread-safe
        current = counter
        # Simulate some processing time
        time.sleep(0.1)
        counter = current + 1
    # Lock is automatically released
                

Without the context manager, you'd need to explicitly release the lock, which could lead to deadlocks if you forget or if an exception occurs.

Temporarily Changing Directory

# File: examples/change_directory.py
import os
from contextlib import contextmanager

@contextmanager
def working_directory(path):
    """Temporarily change the working directory."""
    current_dir = os.getcwd()
    try:
        os.chdir(path)
        yield
    finally:
        os.chdir(current_dir)

# Usage
with working_directory('/tmp'):
    # All code inside this block operates in /tmp
    print(f"Current directory: {os.getcwd()}")
    with open('temp_file.txt', 'w') as f:
        f.write('Test data')
# Back to the original directory
print(f"Back to: {os.getcwd()}")
                

Creating a Simple Context Manager

# File: examples/custom_context_manager.py
class SimpleTimer:
    """A context manager that times code execution."""
    
    def __enter__(self):
        """Setup: Start the timer."""
        import time
        self.start_time = time.time()
        return self  # The value returned is assigned to the variable in the as clause
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        """Cleanup: Calculate and print the elapsed time."""
        import time
        elapsed = time.time() - self.start_time
        print(f"Elapsed time: {elapsed:.6f} seconds")
        # Returning False (or None) re-raises any exception that occurred
        # Returning True would suppress the exception
        return False

# Usage
with SimpleTimer() as timer:
    # Code to time
    import time
    time.sleep(1.5)  # Simulate work
    print("Work completed")
                

Using the @contextmanager Decorator

# File: examples/contextlib_examples.py
from contextlib import contextmanager
import time

@contextmanager
def timer():
    """A context manager that times code execution using the contextmanager decorator."""
    start_time = time.time()
    try:
        # The yield statement separates the setup (before) from the cleanup (after)
        yield
    finally:
        elapsed = time.time() - start_time
        print(f"Elapsed time: {elapsed:.6f} seconds")

# Usage
with timer():
    # Code to time
    time.sleep(1.5)  # Simulate work
    print("Work completed")
                

A Context Manager That Returns a Value

# File: examples/contextlib_with_value.py
from contextlib import contextmanager

@contextmanager
def open_file(filename, mode='r'):
    """A simple reimplementation of open() as a context manager."""
    file = None
    try:
        file = open(filename, mode)
        # Yield the resource to be used in the with block
        yield file
    finally:
        if file:
            file.close()

# Usage
with open_file('data.txt') as f:
    content = f.read()
    print(f"File content: {content}")