Python Lambdas and Functional Programming

 1# Traditional function definition - notice all the ceremony
 2def square(x):
 3    return x ** 2
 4
 5# Equivalent lambda expression - one line, no fuss
 6square_lambda = lambda x: x ** 2
 7
 8# Both produce exactly the same result
 9numbers = [1, 2, 3, 4, 5]
10print("Traditional function:", [square(x) for x in numbers])        # [1, 4, 9, 16, 25]
11print("Lambda function:", [square_lambda(x) for x in numbers])     # [1, 4, 9, 16, 25]
12
13# Lambda expressions can handle multiple parameters just fine
14add = lambda x, y: x + y
15multiply = lambda x, y, z: x * y * z
16
17print("Addition:", add(5, 3))        # 8
18print("Multiplication:", multiply(2, 3, 4))  # 24
19
20# Lambdas can include conditional logic too
21# This is a ternary operation - if a > b, return a, otherwise return b
22max_of_two = lambda a, b: a if a > b else b
23print("Maximum of 10 and 7:", max_of_two(10, 7))  # 10
24
25# They're great for string operations and formatting
26format_name = lambda first, last: f"{first.title()} {last.title()}"
27print("Formatted name:", format_name("john", "doe"))  # John Doe
28
29# Here's where lambdas really shine - working with data structures
30students = [
31    {"name": "Alice", "grade": 85},
32    {"name": "Bob", "grade": 92},
33    {"name": "Charlie", "grade": 78}
34]
35
36# Create little accessor functions to pull out specific fields
37get_name = lambda student: student["name"]
38get_grade = lambda student: student["grade"]
39
40print("Student names:", [get_name(s) for s in students])   # ['Alice', 'Bob', 'Charlie']
41print("Student grades:", [get_grade(s) for s in students]) # [85, 92, 78]

 1# ✅ Perfect use case: Simple, one-line operations
 2numbers = [1, 2, 3, 4, 5]
 3squared = list(map(lambda x: x ** 2, numbers))
 4print("Squared numbers:", squared)
 5
 6# ✅ Excellent for sorting with custom keys
 7# This is one of the most common and useful patterns you'll encounter
 8words = ["Python", "Java", "C", "JavaScript", "Go"]
 9sorted_by_length = sorted(words, key=lambda word: len(word))
10print("Sorted by length:", sorted_by_length)  # ['C', 'Go', 'Java', 'Python', 'JavaScript']
11
12# ❌ Don't do this - too complex for a lambda
13# This is hard to read and debug
14# complex_operation = lambda x: x ** 2 + 2 * x + 1 if x > 0 else abs(x) * 3
15
16# ✅ Much better - use a proper function for complex logic
17def complex_operation(x):
18    """
19    Perform complex mathematical operation based on sign of x.
20    
21    For positive numbers: returns x² + 2x + 1
22    For negative numbers: returns |x| * 3
23    """
24    if x > 0:
25        return x ** 2 + 2 * x + 1
26    else:
27        return abs(x) * 3
28
29# Test the function with some values
30test_values = [-5, -1, 0, 3, 7]
31print("Complex operation results:")
32for val in test_values:
33    result = complex_operation(val)
34    print(f"  f({val}) = {result}")
35
36# ✅ Great for event handlers and callbacks
37def process_data(data, callback):
38    """Process data and apply callback to each item."""
39    return [callback(item) for item in data]
40
41# Using lambda as callback - clean and readable
42data = [1, 2, 3, 4, 5]
43processed = process_data(data, lambda x: x * 2 + 1)
44print("Processed data:", processed)  # [3, 5, 7, 9, 11]
45
46# ✅ Excellent for configuration and dispatch tables
47# This pattern is incredibly useful for creating flexible, data-driven code
48operations = {
49    "add": lambda x, y: x + y,
50    "subtract": lambda x, y: x - y,
51    "multiply": lambda x, y: x * y,
52    "divide": lambda x, y: x / y if y != 0 else float('inf'),
53    "power": lambda x, y: x ** y
54}
55
56# Now you can perform operations based on string keys
57print("Calculator results:")
58print("  5 + 3 =", operations["add"](5, 3))
59print("  4 * 7 =", operations["multiply"](4, 7))
60print("  2 ^ 8 =", operations["power"](2, 8))
61
62# This is huge for building flexible systems!

 1def demonstrate_map():
 2    print("=== map() Function Examples ===")
 3    
 4    numbers = [1, 2, 3, 4, 5]
 5    
 6    # Let me show you three ways to square these numbers
 7    # The traditional way - lots of boilerplate
 8    squares_traditional = []
 9    for num in numbers:
10        squares_traditional.append(num ** 2)
11    
12    # The functional way with map and lambda - clean and expressive
13    squares_map = list(map(lambda x: x ** 2, numbers))
14    
15    # Another functional approach using an existing function
16    squares_func = list(map(pow, numbers, [2] * len(numbers)))
17    
18    print("Traditional approach:", squares_traditional)
19    print("Map + lambda:", squares_map) 
20    print("Map + pow function:", squares_func)
21    print("All three methods produce the same result!")
22    
23    # String operations are where map() really shines
24    words = ["hello", "world", "python", "programming"]
25    
26    # Capitalize first letter of each word
27    capitalized = list(map(lambda word: word.capitalize(), words))
28    print("Capitalized words:", capitalized)
29    
30    # Get length of each word - notice how clean this is
31    lengths = list(map(len, words))
32    print("Word lengths:", lengths)
33    
34    # Real-world example: temperature conversion
35    temperatures_c = [0, 20, 30, 40, 100]
36    # Convert Celsius to Fahrenheit: F = (C × 9/5) + 32
37    temperatures_f = list(map(lambda c: (c * 9/5) + 32, temperatures_c))
38    
39    print("Temperature conversion (C to F):")
40    for c, f in zip(temperatures_c, temperatures_f):
41        print(f"  {c}°C = {f}°F")
42    
43    # Here's something really cool - working with multiple iterables at once
44    names = ["Alice", "Bob", "Charlie"]
45    ages = [25, 30, 35]
46    cities = ["New York", "London", "Tokyo"]
47    
48    # Combine data from three different lists
49    person_info = list(map(
50        lambda name, age, city: f"{name}, {age} years old, from {city}",
51        names, ages, cities
52    ))
53    
54    print("\nPerson information:")
55    for info in person_info:
56        print(f"  {info}")
57    
58    # Pro tip: map() returns an iterator, so you need list() to see the results
59    print("\nPro tip: map() is lazy - it only computes when you ask for results")
60    map_result = map(lambda x: x ** 2, [1, 2, 3, 4, 5])
61    print(f"map object: {map_result}")
62    print(f"Actual values: {list(map_result)}")
63
64demonstrate_map()

 1def demonstrate_filter():
 2    print("\n=== filter() Function Examples ===")
 3    
 4    numbers = list(range(1, 21))  # [1, 2, 3, ..., 20]
 5    
 6    # Filter even numbers - this is a classic example
 7    evens = list(filter(lambda x: x % 2 == 0, numbers))
 8    print(f"Even numbers: {evens}")
 9    
10    # Filter numbers divisible by 3
11    divisible_by_3 = list(filter(lambda x: x % 3 == 0, numbers))
12    print(f"Divisible by 3: {divisible_by_3}")
13    
14    # For more complex conditions, sometimes a regular function is clearer
15    def is_prime(n):
16        """Check if a number is prime."""
17        if n < 2:
18            return False
19        # Only check up to square root for efficiency
20        for i in range(2, int(n ** 0.5) + 1):
21            if n % i == 0:
22                return False
23        return True
24    
25    primes = list(filter(is_prime, numbers))
26    print(f"Prime numbers: {primes}")
27    
28    # String filtering is incredibly useful for text processing
29    words = ["apple", "banana", "cherry", "date", "elderberry", "fig"]
30    
31    # Words longer than 5 characters
32    long_words = list(filter(lambda word: len(word) > 5, words))
33    print(f"Long words (>5 chars): {long_words}")
34    
35    # Words starting with vowels
36    vowel_words = list(filter(lambda word: word[0].lower() in 'aeiou', words))
37    print(f"Words starting with vowels: {vowel_words}")
38    
39    # Real-world example: filtering employee data
40    employees = [
41        {"name": "Alice", "department": "Engineering", "salary": 85000},
42        {"name": "Bob", "department": "Marketing", "salary": 65000},
43        {"name": "Charlie", "department": "Engineering", "salary": 95000},
44        {"name": "Diana", "department": "Sales", "salary": 70000}
45    ]
46    
47    # Find high-earning engineers - combining multiple conditions
48    high_earning_engineers = list(filter(
49        lambda emp: emp["department"] == "Engineering" and emp["salary"] > 80000,
50        employees
51    ))
52    
53    print("\nHigh-earning engineers:")
54    for emp in high_earning_engineers:
55        print(f"  {emp['name']}: ${emp['salary']:,}")
56    
57    # Filtering out unwanted data is a common use case
58    mixed_data = ["hello", "", None, "world", 0, "python", None, "", "coding"]
59    # Remove empty strings and None values
60    clean_data = list(filter(lambda x: x and x != "", mixed_data))
61    print(f"\nCleaned data: {clean_data}")
62    
63    # Working with custom objects
64    class Product:
65        def __init__(self, name, price, in_stock):
66            self.name = name
67            self.price = price
68            self.in_stock = in_stock
69        
70        def __repr__(self):
71            stock_status = "in stock" if self.in_stock else "out of stock"
72            return f"Product('{self.name}', ${self.price}, {stock_status})"
73    
74    products = [
75        Product("Laptop", 999, True),
76        Product("Mouse", 25, False),
77        Product("Keyboard", 75, True),
78        Product("Monitor", 250, True),
79        Product("Webcam", 50, False)
80    ]
81    
82    # Find available products under $100
83    affordable_available = list(filter(
84        lambda p: p.in_stock and p.price < 100,
85        products
86    ))
87    
88    print("\nAffordable available products:")
89    for product in affordable_available:
90        print(f"  {product}")
91    
92    print("\nRemember: filter() returns an iterator, just like map()!")
93
94demonstrate_filter()

  1from functools import reduce
  2
  3def demonstrate_reduce():
  4    print("\n=== reduce() Function Examples ===")
  5    
  6    numbers = [1, 2, 3, 4, 5]
  7    
  8    # Sum all numbers - the classic reduce example
  9    total = reduce(lambda x, y: x + y, numbers)
 10    print(f"Sum using reduce: {total}")
 11    print("This is like doing: ((((1 + 2) + 3) + 4) + 5)")
 12    
 13    # Find maximum value
 14    maximum = reduce(lambda x, y: x if x > y else y, numbers)
 15    print(f"Maximum using reduce: {maximum}")
 16    
 17    # Calculate factorial - perfect use case for reduce
 18    factorial_5 = reduce(lambda x, y: x * y, range(1, 6))
 19    print(f"5! = {factorial_5}")
 20    print("This computes: 1 × 2 × 3 × 4 × 5")
 21    
 22    # String operations
 23    words = ["Python", "is", "awesome", "for", "functional", "programming"]
 24    
 25    # Concatenate all words with spaces
 26    sentence = reduce(lambda x, y: x + " " + y, words)
 27    print(f"Sentence: {sentence}")
 28    
 29    # Find longest word
 30    longest_word = reduce(
 31        lambda x, y: x if len(x) > len(y) else y,
 32        words
 33    )
 34    print(f"Longest word: {longest_word}")
 35    
 36    # Real-world example: calculating business metrics
 37    sales_data = [
 38        {"product": "Laptop", "quantity": 5, "price": 999},
 39        {"product": "Mouse", "quantity": 20, "price": 25},
 40        {"product": "Keyboard", "quantity": 15, "price": 75}
 41    ]
 42    
 43    # Calculate total revenue across all products
 44    total_revenue = reduce(
 45        lambda total, item: total + (item["quantity"] * item["price"]),
 46        sales_data,
 47        0  # This is the initial value - start counting from 0
 48    )
 49    print(f"Total revenue: ${total_revenue:,}")
 50    
 51    # Building complex data structures with reduce
 52    # This creates a nested dictionary from flat data
 53    nested_dict = reduce(
 54        lambda acc, item: {**acc, item["product"]: {
 55            "quantity": item["quantity"],
 56            "revenue": item["quantity"] * item["price"]
 57        }},
 58        sales_data,
 59        {}  # Start with empty dict
 60    )
 61    print(f"Nested structure: {nested_dict}")
 62    
 63    # Flatten nested lists - super useful for data processing
 64    nested_lists = [[1, 2, 3], [4, 5], [6, 7, 8, 9]]
 65    flattened = reduce(lambda x, y: x + y, nested_lists)
 66    print(f"Flattened lists: {flattened}")
 67    
 68    # Advanced example: counting occurrences
 69    def count_occurrences(acc, item):
 70        """Update counter dictionary with new item."""
 71        acc[item] = acc.get(item, 0) + 1
 72        return acc
 73    
 74    letters = ['a', 'b', 'a', 'c', 'b', 'a', 'd', 'c', 'c']
 75    letter_counts = reduce(count_occurrences, letters, {})
 76    print(f"Letter counts: {letter_counts}")
 77    
 78    # Pro tip: reduce with complex logic
 79    def process_transactions(acc, transaction):
 80        """Process financial transactions with running balance."""
 81        acc['balance'] += transaction['amount']
 82        acc['transactions'].append({
 83            'type': transaction['type'],
 84            'amount': transaction['amount'],
 85            'running_balance': acc['balance']
 86        })
 87        return acc
 88    
 89    transactions = [
 90        {'type': 'deposit', 'amount': 1000},
 91        {'type': 'withdrawal', 'amount': -200},
 92        {'type': 'deposit', 'amount': 500},
 93        {'type': 'withdrawal', 'amount': -150}
 94    ]
 95    
 96    account_summary = reduce(process_transactions, transactions, {
 97        'balance': 0,
 98        'transactions': []
 99    })
