Python Functional Programming Explained

Basic Concepts of Functional Programming

Functional programming is a programming paradigm that emphasizes using pure functions and avoiding mutable state and side effects. Although Python is not a pure functional language, it provides rich functional programming tools.

Pure Functions

Pure functions are functions that always produce the same output for the same input and have no side effects.

python
# Pure function example
def add(a, b):
    return a + b

print(add(2, 3))  # 5
print(add(2, 3))  # 5 - Same input, same output

# Impure function example
counter = 0

def increment():
    global counter
    counter += 1
    return counter

print(increment())  # 1
print(increment())  # 2 - Same input, different output (has side effects)

Immutable Data

Functional programming tends to use immutable data structures.

python
# Immutable operations
original_list = [1, 2, 3]
new_list = original_list + [4, 5]  # Create new list, don't modify original
print(original_list)  # [1, 2, 3]
print(new_list)  # [1, 2, 3, 4, 5]

# Mutable operations (not recommended)
original_list.append(4)  # Modify original list
print(original_list)  # [1, 2, 3, 4]

Higher-Order Functions

Higher-order functions are functions that accept functions as parameters or return functions.

map Function

The map function applies a specified function to each element of an iterable.

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

# Using named function
def square(x):
    return x ** 2

squared = list(map(square, numbers))
print(squared)  # [1, 4, 9, 16, 25]

# Multiple iterables
numbers1 = [1, 2, 3]
numbers2 = [4, 5, 6]
summed = list(map(lambda x, y: x + y, numbers1, numbers2))
print(summed)  # [5, 7, 9]

filter Function

The filter function filters elements of an iterable based on a condition.

python
# Basic usage
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(even_numbers)  # [2, 4, 6, 8, 10]

# Using named function
def is_even(x):
    return x % 2 == 0

even_numbers = list(filter(is_even, numbers))
print(even_numbers)  # [2, 4, 6, 8, 10]

# Filter strings
words = ["apple", "banana", "cherry", "date"]
long_words = list(filter(lambda x: len(x) > 5, words))
print(long_words)  # ['banana', 'cherry']

reduce Function

The reduce function performs cumulative operations on elements of an iterable.

python
from functools import reduce

# Basic usage
numbers = [1, 2, 3, 4, 5]
sum_result = reduce(lambda x, y: x + y, numbers)
print(sum_result)  # 15

# Calculate product
product = reduce(lambda x, y: x * y, numbers)
print(product)  # 120

# Using initial value
sum_with_initial = reduce(lambda x, y: x + y, numbers, 10)
print(sum_with_initial)  # 25

# Find maximum
max_value = reduce(lambda x, y: x if x > y else y, numbers)
print(max_value)  # 5

sorted Function

The sorted function sorts an iterable.

python
# Basic sorting
numbers = [3, 1, 4, 1, 5, 9, 2, 6]
sorted_numbers = sorted(numbers)
print(sorted_numbers)  # [1, 1, 2, 3, 4, 5, 6, 9]

# Descending order
sorted_desc = sorted(numbers, reverse=True)
print(sorted_desc)  # [9, 6, 5, 4, 3, 2, 1, 1]

# Sort by key
students = [
    {"name": "Alice", "age": 25},
    {"name": "Bob", "age": 20},
    {"name": "Charlie", "age": 30}
]
sorted_by_age = sorted(students, key=lambda x: x["age"])
print(sorted_by_age)
# [{'name': 'Bob', 'age': 20}, {'name': 'Alice', 'age': 25}, {'name': 'Charlie', 'age': 30}]

Lambda Expressions

Lambda expressions are anonymous functions, suitable for simple function definitions.

Basic Syntax

python
# Lambda expression
add = lambda x, y: x + y
print(add(3, 5))  # 8

# Equivalent to
def add(x, y):
    return x + y

Practical Applications

python
# Used with higher-order functions
numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x ** 2, numbers))
print(squared)  # [1, 4, 9, 16, 25]

# Sorting
students = [("Alice", 25), ("Bob", 20), ("Charlie", 30)]
sorted_students = sorted(students, key=lambda x: x[1])
print(sorted_students)  # [('Bob', 20), ('Alice', 25), ('Charlie', 30)]

# Conditional expression
get_grade = lambda score: "A" if score >= 90 else "B" if score >= 80 else "C"
print(get_grade(95))  # A
print(get_grade(85))  # B
print(get_grade(75))  # C

Lambda Limitations

python
# Lambda can only contain expressions, not statements
# Bad example
# bad_lambda = lambda x: if x > 0: return x  # Syntax error

# Correct approach
good_lambda = lambda x: x if x > 0 else 0
print(good_lambda(5))  # 5
print(good_lambda(-5))  # 0

Decorators

Decorators are an application of higher-order functions, used to modify or enhance function behavior.

Basic Decorator

python
def my_decorator(func):
    def wrapper():
        print("Before function execution")
        func()
        print("After function execution")
    return wrapper

@my_decorator
def say_hello():
    print("Hello!")

say_hello()
# Output:
# Before function execution
# Hello!
# After function execution

Decorator with Parameters

python
def repeat(times):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(times):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator

@repeat(3)
def greet(name):
    print(f"Hello, {name}!")

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

Preserving Function Metadata

python
from functools import wraps

