Day 8: Deeper Dive into Functions

Today, we’ll expand your understanding of functions by exploring some advanced concepts such as
recursion, closures, and writing clear function documentation. These concepts will empower you to
write more expressive and efficient code.

Step 1: Recursion

What is Recursion?

• Definition:
Recursion is a technique where a function calls itself to solve smaller instances of the same
problem.

• Key Concepts:

o Base Case: The condition under which the recursion stops.

o Recursive Case: The part of the function where it calls itself with a modified argument.

Example: Factorial Function

A classic example is calculating the factorial of a number:

def factorial(n):

"""Return the factorial of n (n!)."""

# Base case: factorial of 0 is 1.

if n == 0:

return 1

# Recursive case: n! = n * (n-1)!

else:

return n * factorial(n - 1)

# Test the function

print("Factorial of 5:", factorial(5)) # Expected output: 120

Example: Fibonacci Sequence

Another common recursive function calculates the nth Fibonacci number:

def fibonacci(n):

"""Return the nth Fibonacci number."""

# Base cases: return n for 0 and 1.

if n <= 1:
 return n

# Recursive case: sum of the two preceding numbers.

return fibonacci(n - 1) + fibonacci(n - 2)

# Test the function

print("The 7th Fibonacci number is:", fibonacci(7)) # Expected output: 13

Step 2: Closures

What is a Closure?

• Definition:
A closure occurs when a nested function captures the state of its enclosing environment,
even after the outer function has finished executing.

• Why Use Closures?

Example: Creating a Closure

def make_multiplier(multiplier):

"""Return a function that multiplies its argument by a fixed multiplier."""

def multiplier_function(number):

return number * multiplier

return multiplier_function

# Create a function that doubles the input

doubler = make_multiplier(2)

print("Double of 5:", doubler(5)) # Expected output: 10

# Create a function that triples the input

tripler = make_multiplier(3)

print("Triple of 5:", tripler(5)) # Expected output: 15

Step 3: Function Annotations and Docstrings

Function Annotations
 • Purpose:
Annotations provide hints about the expected types of parameters and return values.

• Syntax Example:

def add(a: int, b: int) -> int:

return a + b

result = add(10, 5)

print("Sum:", result)

Docstrings

• Purpose:
Docstrings are strings placed as the first statement in a function to describe what the
function does. They help improve code readability and are used by documentation tools.

• Example:

def greet(name: str = "Guest") -> None:

"""

Print a greeting message to the user.

Parameters:

name (str): The name of the user. Defaults to "Guest".

"""

print(f"Hello, {name}!")

greet("Alice")

print(greet.__doc__)

Step 4: Hands-On Exercises

Exercise 1: Write a Recursive Function for Factorial

• Task:
Create a recursive function called recursive_factorial that calculates the factorial of a given
number.

• Hints:

o Remember to include a base case (when n equals 0).

o Test your function with various inputs.

• Task:
Create a recursive function called recursive_fibonacci that returns the nth Fibonacci number.

• Hints:

o Define the base cases for n equals 0 and 1.

o Use recursion to compute higher values.

Exercise 3: Create a Closure

• Task:
Write a function make_power_function that takes an exponent as an argument and returns a
function that raises a number to that exponent.

• Example:

def make_power_function(exponent):

"""

Return a function that raises its input to the given exponent.

"""

def power_function(base):

return base ** exponent

return power_function

square = make_power_function(2)

cube = make_power_function(3)

print("Square of 4:", square(4)) # Expected output: 16

print("Cube of 3:", cube(3)) # Expected output: 27

Step 5: Experiment in the Interactive Shell

1. Open the Shell:

python

2. Try Out Some Commands:

# Test recursion: Factorial and Fibonacci

def factorial(n):
 if n == 0:

return 1

return n * factorial(n - 1)

print("Factorial of 6:", factorial(6))

def fibonacci(n):

if n <= 1:

return n

return fibonacci(n - 1) + fibonacci(n - 2)

print("Fibonacci of 8:", fibonacci(8))

# Test a closure

def make_multiplier(multiplier):

def multiplier_function(number):

return number * multiplier

return multiplier_function

doubler = make_multiplier(2)

print("Doubled 7:", doubler(7))

# Test function annotations and docstrings

def add(a: int, b: int) -> int:

"""Return the sum of a and b."""

return a + b

print("Sum using annotated function:", add(10, 15))

print("Function docstring:", add.__doc__)

3. Exit the Shell:

exit()

Step 6: Additional Learning Resources

• Python Official Documentation – More on Recursion: