Functional Programming in Python: map, filter & reduce

Apply functional programming concepts in Python — declarative style, higher-order functions, and the map, filter, and reduce pipeline.

Python supports multiple programming paradigms, and Functional Programming (FP) is one of the most powerful. Rather than describing how to perform each computation step-by-step, FP lets you declare what transformation should happen and pass functions as values to drive that logic. Python’s support for first-class functions, lambdas, and built-in tools like map(), filter(), and reduce() makes building clean, composable data pipelines natural and expressive.

The Declarative Approach

Imperative programming focuses on how to solve a problem — you manage loops, indices, and mutable state. Declarative programming focuses on what you want — you express the logic of a computation without dictating its control flow.

Side-by-Side Comparison

Imperative (how to do it):

numbers = [1, 2, 3, 4]
doubled = []
for num in numbers:
    doubled.append(num * 2)
print(doubled)   # [2, 4, 6, 8]

Declarative (what to do):

numbers = [1, 2, 3, 4]
doubled = list(map(lambda x: x * 2, numbers))
print(doubled)   # [2, 4, 6, 8]

Both produce the same result, but the declarative version is shorter, more expressive, and has no explicit loop or intermediate list to manage.

Higher-Order Functions

A Higher-Order Function either accepts a function as an argument, returns a function as its result, or both.

Passing Functions as Arguments

def process_numbers(numbers, operation):
    return [operation(num) for num in numbers]

def square(x):
    return x * x

def cube(x):
    return x ** 3

nums = [1, 2, 3, 4, 5]
print(process_numbers(nums, square))             # [1, 4, 9, 16, 25]
print(process_numbers(nums, cube))               # [1, 8, 27, 64, 125]
print(process_numbers(nums, lambda x: x + 10))  # [11, 12, 13, 14, 15]

process_numbers doesn’t know or care what operation to perform — it delegates that decision to the caller.

Returning Functions (The Strategy Pattern)

def multiplier(factor):
    def multiply(number):
        return number * factor
    return multiply

double = multiplier(2)
triple = multiplier(3)

print(double(10))   # 20
print(triple(10))   # 30

Real-World: Salary Policy Example

def process_salary(salary, policy):
    return policy(salary)

def tax(salary):
    return salary * 0.9

def bonus(salary):
    return salary * 1.2

salary = 50000
print(process_salary(salary, tax))    # 45000.0
print(process_salary(salary, bonus))  # 60000.0

process_salary is generic. Different policies (tax, bonus) are plugged in at call time — a classic Strategy Pattern.

Built-In Higher-Order Functions

map() — Transform Every Element

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

For complex multi-line logic, pass a named function directly:

def get_grade(marks):
    if marks >= 90:
        return "A"
    elif marks >= 75:
        return "B"
    elif marks >= 50:
        return "C"
    return "F"

student_marks = [88, 45, 92, 67]
grades = list(map(get_grade, student_marks))
print(grades)   # ['B', 'F', 'A', 'C']

filter() — Keep Elements That Match a Condition

numbers = [1, 2, 3, 4, 5, 6]
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(even_numbers)   # [2, 4, 6]

reduce() — Collapse a Sequence to a Single Value

from functools import reduce

numbers = [1, 2, 3, 4]
product = reduce(lambda x, y: x * y, numbers)
# Computed as: ((1 * 2) * 3) * 4 = 24
print(product)   # 24

Functional Pipeline: Sum of Squares of Even Numbers

This classic example chains all three higher-order functions together:

from functools import reduce

numbers = [1, 2, 3, 4, 5, 6]

# Step 1: filter even numbers  → [2, 4, 6]
evens = filter(lambda x: x % 2 == 0, numbers)

# Step 2: square each value    → [4, 16, 36]
squares = map(lambda x: x ** 2, evens)

# Step 3: sum the squares      → 56
total = reduce(lambda x, y: x + y, squares)

print(total)   # 56

As a single chained statement:

total = reduce(
    lambda x, y: x + y,
    map(lambda x: x ** 2,
        filter(lambda x: x % 2 == 0, numbers))
)
print(total)   # 56

The Pythonic Equivalent

While the functional pipeline above is correct, Python often provides a more readable alternative using generator expressions and built-in functions:

numbers = [1, 2, 3, 4, 5, 6]
total = sum(x ** 2 for x in numbers if x % 2 == 0)
print(total)   # 56

Prefer generator expressions and built-in functions (sum(), max(), min(), all(), any()) for mathematical operations on collections. Use map()/filter()/reduce() when building explicit functional pipelines or integrating with callback-based APIs.