def logging_decorator(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        print(f"Calling function: {func.__name__}")
        return func(*args, **kwargs)
    return wrapper

@logging_decorator
def calculate(x, y):
    """Calculate the sum of two numbers"""
    return x + y

print(calculate.__name__)  # calculate
print(calculate.__doc__)   # Calculate the sum of two numbers

Partial Functions

Partial functions fix certain parameters of a function, creating a new function.

python
from functools import partial

# Basic usage
def power(base, exponent):
    return base ** exponent

square = partial(power, exponent=2)
cube = partial(power, exponent=3)

print(square(5))  # 25
print(cube(5))    # 125

# Practical application
def greet(name, greeting, punctuation):
    return f"{greeting}, {name}{punctuation}"

hello = partial(greet, greeting="Hello", punctuation="!")
goodbye = partial(greet, greeting="Goodbye", punctuation=".")

print(hello("Alice"))    # Hello, Alice!
print(goodbye("Bob"))    # Goodbye, Bob.

List Comprehensions and Generator Expressions

List Comprehensions

python
# Basic usage
numbers = [1, 2, 3, 4, 5]
squared = [x ** 2 for x in numbers]
print(squared)  # [1, 4, 9, 16, 25]

# With condition
even_squared = [x ** 2 for x in numbers if x % 2 == 0]
print(even_squared)  # [4, 16]

# Nested
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flattened = [item for row in matrix for item in row]
print(flattened)  # [1, 2, 3, 4, 5, 6, 7, 8, 9]

Generator Expressions

python
# Basic usage
numbers = (x ** 2 for x in range(10))
print(list(numbers))  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# Memory efficiency
# List comprehension - uses a lot of memory
large_list = [x ** 2 for x in range(1000000)]

# Generator expression - almost no memory usage
large_gen = (x ** 2 for x in range(1000000))

Practical Application Scenarios

1. Data Processing Pipeline

python
from functools import reduce

# Data processing pipeline
data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Filter even numbers
even = filter(lambda x: x % 2 == 0, data)

# Square
squared = map(lambda x: x ** 2, even)

# Sum
result = reduce(lambda x, y: x + y, squared)
print(result)  # 220

2. Function Composition

python
def compose(*functions):
    """Compose multiple functions"""
    def inner(arg):
        result = arg
        for func in reversed(functions):
            result = func(result)
        return result
    return inner

# Define functions
def add_one(x):
    return x + 1

def multiply_two(x):
    return x * 2

def square(x):
    return x ** 2

# Compose functions
pipeline = compose(square, multiply_two, add_one)
print(pipeline(3))  # ((3 + 1) * 2) ** 2 = 64

3. Currying

python
def curry(func):
    """Curry function"""
    def curried(*args):
        if len(args) >= func.__code__.co_argcount:
            return func(*args)
        return lambda *more_args: curried(*(args + more_args))
    return curried

@curry
def add(a, b, c):
    return a + b + c

add_1 = add(1)
add_1_2 = add_1(2)
result = add_1_2(3)
print(result)  # 6

# Can also be called chain-style
result = add(1)(2)(3)
print(result)  # 6

4. Memoization

python
from functools import lru_cache

# Using lru_cache decorator
@lru_cache(maxsize=128)
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

print(fibonacci(100))  # Fast calculation

# Manual memoization
def memoize(func):
    cache = {}
    def wrapper(*args):
        if args not in cache:
            cache[args] = func(*args)
        return cache[args]
    return wrapper

@memoize
def fibonacci_manual(n):
    if n < 2:
        return n
    return fibonacci_manual(n-1) + fibonacci_manual(n-2)

print(fibonacci_manual(100))  # Fast calculation

Advantages of Functional Programming

1. Predictability

python
# Pure functions have predictable behavior
def calculate_discount(price, discount_rate):
    return price * (1 - discount_rate)

print(calculate_discount(100, 0.2))  # 80.0
print(calculate_discount(100, 0.2))  # 80.0 - Always the same

2. Testability

python
# Pure functions are easy to test
def add(a, b):
    return a + b

# Tests
assert add(2, 3) == 5
assert add(-1, 1) == 0
assert add(0, 0) == 0

3. Parallelism

python
# Pure functions can be safely executed in parallel
from concurrent.futures import ThreadPoolExecutor

def process_item(item):
    return item ** 2

items = list(range(1000))

with ThreadPoolExecutor(max_workers=4) as executor:
    results = list(executor.map(process_item, items))

4. Code Simplicity

python
# Functional style is more concise
numbers = [1, 2, 3, 4, 5]

# Imperative style
squared = []
for num in numbers:
    squared.append(num ** 2)

# Functional style
squared = list(map(lambda x: x ** 2, numbers))

Best Practices

1. Prioritize Pure Functions

python
# Good practice - pure function
def calculate_total(price, tax_rate):
    return price * (1 + tax_rate)

# Bad practice - has side effects
total = 0
def add_to_total(amount):
    global total
    total += amount

2. Avoid Overusing Lambda

python
# Bad practice - complex lambda
complex_lambda = lambda x: x ** 2 if x > 0 else (x * 2 if x < 0 else 0)

# Good practice - use named function
def process_number(x):
    if x > 0:
        return x ** 2
    elif x < 0:
        return x * 2
    else:
        return 0

3. Use List Comprehensions Appropriately

python
# Simple cases - use list comprehension
squared = [x ** 2 for x in range(10)]

# Complex cases - use generator or loop
def complex_process(data):
    for item in data:
        # Complex processing logic
        processed = item * 2
        if processed > 10:
            yield processed

4. Use Built-in Functions

python
# Good practice - use built-in functions
numbers = [1, 2, 3, 4, 5]
total = sum(numbers)
maximum = max(numbers)
minimum = min(numbers)

# Bad practice - manual implementation
total = 0
for num in numbers:
    total += num

Summary

Core concepts of Python functional programming:

Pure Functions: Same input always produces same output, no side effects
Immutable Data: Avoid modifying original data, create new data
Higher-Order Functions: Functions that accept or return functions (map, filter, reduce)
Lambda Expressions: Anonymous functions for simple operations
Decorators: Modify or enhance function behavior
Partial Functions: Fix function parameters, create new functions
List Comprehensions: Concisely create lists
Generator Expressions: Lazy evaluation, save memory

Advantages of functional programming:

More concise and readable code
Easier to test and debug
Better parallelism
Reduced side effects and state management

Mastering functional programming techniques enables writing more elegant and efficient Python code.

What are the features and use cases of Python functional programming?