Functional Programming in Python

1. Introduction

Functional programming is a programming paradigm that treats computation as the evaluation of mathematical functions and avoids changing-state and mutable data. Python supports functional programming features while being primarily an imperative language.

2. Key Concepts

• First-Class Functions
• Higher-Order Functions
• Pure Functions
• Immutability
• Recursion

3. First-Class Functions

In Python, functions are first-class citizens, meaning they can be passed around as arguments, returned from other functions, and assigned to variables.

def greet(name):
    return f"Hello, {name}!"

def call_function(func, name):
    return func(name)

print(call_function(greet, "Alice"))  # Output: Hello, Alice!

4. Lambda Functions

Lambda functions are anonymous functions defined using the lambda keyword. They can take any number of arguments but can only have one expression.

add = lambda x, y: x + y
print(add(3, 5))  # Output: 8

5. Higher-Order Functions

Higher-order functions are functions that can take other functions as arguments or return them as results. Examples include map, filter, and reduce.

from functools import reduce

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

sum_numbers = reduce(lambda x, y: x + y, numbers)
print(sum_numbers)  # Output: 15

6. Functional Tools

Python provides several built-in functions and modules for functional programming:

• map(function, iterable): Applies a function to all items in an iterable.
• filter(function, iterable): Filters items out of an iterable based on a function.
• reduce(function, iterable): Reduces an iterable to a single value using a function.
• functools.partial: Creates a new function with partial application of arguments.

7. Best Practices

When writing functional code in Python, consider the following best practices:

• Avoid side effects: Ensure functions do not modify external states.
• Use descriptive names: Clearly describe what each function does.
• Keep functions small: Aim for single-responsibility functions.
• Embrace immutability: Prefer immutable data structures wherever possible.

8. FAQ