Chapter 2: Advanced Functions

Teaching Objectives

By the end of this chapter, students should:

• Understand higher-order functions in Python
• Know how to use functions as arguments and return values
• Master function closures and scoping rules
• Learn about decorators and their practical applications
• Apply functional programming concepts in Python

Preparation

Before teaching this chapter, ensure:

• Students are comfortable with basic functions and their syntax
• You have prepared examples of higher-order functions and closures
• You have real-world examples to demonstrate these concepts

Lesson Overview

1. Introduction to Higher-Order Functions (15 minutes)

Start by explaining higher-order functions:

• A higher-order function is a function that either:
  • Takes one or more functions as arguments, or
  • Returns a function as its result
• Python treats functions as first-class objects, allowing them to be passed around and manipulated like any other object

Real-world analogy: Think of higher-order functions like a manager who can delegate tasks to other workers (functions) or hire new workers (create and return functions).

Basic examples:

# Function that takes another function as an argument
def apply_function(func, value):
    return func(value)

def double(x):
    return x * 2

def square(x):
    return x ** 2

# Using the higher-order function
result1 = apply_function(double, 5)  # 10
result2 = apply_function(square, 5)  # 25

print(f"Double of 5: {result1}")
print(f"Square of 5: {result2}")

2. Functions as Arguments (20 minutes)

Dive deeper into using functions as arguments:

# Using built-in higher-order functions
numbers = [1, 2, 3, 4, 5]

# map applies a function to each item in an iterable
squared = list(map(lambda x: x**2, numbers))
print("Squared:", squared)  # [1, 4, 9, 16, 25]

# filter keeps only items where the function returns True
evens = list(filter(lambda x: x % 2 == 0, numbers))
print("Even numbers:", evens)  # [2, 4]

# sorted can use a key function for custom sorting
names = ["Alice", "Bob", "Charlie", "Dave"]
sorted_by_length = sorted(names, key=len)
print("Sorted by length:", sorted_by_length)  # ['Bob', 'Dave', 'Alice', 'Charlie']

Teaching points:

• Emphasize that map, filter, and sorted (with key) are examples of higher-order functions
• Explain how lambda functions can be used for simple, one-line function definitions
• Demonstrate how to rewrite the lambda expressions as named functions for clarity in more complex cases

Custom higher-order functions:

# Function that applies multiple functions to a value
def apply_operations(value, operations):
    result = value
    for operation in operations:
        result = operation(result)
    return result

# Define operations
def add_10(x):
    return x + 10

def multiply_by_2(x):
    return x * 2

def subtract_5(x):
    return x - 5

# Apply multiple operations in sequence
result = apply_operations(5, [add_10, multiply_by_2, subtract_5])
print(f"Result after operations: {result}")  # (5 + 10) * 2 - 5 = 25

3. Functions as Return Values (25 minutes)

Explain how functions can return other functions:

# Function factory - returns a customized function
def create_multiplier(factor):
    def multiplier(x):
        return x * factor
    return multiplier

# Create specific multiplier functions
double = create_multiplier(2)
triple = create_multiplier(3)

print(f"Double 10: {double(10)}")  # 20
print(f"Triple 10: {triple(10)}")  # 30

Teaching points:

• The inner function (multiplier) has access to the outer function's variable (factor)
• Each time the outer function is called, it creates a new function with a specific behavior
• This is a common pattern for creating customized functions on-the-fly

More complex example - creating a validation function:

def create_validator(min_value, max_value):
    def validate(value):
        return min_value <= value <= max_value
    return validate

# Create specific validators
is_valid_age = create_validator(0, 120)
is_valid_percentage = create_validator(0, 100)

print(f"Is 25 a valid age? {is_valid_age(25)}")           # True
print(f"Is 150 a valid age? {is_valid_age(150)}")         # False
print(f"Is 75 a valid percentage? {is_valid_percentage(75)}")  # True
print(f"Is 110 a valid percentage? {is_valid_percentage(110)}")  # False

4. Closures (20 minutes)

Explain the concept of closures:

• A closure is a function object that remembers values from its enclosing lexical scope (outer function) even when the outer function has finished execution
• The inner function "closes over" the variables from the outer function, forming a closure

def counter_factory():
    count = 0
    
    def increment():
        nonlocal count  # This tells Python we want to modify the outer variable
        count += 1
        return count
    
    return increment

# Create counters
counter1 = counter_factory()
counter2 = counter_factory()

print(counter1())  # 1
print(counter1())  # 2
print(counter1())  # 3

print(counter2())  # 1 (separate counter)
print(counter2())  # 2

print(counter1())  # 4 (continues from where it left off)

Teaching points:

• Each closure maintains its own separate state
• The nonlocal keyword is needed to modify variables from the outer scope
• Without nonlocal, Python would create a new local variable instead of modifying the outer one

Important concept: Variable lookup rules (LEGB):

1. Local (L): Variables defined inside the current function
2. Enclosing (E): Variables defined in enclosing functions
3. Global (G): Variables defined at the top level of the module
4. Built-in (B): Built-in functions and names in Python

5. Practical Applications of Higher-Order Functions (20 minutes)

Demonstrate real-world uses:

Example 1: Caching/memoization:

def memoize(func):
    cache = {}
    
    def wrapper(*args):
        if args in cache:
            print(f"Cache hit for {args}")
            return cache[args]
        else:
            print(f"Cache miss for {args}, calculating...")
            result = func(*args)
            cache[args] = result
            return result
    
    return wrapper

# Create a memoized function
@memoize
def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

# Try calling the function
print(fibonacci(10))  # Will show the calculation process
print(fibonacci(10))  # Will use the cached result

Example 2: Function composition:

def compose(*functions):
    def inner(x):
        result = x
        for f in reversed(functions):  # Apply functions from right to left
            result = f(result)
        return result
    return inner

# Simple functions to compose
def add_10(x): return x + 10
def multiply_by_2(x): return x * 2
def negate(x): return -x

# Create a composed function (applies functions from right to left)
composed = compose(negate, multiply_by_2, add_10)
# This is equivalent to: negate(multiply_by_2(add_10(5)))

print(composed(5))  # -((5 + 10) * 2) = -30

6. Guided Practice (20 minutes)

Have students work through these exercises:

1. Create a function that times other functions:

   import time
   
   def time_execution(func):
       def wrapper(*args, **kwargs):
           start_time = time.time()
           result = func(*args, **kwargs)
           end_time = time.time()
           execution_time = end_time - start_time
           print(f"{func.__name__} took {execution_time:.6f} seconds to run")
           return result
       return wrapper
   
   @time_execution
   def calculate_sum(n):
       total = 0
       for i in range(n):
           total += i
       return total
   
   result = calculate_sum(1000000)
   print(f"Sum: {result}")
   

2. Create a customizable greeting function:

   def create_greeter(greeting):
       def greet(name):
           return f"{greeting}, {name}!"
       return greet
   
   # Create specific greeting functions
   say_hello = create_greeter("Hello")
   say_hi = create_greeter("Hi")
   say_hola = create_greeter("Hola")
   
   # Use the greeting functions
   print(say_hello("Alice"))  # Hello, Alice!
   print(say_hi("Bob"))       # Hi, Bob!
   print(say_hola("Carlos"))  # Hola, Carlos!
   

7. Problem-Solving Activities (15 minutes)

Present students with more challenging problems:

1. Create a function that applies various conversions:

   def convert_units(value, from_unit, to_unit):
       # Define conversion factors as a nested dictionary
       conversions = {
           "meters": {
               "feet": 3.28084,
               "inches": 39.3701,
               "yards": 1.09361
           },
           "grams": {
               "ounces": 0.035274,
               "pounds": 0.00220462,
               "kilograms": 0.001
           },
           "seconds": {
               "minutes": 1/60,
               "hours": 1/3600,
               "days": 1/86400
           }
       }
       
       def converter(val):
           if from_unit not in conversions or to_unit not in conversions[from_unit]:
               return f"Conversion from {from_unit} to {to_unit} not supported"
           factor = conversions[from_unit][to_unit]
           return val * factor
       
       return converter
   
   # Create specific converters
   meters_to_feet = convert_units(value=None, from_unit="meters", to_unit="feet")
   grams_to_pounds = convert_units(value=None, from_unit="grams", to_unit="pounds")
   
   # Use the converters
   print(f"5 meters is {meters_to_feet(5):.2f} feet")
   print(f"500 grams is {grams_to_pounds(500):.2f} pounds")
   

2. Create a function that filters an iterable based on multiple criteria:

   def multi_filter(data, *filter_funcs):
       def combined_filter(item):
           return all(f(item) for f in filter_funcs)
       
       return list(filter(combined_filter, data))
   
   # Example usage
   numbers = list(range(1, 51))
   
   # Define filter criteria
   is_even = lambda x: x % 2 == 0
   is_divisible_by_3 = lambda x: x % 3 == 0
   is_greater_than_10 = lambda x: x > 10
   
   # Apply multiple filters
   result = multi_filter(numbers, is_even, is_divisible_by_3, is_greater_than_10)
   print(result)  # [12, 18, 24, 30, 36, 42, 48]
   

8. Review and Discussion (10 minutes)

• Review the key concepts covered
• Ask students to explain in their own words:
  • What is a higher-order function?
  • What is a closure and how does it work?
  • Why are these concepts useful in real-world programming?

Common Challenges and Solutions

• Conceptual difficulty: These concepts can be abstract. Use concrete analogies and visual diagrams to explain them.
• Understanding closure scope: Students often struggle with variable scoping. Practice with many examples to reinforce the concept.
• Lambda functions: Students may find lambda syntax confusing. Show when to use lambdas versus named functions.
• Memory usage: Explain that closures can lead to memory issues if overused, as they keep references to their enclosing scope.

Extension Activities

For students who finish early:

• Challenge them to implement a simple caching system for expensive function calls
• Have them create a function composition system that can handle an arbitrary number of functions
• Ask them to implement a function that can retry another function a specified number of times on failure

Assessment

Look for these indicators of understanding:

• Students can create and use higher-order functions correctly
• They understand how closures maintain state between function calls
• They can apply these concepts to solve practical problems
• They can explain the benefits of functional programming approaches

Resources

• Python Documentation on Nested Functions
• Real Python: First-Class Functions in Python
• Functional Programming in Python: A Beginner's Guide