← Back to DevBytes
Python July 10, 2026 12 min read

Functional Programming in Python

What is Functional Programming?

Functional programming (FP) is a programming paradigm centered around building programs using pure functions — functions that avoid mutable state, side effects, and shared data. In FP, computation is treated as the evaluation of mathematical functions, emphasizing immutability, declarative style, and function composition over imperative step-by-step instructions.

Python is a multi-paradigm language. While it is fundamentally object-oriented and imperative, it borrows many powerful features from the functional world. You can write Python code that embraces functional principles without abandoning Python's core strengths. The language provides first-class functions, lambda expressions, higher-order functions like map, filter, and reduce, as well as comprehensions and modules like itertools and functools that make functional patterns both natural and efficient.

Core Concepts

Why Functional Programming Matters in Python

🚀 Deploy your AI agent in 10 minutes

Managed Hermes hosting. Zero DevOps. 100M tokens/mo included.

Try it free →

Adopting functional patterns in Python brings several concrete benefits, even when you're not writing in a "pure" functional language like Haskell:

How to Use Functional Programming in Python

1. Pure Functions

A pure function depends only on its input arguments and produces a deterministic output. It does not read or modify any external state.

# Impure: relies on and mutates external state
tax_rate = 0.15
prices_with_tax = []

def add_tax_impure(price):
    prices_with_tax.append(price + price * tax_rate)  # side effect
    return price + price * tax_rate

# Pure: everything it needs comes from parameters
def add_tax_pure(price, rate=0.15):
    return price + price * rate

# The pure version always returns the same output for the same input
assert add_tax_pure(100, 0.15) == add_tax_pure(100, 0.15)

2. Immutability

In Python, tuples, frozensets, and strings are immutable. For lists and dictionaries, prefer returning new copies rather than mutating in place.

# Mutating in place — impure, harder to reason about
def add_item_bad(cart, item):
    cart.append(item)  # mutates the original list
    return cart

# Returning a new collection — functional style
def add_item(cart, item):
    return [*cart, item]  # creates a new list

original = ['apple', 'banana']
new_cart = add_item(original, 'orange')
print(original)  # ['apple', 'banana'] — unchanged
print(new_cart)  # ['apple', 'banana', 'orange']

For nested data, consider using dataclasses with frozen=True or leveraging libraries like pyrsistent for persistent data structures.

from dataclasses import dataclass, replace

@dataclass(frozen=True)
class User:
    name: str
    age: int
    email: str

user1 = User("Alice", 30, "alice@example.com")
user2 = replace(user1, age=31)  # returns a new instance
print(user1.age)  # 30 — original unchanged
print(user2.age)  # 31

3. First-Class Functions and Lambdas

In Python, functions are objects you can assign, pass, and return. Lambda expressions create small anonymous functions inline.

# Assigning a function to a variable
def square(x):
    return x * x

f = square
print(f(5))  # 25

# Passing functions as arguments
def apply_twice(func, value):
    return func(func(value))

print(apply_twice(square, 3))  # 81 — square(square(3))

# Lambda for short, throwaway logic
add_one = lambda x: x + 1
print(add_one(10))  # 11

# Lambda used inline with higher-order functions
names = ['alice', 'bob', 'charlie']
sorted_names = sorted(names, key=lambda n: len(n))
print(sorted_names)  # ['bob', 'alice', 'charlie']

4. Higher-Order Functions: map, filter, reduce

These built-in functions are the backbone of functional data transformation in Python.

map applies a function to every item in an iterable and returns an iterator of results.

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

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

# map with named function
def celsius_to_fahrenheit(c):
    return c * 9/5 + 32

temps_c = [0, 10, 20, 30]
temps_f = list(map(celsius_to_fahrenheit, temps_c))
print(temps_f)  # [32.0, 50.0, 68.0, 86.0]

filter selects items from an iterable where a predicate function returns True.

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

# Filter even numbers
evens = filter(lambda x: x % 2 == 0, numbers)
print(list(evens))  # [2, 4, 6, 8, 10]

# Filter with named function
def is_prime(n):
    if n < 2:
        return False
    for i in range(2, int(n ** 0.5) + 1):
        if n % i == 0:
            return False
    return True

primes = list(filter(is_prime, range(2, 30)))
print(primes)  # [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]

reduce (from functools) cumulatively applies a function to items, reducing the iterable to a single value.

from functools import reduce

# Sum all numbers
numbers = [1, 2, 3, 4, 5]
total = reduce(lambda acc, x: acc + x, numbers, 0)
print(total)  # 15

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

# Build a concatenated string
words = ['functional', 'programming', 'in', 'python']
sentence = reduce(lambda acc, w: acc + ' ' + w, words)
print(sentence)  # 'functional programming in python'

5. Comprehensions: The Pythonic Functional Style

List, dict, and set comprehensions are often more readable than map/filter chains and are the preferred Pythonic way to express functional transformations.