100    
101    print(f"\nAccount balance: ${account_summary['balance']}")
102    print("Transaction history:")
103    for txn in account_summary['transactions']:
104        print(f"  {txn['type']}: ${txn['amount']:+} -> Balance: ${txn['running_balance']}")
105
106demonstrate_reduce()

  1def demonstrate_higher_order_functions():
  2    print("\n=== Higher-Order Functions ===")
  3    
  4    # Functions that return functions - this is mind-bending at first
  5    def create_multiplier(factor):
  6        """
  7        Returns a function that multiplies by the given factor.
  8        This is called a 'closure' because the inner function 'closes over' the factor variable.
  9        """
 10        return lambda x: x * factor
 11    
 12    # Create specialized functions
 13    double = create_multiplier(2)
 14    triple = create_multiplier(3)
 15    times_ten = create_multiplier(10)
 16    
 17    numbers = [1, 2, 3, 4, 5]
 18    print("Original numbers:", numbers)
 19    print("Doubled:", list(map(double, numbers)))
 20    print("Tripled:", list(map(triple, numbers)))
 21    print("Times ten:", list(map(times_ten, numbers)))
 22    
 23    # Function composition - combining simple functions to create complex behavior
 24    def compose(f, g):
 25        """
 26        Compose two functions: returns f(g(x))
 27        This is like mathematical function composition
 28        """
 29        return lambda x: f(g(x))
 30    
 31    # Simple building blocks
 32    add_one = lambda x: x + 1
 33    square = lambda x: x ** 2
 34    double = lambda x: x * 2
 35    
 36    # Compose them to create more complex operations
 37    square_after_add = compose(square, add_one)
 38    double_after_square = compose(double, square)
 39    
 40    test_value = 5
 41    print(f"\nFunction composition examples with {test_value}:")
 42    print(f"Add 1, then square: {square_after_add(test_value)}")  # (5+1)² = 36
 43    print(f"Square, then double: {double_after_square(test_value)}")  # 5² × 2 = 50
 44    
 45    # Multiple function composition - this gets really powerful
 46    def compose_multiple(*functions):
 47        """
 48        Compose multiple functions from right to left.
 49        Like mathematical notation: f(g(h(x)))
 50        """
 51        return reduce(lambda f, g: lambda x: f(g(x)), functions, lambda x: x)
 52    
 53    # Chain: add 1, then square, then double
 54    chained = compose_multiple(double, square, add_one)
 55    result = chained(3)
 56    print(f"Chained operations on 3: {result}")  # ((3+1)²)×2 = 32
 57    print("This computed: double(square(add_one(3)))")
 58    
 59    # Partial application using closures - creating specialized functions
 60    def create_validator(min_length, max_length):
 61        """
 62        Create a validator function with specific length constraints.
 63        This pattern is incredibly useful for creating configurable behavior.
 64        """
 65        def validator(text):
 66            if not isinstance(text, str):
 67                return False
 68            length = len(text)
 69            return min_length <= length <= max_length
 70        
 71        # Add some metadata to help with debugging
 72        validator.min_length = min_length
 73        validator.max_length = max_length
 74        return validator
 75    
 76    # Create specialized validators for different use cases
 77    username_validator = create_validator(3, 20)
 78    password_validator = create_validator(8, 50)
 79    tweet_validator = create_validator(1, 280)
 80    
 81    test_inputs = ["ab", "alice", "very_long_username_that_exceeds_the_maximum_limit"]
 82    
 83    print("\nValidator examples:")
 84    for inp in test_inputs:
 85        print(f"  '{inp}':")
 86        print(f"    Username valid: {username_validator(inp)}")
 87        print(f"    Password valid: {password_validator(inp)}")
 88        print(f"    Tweet valid: {tweet_validator(inp)}")
 89    
 90    # Decorator as higher-order function - this is incredibly practical
 91    def memoize(func):
 92        """
 93        Cache function results for optimization.
 94        This is a decorator that remembers previous results.
 95        """
 96        cache = {}
 97        
 98        def wrapper(*args):
 99            if args in cache:
