Python Functions: Mastering Callable Objects and Best Practices

def advanced_function(pos_only, /, pos_or_kwd, *args, kwd_only=None, **kwargs):
    """
    Demonstrates Python's argument types
    - pos_only: Positional-only arguments (Python 3.8+)
    - pos_or_kwd: Positional or keyword arguments
    - *args: Variable positional arguments
    - kwd_only: Keyword-only arguments
    - **kwargs: Variable keyword arguments
    """
    print(f"Positional-only: {pos_only}")
    print(f"Positional/kw: {pos_or_kwd}")
    print(f"Args: {args}")
    print(f"Kwd-only: {kwd_only}")
    print(f"Kwargs: {kwargs}")

# Usage example
advanced_function(1, 2, 3, 4, kwd_only="hello", extra="world")

# ❌ Dangerous - mutable default
def bad_function(items=[]):
    items.append("new_item")
    return items

# ✅ Correct approach
def good_function(items=None):
    if items is None:
        items = []
    items.append("new_item")
    return items

# Test the difference
print(bad_function())  # ['new_item']
print(bad_function())  # ['new_item', 'new_item'] - Unexpected!

print(good_function())  # ['new_item']
print(good_function())  # ['new_item'] - Correct behavior

def apply_operation(func, value):
    """Higher-order function that applies a given function to a value"""
    return func(value)

def square(x):
    return x ** 2

def double(x):
    return x * 2

# Using functions as arguments
result1 = apply_operation(square, 5)  # 25
result2 = apply_operation(double, 5)  # 10

# Function assignment
operation = square
print(operation(4))  # 16

# Lambda with map
numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x**2, numbers))
print(squared)  # [1, 4, 9, 16, 25]

# Lambda with filter
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(even_numbers)  # [2, 4]

# Lambda with sorted
students = [('Alice', 85), ('Bob', 90), ('Charlie', 78)]
sorted_by_grade = sorted(students, key=lambda student: student[1])
print(sorted_by_grade)  # [('Charlie', 78), ('Alice', 85), ('Bob', 90)]

def create_multiplier(factor):
    """Creates a closure that multiplies by a specific factor"""
    def multiplier(number):
        return number * factor
    return multiplier

# Create specialized functions
double = create_multiplier(2)
triple = create_multiplier(3)

print(double(5))  # 10
print(triple(5))  # 15

# Closure inspection
print(double.__closure__)  # Shows captured variables

import time
import functools

def timing_decorator(func):
    """Decorator that measures execution time"""
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print(f"{func.__name__} took {end - start:.4f} seconds")
        return result
    return wrapper

@timing_decorator
def slow_function():
    time.sleep(0.1)
    return "Completed"

result = slow_function()  # Prints execution time

from functools import lru_cache

@lru_cache(maxsize=128)
def fibonacci(n):
    """Efficient fibonacci calculation with caching"""
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

# First call is slow, subsequent calls are fast
print(fibonacci(10))  # 55
print(fibonacci.cache_info())  # Shows cache statistics

def fibonacci_generator(n):
    """Memory-efficient fibonacci sequence generator"""
    a, b = 0, 1
    for _ in range(n):
        yield a
        a, b = b, a + b

# Generate first 10 fibonacci numbers
fib_sequence = list(fibonacci_generator(10))
print(fib_sequence)  # [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

# Memory-efficient processing
def process_large_dataset(data):
    """Process large datasets without loading everything into memory"""
    for item in data:
        if item > 0:
            yield item ** 2

# Usage
large_numbers = range(1000000)
processed = process_large_dataset(large_numbers)
# Only processes items as needed

def create_validator(min_length, max_length, allowed_chars=None):
    """Factory function for creating validation functions"""
    def validate(text):
        if not isinstance(text, str):
            return False
        if not (min_length <= len(text) <= max_length):
            return False
        if allowed_chars and not all(c in allowed_chars for c in text):
            return False
        return True
    return validate

# Create specific validators
email_validator = create_validator(5, 50, "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789@.")
password_validator = create_validator(8, 128, "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*()")

print(email_validator("[email protected]"))  # True
print(password_validator("password123"))     # True

from contextlib import contextmanager

@contextmanager
def database_connection():
    """Context manager for database connections"""
    connection = "Connected to database"
    print(f"Opening {connection}")
    try:
        yield connection
    finally:
        print("Closing database connection")

# Usage
with database_connection() as db:
    print(f"Working with {db}")
    # Database operations here