# List comprehension — map + filter in one expression
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
squared_evens = [x ** 2 for x in numbers if x % 2 == 0]
print(squared_evens)  # [4, 16, 36, 64, 100]

# Dictionary comprehension
names = ['alice', 'bob', 'charlie']
name_lengths = {name: len(name) for name in names}
print(name_lengths)  # {'alice': 5, 'bob': 3, 'charlie': 7}

# Set comprehension
nums = [1, 2, 2, 3, 4, 4, 5]
unique_squares = {x ** 2 for x in nums}
print(unique_squares)  # {1, 4, 9, 16, 25}

# Generator expression — lazy, memory-efficient
gen = (x ** 2 for x in range(10_000_000))  # doesn't compute all at once
print(next(gen))  # 0
print(next(gen))  # 1

6. Function Composition

Function composition chains operations so the output of one function becomes the input of the next. Python doesn't have a built-in compose operator, but you can create one easily.

# Manual composition — nested calls
def double(x):
    return x * 2

def increment(x):
    return x + 1

def square(x):
    return x ** 2

result = square(increment(double(3)))  # ((3*2)+1)^2 = 49
print(result)

# Building a compose utility
from functools import reduce

def compose(*functions):
    """Compose functions right-to-left: compose(f, g, h)(x) = f(g(h(x)))"""
    return lambda x: reduce(lambda acc, func: func(acc), reversed(functions), x)

pipeline = compose(square, increment, double)
print(pipeline(3))  # 49

# For left-to-right pipelines, use a different order
def pipe(*functions):
    """Pipe functions left-to-right: pipe(f, g, h)(x) = h(g(f(x)))"""
    return lambda x: reduce(lambda acc, func: func(acc), functions, x)

pipeline = pipe(double, increment, square)
print(pipeline(3))  # 49

7. Partial Application and Currying

functools.partial lets you fix some arguments of a function, creating a new function with fewer parameters — a powerful technique for specialization and reuse.

from functools import partial

def format_price(currency_symbol, decimal_places, amount):
    return f"{currency_symbol}{amount:.{decimal_places}f}"

# Create specialized versions by fixing some arguments
format_usd = partial(format_price, "$", 2)
format_eur = partial(format_price, "€", 2)
format_jpy = partial(format_price, "¥", 0)

print(format_usd(45.678))   # $45.68
print(format_eur(45.678))   # €45.68
print(format_jpy(45.678))   # ¥46

# Partial with keyword arguments
def send_email(from_addr, to_addr, subject, body, smtp_server="smtp.default.com"):
    return f"Sending from {from_addr} to {to_addr}: {subject}"

send_from_noreply = partial(send_email, from_addr="noreply@example.com")
print(send_from_noreply(to_addr="user@example.com", subject="Hello", body="..."))

8. Working with itertools

The itertools module provides a rich set of lazy iterators for functional-style data processing — mapping, filtering, grouping, slicing, and combining infinite sequences without materializing them all at once.

import itertools

# Infinite counter starting at 10, stepping by 3
counter = itertools.count(start=10, step=3)
first_five = list(itertools.islice(counter, 5))
print(first_five)  # [10, 13, 16, 19, 22]

# Cycle through a sequence
cycler = itertools.cycle(['A', 'B', 'C'])
cycle_slice = list(itertools.islice(cycler, 8))
print(cycle_slice)  # ['A', 'B', 'C', 'A', 'B', 'C', 'A', 'B']

# Repeat a value
repeater = itertools.repeat('Hello', 4)
print(list(repeater))  # ['Hello', 'Hello', 'Hello', 'Hello']

# accumulate — like reduce but yields intermediate results
numbers = [1, 2, 3, 4, 5]
running_total = itertools.accumulate(numbers)
print(list(running_total))  # [1, 3, 6, 10, 15]

# chain — concatenate multiple iterables
result = itertools.chain([1, 2, 3], ['a', 'b', 'c'], [True, False])
print(list(result))  # [1, 2, 3, 'a', 'b', 'c', True, False]

# groupby — group consecutive items by a key
data = [('A', 1), ('A', 2), ('B', 3), ('B', 4), ('A', 5)]
grouped = itertools.groupby(data, key=lambda pair: pair[0])
for key, group in grouped:
    print(key, list(group))
# A [('A', 1), ('A', 2)]
# B [('B', 3), ('B', 4)]
# A [('A', 5)]

# product, permutations, combinations — combinatorial iterators
colors = ['red', 'blue']
sizes = ['S', 'M', 'L']
products = itertools.product(colors, sizes)
print(list(products))
# [('red', 'S'), ('red', 'M'), ('red', 'L'), ('blue', 'S'), ('blue', 'M'), ('blue', 'L')]

# combinations of 2 from a list
items = ['a', 'b', 'c', 'd']
combs = itertools.combinations(items, 2)
print(list(combs))
# [('a', 'b'), ('a', 'c'), ('a', 'd'), ('b', 'c'), ('b', 'd'), ('c', 'd')]

9. Using functools Beyond reduce and partial

The functools module offers additional tools that enhance functional patterns, including caching, total ordering, and function wrappers.

import functools
import time

# lru_cache — memoize a pure function for performance
@functools.lru_cache(maxsize=128)
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

start = time.time()
print(fibonacci(35))  # 9227465 — computed quickly thanks to caching
print(f"Took: {time.time() - start:.4f}s")

# singledispatch — function overloading based on argument type
@functools.singledispatch
def process(value):
    raise NotImplementedError(f"No handler for {type(value)}")

@process.register(str)
def _(value):
    return f"String: {value.upper()}"

@process.register(int)
def _(value):
    return f"Integer: {value * 2}"

@process.register(list)
def _(value):
    return f"List: {len(value)} items"

print(process("hello"))   # String: HELLO
print(process(42))        # Integer: 84
print(process([1,2,3]))   # List: 3 items

# wraps — preserve metadata when writing decorators
def log_calls(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print(f"Calling {func.__name__} with args={args}, kwargs={kwargs}")
        result = func(*args, **kwargs)
        print(f"Result: {result}")
        return result
    return wrapper

@log_calls
def add(a, b):
    """Add two numbers."""
    return a + b

result = add(3, 5)
print(add.__name__)   # 'add' — preserved by @wraps
print(add.__doc__)    # 'Add two numbers.' — preserved

10. Real-World Pipeline Example

Here's a complete example combining multiple functional techniques to process a dataset — a common pattern in data engineering and ETL workflows.

from functools import reduce, partial
from itertools import groupby
from dataclasses import dataclass, replace
from typing import List

# Immutable data model
@dataclass(frozen=True)
class Sale:
    product: str
    category: str
    quantity: int
    price_per_unit: float

@dataclass(frozen=True)
class RevenueSummary:
    category: str
    total_revenue: float
    total_units: int

# Sample data
sales: List[Sale] = [
    Sale("Widget A", "Widgets", 10, 12.50),
    Sale("Widget B", "Widgets", 5, 18.00),
    Sale("Gadget X", "Gadgets", 20, 8.75),
    Sale("Gadget Y", "Gadgets", 15, 9.25),
    Sale("Widget A", "Widgets", 8, 12.50),
    Sale("Gadget X", "Gadgets", 12, 8.75),
]

# Pure functions for transformation steps
def compute_revenue(sale: Sale) -> float:
    return sale.quantity * sale.price_per_unit

def sale_to_pair(sale: Sale):
    """Extract category and revenue for grouping."""
    return (sale.category, compute_revenue(sale))

def build_summary(category: str, revenues_and_quantities) -> RevenueSummary:
    """Reduce a group's data into a summary."""
    total_rev = sum(r for r, _ in revenues_and_quantities)
    total_qty = sum(q for _, q in revenues_and_quantities)
    return RevenueSummary(category=category, total_revenue=round(total_rev, 2), total_units=total_qty)

# Pipeline: annotate sales with revenue, group by category, aggregate
def process_sales(sales_data: List[Sale]) -> List[RevenueSummary]:
    # Step 1: Create pairs of (category, (revenue, quantity))
    enriched = [(s.category, (compute_revenue(s), s.quantity)) for s in sales_data]
    
    # Step 2: Sort by category for groupby (groupby requires sorted data)
    enriched.sort(key=lambda x: x[0])
    
    # Step 3: Group by category and build summaries
    summaries = []
    for category, group in groupby(enriched, key=lambda x: x[0]):
        # Extract just the (revenue, quantity) tuples from the group
        revenue_qty_pairs = [pair[1] for pair in group]
        summaries.append(build_summary(category, revenue_qty_pairs))
    
    return summaries

# Run the pipeline
summaries = process_sales(sales)
for s in summaries:
    print(f"{s.category}: ${s.total_revenue} revenue, {s.total_units} units sold")

# Output:
# Widgets: $215.00 revenue, 23 units sold
# Gadgets: $418.75 revenue, 47 units sold

Best Practices for Functional Python

Conclusion

Functional programming in Python is not an all-or-nothing proposition — it's a spectrum of techniques you can adopt incrementally. By writing pure functions, embracing immutability, and composing transformations with comprehensions and higher-order functions, you gain predictability, testability, and clarity without leaving the Python ecosystem. The standard library equips you with map, filter, reduce, itertools, and functools — a powerful toolkit that rewards functional thinking. Start by isolating side effects, converting mutable state passages into return-value chains, and using comprehensions to describe data transformations declaratively. Over time, you'll find your Python code becoming more modular, easier to reason about, and surprisingly elegant — a testament to the quiet power of functional principles woven into a language that welcomes many styles.

🚀 Need a reliable AI agent for your project?

Deploy Hermes Agent in 10 minutes. Managed hosting, zero DevOps.

Get Started — $23.99/mo
← Back to all articles