100                print(f"Cache hit for {args}")
101                return cache[args]
102            
103            print(f"Computing {func.__name__}{args}...")
104            result = func(*args)
105            cache[args] = result
106            print(f"Cached result: {result}")
107            return result
108        
109        # Preserve function metadata
110        wrapper.__name__ = func.__name__
111        wrapper.__doc__ = func.__doc__
112        wrapper.cache = cache  # Allow access to cache for debugging
113        return wrapper
114    
115    @memoize
116    def fibonacci(n):
117        """Calculate fibonacci number recursively."""
118        if n <= 1:
119            return n
120        return fibonacci(n - 1) + fibonacci(n - 2)
121    
122    print(f"\nMemoized fibonacci(10): {fibonacci(10)}")
123    print("Notice how it only computes each value once!")
124    
125    # Function factories for different behaviors
126    def create_formatter(prefix="", suffix="", transform=None):
127        """Create a string formatter with specific rules."""
128        def formatter(text):
129            result = str(text)
130            if transform:
131                result = transform(result)
132            return f"{prefix}{result}{suffix}"
133        return formatter
134    
135    # Create different formatters
136    html_bold = create_formatter("<b>", "</b>")
137    bracket_upper = create_formatter("[", "]", str.upper)
138    quote_title = create_formatter('"', '"', str.title)
139    
140    test_text = "hello world"
141    print(f"\nFormatting '{test_text}':")
142    print(f"  HTML bold: {html_bold(test_text)}")
143    print(f"  Bracket upper: {bracket_upper(test_text)}")
144    print(f"  Quote title: {quote_title(test_text)}")
145
146demonstrate_higher_order_functions()

  1from operator import itemgetter, attrgetter, methodcaller
  2from collections import namedtuple
  3from itertools import groupby, chain
  4import statistics
  5
  6def demonstrate_functional_pipelines():
  7    print("\n=== Functional Data Processing Pipelines ===")
  8    
  9    # Let's work with a realistic dataset
 10    Employee = namedtuple('Employee', 'name department salary age years_experience')
 11    
 12    employees = [
 13        Employee("Alice Johnson", "Engineering", 85000, 28, 5),
 14        Employee("Bob Smith", "Engineering", 92000, 32, 8),
 15        Employee("Carol Davis", "Marketing", 68000, 26, 3),
 16        Employee("David Wilson", "Engineering", 78000, 24, 2),
 17        Employee("Eve Brown", "Marketing", 72000, 30, 6),
 18        Employee("Frank Miller", "Sales", 65000, 35, 10),
 19        Employee("Grace Taylor", "Engineering", 95000, 29, 7),
 20        Employee("Henry Clark", "Sales", 70000, 33, 9),
 21        Employee("Iris White", "Marketing", 75000, 27, 4)
 22    ]
 23    
 24    # Pipeline 1: Find top performers by department
 25    def analyze_top_performers_by_department(employees, top_n=2):
 26        """
 27        Analyze top performers by department using functional pipeline.
 28        This shows how to break down complex logic into clear steps.
 29        """
 30        # Step 1: Sort by department, then by salary descending
 31        sorted_employees = sorted(employees, 
 32                                key=lambda emp: (emp.department, -emp.salary))
 33        
 34        # Step 2: Group by department
 35        grouped = groupby(sorted_employees, key=attrgetter('department'))
 36        
 37        # Step 3: Take top N from each department
 38        result = {}
 39        for dept, emp_group in grouped:
 40            top_performers = list(emp_group)[:top_n]
 41            result[dept] = top_performers
 42        
 43        return result
 44    
 45    top_performers = analyze_top_performers_by_department(employees)
 46    print("Top 2 performers by department:")
 47    for dept, performers in top_performers.items():
 48        print(f"  {dept}:")
 49        for emp in performers:
 50            print(f"    {emp.name}: ${emp.salary:,} (age {emp.age})")
 51    
 52    # Pipeline 2: Complex data transformation using functional chaining
 53    def pipe(data, *functions):
 54        """
 55        Apply functions in sequence to data.
 56        This is the secret sauce for creating clean data pipelines.
 57        """
 58        return reduce(lambda result, func: func(result), functions, data)
 59    
 60    # Define transformation functions
 61    def filter_high_earners(emps, threshold=70000):
 62        return filter(lambda emp: emp.salary > threshold, emps)
 63    
 64    def add_salary_grade(emps):
 65        def grade_employee(emp):
 66            if emp.salary >= 90000:
 67                grade = "Senior"
 68            elif emp.salary >= 75000:
 69                grade = "Mid-level" 
 70            else:
 71                grade = "Junior"
 72            
 73            return {
 74                'name': emp.name,
 75                'department': emp.department,
 76                'salary': emp.salary,
 77                'age': emp.age,
 78                'grade': grade,
 79                'experience': emp.years_experience
 80            }
 81        return map(grade_employee, emps)
 82    
 83    def sort_by_experience(emps):
 84        return sorted(emps, key=lambda emp: emp['experience'], reverse=True)
 85    
 86    # Create processing pipeline
 87    high_earner_analysis = pipe(
 88        employees,
 89        lambda emps: filter_high_earners(emps, 70000),
 90        add_salary_grade,
 91        sort_by_experience,
 92        list  # Convert to list at the end
 93    )
 94    
 95    print("\nHigh earners (>$70k) analysis:")
 96    for emp_data in high_earner_analysis:
 97        print(f"  {emp_data['name']} ({emp_data['grade']}) - "
 98              f"${emp_data['salary']:,}, {emp_data['experience']} years exp")
 99    
