An Introduction to the Art of Computer Programming Using Python in the Age of Generative AI

XV. Functional Programming

Introduction to Functional Programming

Functional programming is a programming paradigm that treats computation as the evaluation of mathematical functions and avoids changing states or mutable data. It emphasizes the use of functions, in contrast to the procedural and object-oriented programming paradigms. In Python, we can use functional programming principles to write clearer, more concise, and more predictable code.

Pure Functions

Pure functions are the cornerstone of functional programming. The output of a pure function is determined solely by its input values, with no observable side effects. This means that a pure function does not change any external state or depend on any external state that may change. As a result, pure functions are predictable and easier to test.

def add(a, b):
    return a + b

result = add(3, 4)
print(result)
        

Run

In the example above, the add function is pure because it always produces the same output for the same input and does not affect any external state.

Lambda Functions

Lambda functions, also known as anonymous functions, are a key feature of functional programming in Python. They allow the creation of small, unnamed functions that can be defined inline. This makes them particularly useful for functional programming constructs, where functions are often passed as arguments to higher-level functions such as map, filter, and reduce. The syntax for a lambda function is:

lambda arguments: function expression
        

Let's say we want to filter even numbers in a list. A lambda function for this would be:

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

odd_numbers = filter(lambda x: x % 2 != 0, numbers)
print(list(odd_numbers))
        

Run

Higher-Order Functions

Higher-order functions are functions that either take one or more functions as arguments or return a function as a result. They are a powerful feature in functional programming, allowing for more abstract and flexible code. Python's built-in map and filter functions are classic examples of higher-order functions.

numbers = [1, 2, 3, 4, 5]
squared_numbers = map(lambda x: x ** 2, numbers)
print(list(squared_numbers))

even_numbers = filter(lambda x: x % 2 == 0, numbers)
print(list(even_numbers))
        

Run

First-Class Functions

Functions are first-class citizens in Python. This means that functions can be assigned to variables, passed as arguments to other functions, and returned as values by other functions. This property allows the creation of higher-level functions and makes functional programming techniques more natural and expressive.

def square(x):
    return x * x

def cube(x):
    return x * x * x

def my_map(func, arg_list):
    result = []
    for i in arg_list:
        result.append(func(i))
    return result

squares = my_map(square, [1, 2, 3, 4, 5])
print(squares)

cubes = my_map(cube, [1, 2, 3, 4, 5])
print(cubes)
        

Run

Immutability

A key concept in functional programming is immutability, which means that data cannot be changed after it is created. Instead of modifying data, new data structures are created. This approach results in more predictable and bug-resistant code because functions do not have side effects that change the state of the program.

# Using tuple instead of list to ensure immutability
numbers = (0, 1, 2, 3, 4)

# Functions that operate on immutable data return new data structures
def add_one_to_each(numbers):
    return tuple(x + 1 for x in numbers)

new_numbers = add_one_to_each(numbers)
print(new_numbers)
print(numbers)
        

Run

Prompting AI for Implementing Functional Programming

Start by defining the functionality you need and the context in which it will be used. For example, instead of asking "How do I use functional programming?", ask "Can you help me write Python functions that follow functional programming principles, such as pure functions and higher-order functions?" Provide detailed requirements, such as "I need a pure function to add two numbers and higher-order functions to square and filter even numbers from a list." Ask for examples to illustrate the solution, such as "Can you provide a Python example using the map and filter functions to process a list of numbers?"

Example Prompt:

Resulting AI-generated code:

MORSE_CODE_DICT = {
    'A': '.-', 'B': '-...', 'C': '-.-.', 'D': '-..', 'E': '.', 'F': '..-.',
    'G': '--.', 'H': '....', 'I': '..', 'J': '.---', 'K': '-.-', 'L': '.-..',
    'M': '--', 'N': '-.', 'O': '---', 'P': '.--.', 'Q': '--.-', 'R': '.-.',
    'S': '...', 'T': '-', 'U': '..-', 'V': '...-', 'W': '.--', 'X': '-..-',
    'Y': '-.--', 'Z': '--..',
    '0': '-----', '1': '.----', '2': '..---', '3': '...--', '4': '....-',
    '5': '.....', '6': '-....', '7': '--...', '8': '---..', '9': '----.',
    ',': '--..--', '.': '.-.-.-', '?': '..--..', '/': '-..-.', '-': '-....-',
    '(': '-.--.', ')': '-.--.-', ' ': '/'
}

def encode_message(message):
    return ' '.join(MORSE_CODE_DICT.get(char.upper(), '') for char in message)

def decode_message(morse_code):
    reverse_dict = {value: key for key, value in MORSE_CODE_DICT.items()}
    return ''.join(reverse_dict.get(code, '') for code in morse_code.split(' '))

# Encoding a message to Morse code
message = "HELLO WORLD"
encoded_message = encode_message(message)
print(f"Encoded: {encoded_message}")

# Decoding a Morse code message
morse_code = ".... . .-.. .-.. --- / .-- --- .-. .-.. -.."
decoded_message = decode_message(morse_code)
print(f"Decoded: {decoded_message}")

Run