Python Functions: Variable Scope and Namespaces

Real-World Examples of Scope and Namespace Usage

Let's explore some real-world examples of how scope and namespaces are used in practical Python applications:

Data Processing Pipeline

# File: data_processing.py
# Location: /python_projects/functions_tutorial/

# Global configuration
INPUT_DIR = "./data/input"
OUTPUT_DIR = "./data/output"
DEFAULT_ENCODING = "utf-8"
MAX_BATCH_SIZE = 1000

def process_data(input_file, output_file=None, encoding=None):
    """Process data from input file and write results to output file."""
    # Use globals for defaults but allow overrides
    encoding = encoding or DEFAULT_ENCODING
    
    if output_file is None:
        # Generate output filename based on input filename
        import os
        input_name = os.path.basename(input_file)
        output_name = f"processed_{input_name}"
        output_file = os.path.join(OUTPUT_DIR, output_name)
    
    # Local function for specialized processing
    def parse_line(line):
        """Parse a single line of data."""
        # Local variables for processing
        parts = line.strip().split(',')
        result = {}
        
        # Process each part
        for i, part in enumerate(parts):
            key = f"field_{i+1}"
            result[key] = part.strip()
        
        return result
    
    # Simulate processing (in a real script, this would actually read/write files)
    print(f"Processing {input_file} (encoding: {encoding})")
    print(f"Output will be written to {output_file}")
    print(f"Using parse_line function to process each line")
    
    # Return a summary
    return {
        "input_file": input_file,
        "output_file": output_file,
        "encoding": encoding,
        "status": "completed"
    }

# Batch processing function
def batch_process_files(file_list):
    """Process multiple files in batches."""
    results = []
    
    for i in range(0, len(file_list), MAX_BATCH_SIZE):
        # Process files in batches
        batch = file_list[i:i+MAX_BATCH_SIZE]
        print(f"Processing batch of {len(batch)} files...")
        
        # Process each file in the batch
        for file in batch:
            result = process_data(file)
            results.append(result)
    
    return results

# Example usage
files_to_process = [
    "./data/input/file1.csv",
    "./data/input/file2.csv",
    "./data/input/file3.csv"
]

summary = batch_process_files(files_to_process)
print(f"Processed {len(summary)} files")

In this data processing example:

• Global constants define configuration settings
• Function parameters allow for customization while providing defaults
• A local function (parse_line) handles specialized processing that's only needed within the main function
• Each function has its own local scope, isolating its variables

Web Application Request Handler

# File: web_handlers.py
# Location: /python_projects/functions_tutorial/

# Global application settings
API_VERSION = "v1"
AUTH_REQUIRED = True
MAX_REQUEST_SIZE = 1024 * 1024  # 1 MB

# Global connection pool (shared resource)
db_connection_pool = {"max_connections": 10, "timeout": 30}

def handle_request(request_data, auth_token=None):
    """Process a web API request."""
    # Check authentication if required
    if AUTH_REQUIRED and not auth_token:
        return {"error": "Authentication required", "status": 401}
    
    # Request validation logic
    def validate_request():
        """Validate the request data."""
        # Local validation rules
        required_fields = ["action", "payload"]
        
        # Check required fields
        for field in required_fields:
            if field not in request_data:
                return False, f"Missing required field: {field}"
        
        # Check request size
        import json
        request_size = len(json.dumps(request_data))
        if request_size > MAX_REQUEST_SIZE:
            return False, "Request too large"
        
        return True, None
    
    # Validate the request
    is_valid, error_message = validate_request()
    if not is_valid:
        return {"error": error_message, "status": 400}
    
    # Process the request based on action
    action = request_data["action"]
    payload = request_data["payload"]
    
    def get_database_connection():
        """Get a connection from the pool."""
        # Uses the global connection pool
        nonlocal auth_token  # Using enclosing variable
        print(f"Getting database connection with auth token: {auth_token}")
        # In a real app, this would actually get a connection
        return {"connection_id": 123, "status": "connected"}
    
    # Handle different actions
    if action == "get_user":
        # Get a database connection
        db = get_database_connection()
        
        # Simulate fetching user data
        user_id = payload.get("user_id")
        print(f"Fetching user {user_id} from database using connection {db['connection_id']}")
        
        # Return simulated result
        return {
            "status": 200,
            "data": {
                "user_id": user_id,
                "username": f"user_{user_id}",
                "email": f"user_{user_id}@example.com"
            }
        }
    
    elif action == "update_user":
        # Similar pattern for update operation
        db = get_database_connection()
        
        user_id = payload.get("user_id")
        user_data = payload.get("user_data", {})
        
        print(f"Updating user {user_id} with data: {user_data}")
        
        return {
            "status": 200,
            "data": {
                "user_id": user_id,
                "updated": True
            }
        }
    
    else:
        return {"error": f"Unknown action: {action}", "status": 400}

# Example usage
request1 = {
    "action": "get_user",
    "payload": {"user_id": 123}
}

response1 = handle_request(request1, auth_token="token123")
print(f"Response 1: {response1}")

request2 = {
    "action": "update_user",
    "payload": {
        "user_id": 123,
        "user_data": {"email": "new_email@example.com"}
    }
}

response2 = handle_request(request2, auth_token="token123")
print(f"Response 2: {response2}")

In this web application example:

• Global constants define application-wide settings
• A global connection pool is shared across requests
• Nested functions handle specific subtasks with access to the parent function's variables
• The nonlocal keyword is used to access variables from the enclosing scope
• Different request types are handled within the same function but with different logic