100    # Pipeline 3: Advanced statistical analysis
101    def calculate_comprehensive_stats(employees):
102        """
103        Calculate comprehensive statistics using functional programming.
104        This shows how to aggregate data in multiple ways simultaneously.
105        """
106        # Group employees by department
107        dept_groups = {}
108        for emp in employees:
109            if emp.department not in dept_groups:
110                dept_groups[emp.department] = []
111            dept_groups[emp.department].append(emp)
112        
113        # Calculate stats for each department using functional approach
114        stats = {}
115        for dept, emp_list in dept_groups.items():
116            salaries = list(map(attrgetter('salary'), emp_list))
117            ages = list(map(attrgetter('age'), emp_list))
118            experiences = list(map(attrgetter('years_experience'), emp_list))
119            
120            stats[dept] = {
121                'count': len(emp_list),
122                'salary_stats': {
123                    'mean': statistics.mean(salaries),
124                    'median': statistics.median(salaries),
125                    'min': min(salaries),
126                    'max': max(salaries),
127                    'std_dev': statistics.stdev(salaries) if len(salaries) > 1 else 0
128                },
129                'age_stats': {
130                    'mean': statistics.mean(ages),
131                    'median': statistics.median(ages),
132                    'range': max(ages) - min(ages)
133                },
134                'experience_stats': {
135                    'mean': statistics.mean(experiences),
136                    'total_years': sum(experiences)
137                },
138                'total_payroll': sum(salaries)
139            }
140        
141        return stats
142    
143    dept_stats = calculate_comprehensive_stats(employees)
144    print("\nComprehensive department statistics:")
145    for dept, stats in dept_stats.items():
146        print(f"\n  {dept} Department:")
147        print(f"    Team size: {stats['count']} people")
148        print(f"    Salary - Mean: ${stats['salary_stats']['mean']:,.0f}, "
149              f"Median: ${stats['salary_stats']['median']:,.0f}")
150        print(f"    Salary - Range: ${stats['salary_stats']['min']:,} - "
151              f"${stats['salary_stats']['max']:,}")
152        print(f"    Age - Average: {stats['age_stats']['mean']:.1f}, "
153              f"Range: {stats['age_stats']['range']} years")
154        print(f"    Experience - Average: {stats['experience_stats']['mean']:.1f} years, "
155              f"Total: {stats['experience_stats']['total_years']} years")
156        print(f"    Total payroll: ${stats['total_payroll']:,}")
157    
158    # Pipeline 4: Complex filtering and transformation
159    def find_promotion_candidates(employees):
160        """
161        Find employees who might be ready for promotion.
162        Uses multiple criteria in a functional pipeline.
163        """
164        def is_promotion_candidate(emp):
165            # High performer with experience but potentially underpaid
166            dept_avg_salaries = {
167                'Engineering': 85000,
168                'Marketing': 72000,
169                'Sales': 68000
170            }
171            
172            expected_salary = dept_avg_salaries.get(emp.department, 70000)
173            return (emp.years_experience >= 4 and 
174                    emp.salary < expected_salary * 1.1 and
175                    emp.age < 35)
176        
177        candidates = pipe(
178            employees,
179            lambda emps: filter(is_promotion_candidate, emps),
180            lambda emps: map(lambda emp: {
181                'name': emp.name,
182                'department': emp.department,
183                'current_salary': emp.salary,
184                'years_experience': emp.years_experience,
185                'age': emp.age,
186                'potential_increase': int(emp.salary * 0.15)
187            }, emps),
188            lambda emps: sorted(emps, key=lambda emp: emp['years_experience'], reverse=True),
189            list
190        )
191        
192        return candidates
193    
194    promotion_candidates = find_promotion_candidates(employees)
195    print("\nPromotion candidates:")
196    for candidate in promotion_candidates:
197        print(f"  {candidate['name']} ({candidate['department']}) - "
198              f"${candidate['current_salary']:,} → "
199              f"${candidate['current_salary'] + candidate['potential_increase']:,}")
200
201demonstrate_functional_pipelines()

  1from itertools import (
  2    chain, combinations, permutations, product,
  3    accumulate, cycle, repeat, takewhile, dropwhile,
  4    groupby, compress, filterfalse, islice, tee
  5)
  6
  7def demonstrate_itertools():
  8    print("\n=== itertools for Functional Programming ===")
  9    
 10    # Chain - combining multiple iterables seamlessly
 11    list1 = [1, 2, 3]
 12    list2 = ['a', 'b', 'c'] 
 13    list3 = [10, 20, 30]
 14    
 15    chained = list(chain(list1, list2, list3))
 16    print(f"Chained iterables: {chained}")
 17    
 18    # Real-world example: combining data from multiple sources
 19    engineering_employees = ["Alice", "Bob", "Charlie"]
 20    marketing_employees = ["Diana", "Eve"] 
 21    sales_employees = ["Frank", "Grace", "Henry"]
 22    
 23    all_employees = list(chain(engineering_employees, marketing_employees, sales_employees))
 24    print(f"All employees: {all_employees}")
 25    
 26    # Combinations and permutations - incredibly useful for analysis
 27    colors = ['red', 'green', 'blue']
 28    
 29    # All possible 2-color combinations (order doesn't matter)
 30    color_combinations = list(combinations(colors, 2))
 31    print(f"Color combinations: {color_combinations}")
 32    
 33    # All possible 2-color arrangements (order matters)
 34    color_permutations = list(permutations(colors, 2))
 35    print(f"Color permutations: {color_permutations}")
 36    
 37    # Cartesian product - perfect for generating test cases or product variants
 38    sizes = ['S', 'M', 'L']
 39    materials = ['Cotton', 'Polyester']
 40    
 41    product_variants = list(product(colors, sizes, materials))
 42    print(f"Product variants (first 5): {product_variants[:5]}")
 43    print(f"Total variants possible: {len(product_variants)}")
 44    
 45    # Accumulate - running totals and cumulative operations
 46    daily_sales = [100, 150, 200, 180, 220, 190, 160]
 47    
 48    # Running total
 49    running_total = list(accumulate(daily_sales))
 50    print(f"Daily sales: {daily_sales}")
 51    print(f"Running total: {running_total}")
 52    
 53    # Running maximum (using custom function)
 54    running_max = list(accumulate(daily_sales, max))
 55    print(f"Running maximum: {running_max}")
 56    
 57    # Running average (more complex example)
 58    def running_average_func(acc_count, new_value):
 59        acc, count = acc_count
 60        count += 1
 61        new_acc = acc + (new_value - acc) / count
 62        return (new_acc, count)
 63    
 64    # Start with (0, 0) - (accumulator, count)
 65    running_avg_data = list(accumulate(daily_sales, 
 66        lambda acc_count, val: (acc_count[0] + (val - acc_count[0]) / (acc_count[1] + 1), acc_count[1] + 1),
 67        initial=(0, 0)
 68    ))
 69    running_averages = [round(avg, 1) for avg, _ in running_avg_data[1:]]  # Skip the initial value
 70    print(f"Running averages: {running_averages}")
 71    
 72    # Takewhile and dropwhile - conditional iteration
 73    numbers = [1, 3, 5, 8, 9, 11, 4, 6, 13, 15]
 74    
 75    # Take elements while condition is true
 76    small_numbers = list(takewhile(lambda x: x < 10, numbers))
 77    print(f"Numbers while < 10: {small_numbers}")
 78    
 79    # Drop elements while condition is true, keep the rest
 80    after_threshold = list(dropwhile(lambda x: x < 10, numbers))
 81    print(f"Numbers after first >= 10: {after_threshold}")
 82    
 83    # Compress - filtering with boolean mask
 84    employee_names = ['Alice', 'Bob', 'Charlie', 'Diana', 'Eve', 'Frank']
 85    performance_scores = [85, 72, 91, 68, 94, 78]
 86    high_performers = [score >= 80 for score in performance_scores]  # Boolean mask
 87    
 88    top_employees = list(compress(employee_names, high_performers))
 89    print(f"High-performing employees: {top_employees}")
 90    
 91    # Group consecutive elements - incredibly useful for data analysis
 92    def analyze_sales_trends():
 93        """Analyze sales trends using groupby."""
 94        # Sample sales data with trends
 95        sales_data = [
 96            ('Jan', 'up'), ('Feb', 'up'), ('Mar', 'up'),
 97            ('Apr', 'down'), ('May', 'down'),
 98            ('Jun', 'up'), ('Jul', 'up'), ('Aug', 'up'), ('Sep', 'up'),
 99            ('Oct', 'down'), ('Nov', 'down'), ('Dec', 'up')
100        ]
101        
102        # Group consecutive trends
103        trend_groups = groupby(sales_data, key=lambda x: x[1])
104        
105        print("Sales trend analysis:")
106        for trend, months in trend_groups:
107            month_list = [month for month, _ in months]
108            print(f"  {trend.title()} trend: {month_list} ({len(month_list)} months)")
109    
110    analyze_sales_trends()
111    
112    # Advanced pattern: sliding window
113    def sliding_window(iterable, n):
114        """
115        Create sliding window of size n over iterable.
116        Perfect for time series analysis and moving averages.
117        """
118        # Create n iterators, each starting at different positions
119        iterators = []
120        iterator = iter(iterable)
121        
122        # Fill the first window
123        window = []
124        for _ in range(n):
125            try:
126                window.append(next(iterator))
127            except StopIteration:
128                break
129        
130        if len(window) == n:
131            yield tuple(window)
132        
133        # Slide the window
134        for item in iterator:
135            window = window[1:] + [item]
136            yield tuple(window)
137    
138    sequence = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
139    windows = list(sliding_window(sequence, 3))
140    print(f"Sliding windows (size 3): {windows}")
141    
142    # Calculate moving averages
143    moving_averages = [sum(window) / len(window) for window in windows]
144    print(f"Moving averages: {[round(avg, 1) for avg in moving_averages]}")
145    
146    # Advanced example: data processing pipeline with itertools
147    def process_log_data():
148        """
149        Simulate processing log data using itertools.
150        This shows how to handle large datasets efficiently.
151        """
152        # Simulate log entries
153        log_entries = [
154            "ERROR: Database connection failed",
155            "INFO: User login successful", 
156            "ERROR: Invalid API key",
157            "INFO: Data processed successfully",
158            "WARNING: High memory usage",
159            "ERROR: Timeout occurred",
160            "INFO: Backup completed"
161        ]
162        
163        # Extract error messages only
164        error_entries = filter(lambda entry: entry.startswith("ERROR"), log_entries)
165        
166        # Group similar errors
167        def error_category(entry):
168            if "connection" in entry.lower():
169                return "connection"
170            elif "api" in entry.lower() or "key" in entry.lower():
171                return "authentication"
172            elif "timeout" in entry.lower():
173                return "timeout"
174            else:
175                return "other"
176        
177        # Sort by category for grouping
178        sorted_errors = sorted(error_entries, key=error_category)
179        grouped_errors = groupby(sorted_errors, key=error_category)
180        
181        print("Error analysis:")
182        for category, errors in grouped_errors:
183            error_list = list(errors)
184            print(f"  {category.title()} errors ({len(error_list)}):")
185            for error in error_list:
186                print(f"    {error}")
187    
188    process_log_data()
189    
190    # Memory-efficient processing with tee
191    def demonstrate_tee():
192        """Show how tee can split an iterator for multiple processing paths."""
193        numbers = range(1, 21)  # 1 to 20
194        
195        # Split the iterator into three independent iterators
196        iter1, iter2, iter3 = tee(numbers, 3)
197        
198        # Process each iterator differently
199        evens = list(filter(lambda x: x % 2 == 0, iter1))
200        squares = list(map(lambda x: x ** 2, iter2))  
201        large_numbers = list(filter(lambda x: x > 15, iter3))
202        
203        print(f"From same source - Evens: {evens[:5]}...")
204        print(f"From same source - Squares: {squares[:5]}...")
205        print(f"From same source - Large: {large_numbers}")
206    
207    demonstrate_tee()
208
209demonstrate_itertools()

  1import time
  2from functools import lru_cache, partial
  3import sys
  4
  5def demonstrate_performance_best_practices():
  6    print("\n=== Performance Best Practices ===")
  7    
  8    # 1. List comprehensions vs map/filter - the eternal debate
  9    def compare_performance():
 10        """Compare different approaches to the same problem."""
 11        # Create a reasonably large dataset for meaningful comparison
 12        data = list(range(100000))
 13        
 14        print("Processing 100,000 numbers: square all even numbers")
 15        
 16        # Method 1: List comprehension (Pythonic)
 17        start = time.time()
 18        result1 = [x * x for x in data if x % 2 == 0]
 19        time1 = time.time() - start
 20        
 21        # Method 2: Map + filter (Functional)
 22        start = time.time()
 23        result2 = list(map(lambda x: x * x, filter(lambda x: x % 2 == 0, data)))
 24        time2 = time.time() - start
 25        
 26        # Method 3: Traditional loop (Imperative)
 27        start = time.time()
 28        result3 = []
 29        for x in data:
 30            if x % 2 == 0:
 31                result3.append(x * x)
 32        time3 = time.time() - start
 33        
 34        print(f"  List comprehension: {time1:.4f}s")
 35        print(f"  Map + filter: {time2:.4f}s")
 36        print(f"  Traditional loop: {time3:.4f}s")
 37        print(f"  All results equal: {result1 == result2 == result3}")
 38        print(f"  Winner: List comprehension is typically fastest in Python!")
 39        
 40        # Memory usage comparison
 41        print(f"\nMemory efficiency:")
 42        print(f"  List comprehension memory: {sys.getsizeof(result1)} bytes")
 43        print(f"  Map + filter memory: {sys.getsizeof(result2)} bytes")
 44    
 45    compare_performance()
 46    
 47    # 2. Generator expressions for memory efficiency
 48    def demonstrate_generators():
 49        """Show the power of generators for large datasets."""
 50        print("\n--- Generator Memory Efficiency ---")
 51        
 52        # Regular list - loads everything into memory
 53        large_list = [x ** 2 for x in range(1000000)]
 54        print(f"List of 1M squares: {sys.getsizeof(large_list)} bytes")
 55        
 56        # Generator - computes on demand
 57        large_generator = (x ** 2 for x in range(1000000))
 58        print(f"Generator of 1M squares: {sys.getsizeof(large_generator)} bytes")
 59        
 60        # Memory-efficient pipeline processing
 61        def process_large_dataset_efficiently():
 62            """Process data without loading everything into memory."""
 63            # Simulate reading from a large file or database
 64            def data_source():
 65                for i in range(1000000):
 66                    yield f"record_{i}"
 67            
 68            # Generator pipeline - memory efficient
 69            pipeline = (
 70                record.upper()                    # Transform each record
 71                for record in data_source()       # Source data
 72                if 'record_9' in record           # Filter condition
 73            )
 74            
 75            # Process only what we need
 76            sample_results = [next(pipeline) for _ in range(5)]
 77            return sample_results
 78        
 79        results = process_large_dataset_efficiently()
 80        print(f"Processed sample: {results}")
 81        print("Generator pipelines use constant memory regardless of data size!")
 82    
 83    demonstrate_generators()
 84    
 85    # 3. Memoization for expensive computations
 86    print("\n--- Memoization for Performance ---")
 87    
 88    # Regular fibonacci (inefficient)
 89    def fibonacci_slow(n):
 90        """Slow fibonacci - recalculates everything."""
 91        if n <= 1:
 92            return n
 93        return fibonacci_slow(n - 1) + fibonacci_slow(n - 2)
 94    
 95    # Memoized fibonacci (fast)
 96    @lru_cache(maxsize=128)
 97    def fibonacci_fast(n):
 98        """Fast fibonacci with memoization."""
 99        if n <= 1:
100            return n
101        return fibonacci_fast(n - 1) + fibonacci_fast(n - 2)
102    
103    # Compare performance
104    test_value = 35
105    
106    print(f"Computing fibonacci({test_value}):")
107    
108    start = time.time()
109    result_fast = fibonacci_fast(test_value)
110    fast_time = time.time() - start
111    
112    print(f"  Memoized version: {result_fast} in {fast_time:.4f}s")
113    print("  (The slow version would take several seconds!)")
114    
115    # Show cache effectiveness
116    print(f"  Cache info: {fibonacci_fast.cache_info()}")
117    
118    # 4. Partial application for performance optimization
119    def demonstrate_partial_optimization():
120        """Show how partial can optimize repeated function calls."""
121        print("\n--- Partial Application Optimization ---")
122        
123        def complex_calculation(base_rate, tax_rate, bonus_multiplier, salary):
124            """Simulate a complex business calculation."""
125            # Simulate some expensive computation
126            time.sleep(0.0001)  # 0.1ms delay
127            return salary * base_rate * (1 + tax_rate) * bonus_multiplier
128        
129        # Company-specific rates (these don't change often)
130        company_base_rate = 1.05
131        company_tax_rate = 0.15
132        company_bonus_multiplier = 1.10
133        
134        # Pre-configure with partial
135        calculate_employee_pay = partial(
136            complex_calculation, 
137            company_base_rate, 
138            company_tax_rate, 
139            company_bonus_multiplier
140        )
141        
142        salaries = [50000, 60000, 75000, 80000, 90000] * 20  # 100 employees
143        
144        # Traditional approach
145        start = time.time()
146        results1 = [complex_calculation(company_base_rate, company_tax_rate, 
147                                      company_bonus_multiplier, salary) 
148                   for salary in salaries]
149        traditional_time = time.time() - start
150        
151        # Partial application approach
152        start = time.time()
153        results2 = [calculate_employee_pay(salary) for salary in salaries]
154        partial_time = time.time() - start
155        
156        print(f"Processing {len(salaries)} employee salaries:")
157        print(f"  Traditional approach: {traditional_time:.4f}s")
158        print(f"  Partial application: {partial_time:.4f}s")
159        print(f"  Speedup: {traditional_time/partial_time:.2f}x")
160        print(f"  Results equal: {results1 == results2}")
161        
162    demonstrate_partial_optimization()
163    
164    # 5. Choosing the right tool for the job
165    def performance_guidelines():
166        """Guidelines for choosing functional vs other approaches."""
167        print("\n--- Performance Guidelines ---")
168        
169        guidelines = [
170            "✅ Use list comprehensions for simple transformations",
171            "✅ Use generators for large datasets or streaming data", 
172            "✅ Use map/filter when working with existing functions",
173            "✅ Use functools.lru_cache for expensive recursive functions",
174            "✅ Use partial for repeated calls with fixed parameters",
175            "❌ Avoid deep recursion in Python (stack overflow risk)",
176            "❌ Avoid complex lambdas that hurt readability",
177            "❌ Don't use functional style just because you can"
178        ]
179        
180        for guideline in guidelines:
181            print(f"  {guideline}")
182
183    performance_guidelines()
184
185demonstrate_performance_best_practices()