Functional Programming in Python

Python is not a purely functional language, but it supports functional-style programming well — first-class functions, higher-order functions, and a preference for expressions over mutation — as one tool among several, not a religion.

Functional programming (FP) is a paradigm built around treating computation as the evaluation of functions, favoring immutable data and pure functions (no side effects) over step-by-step mutation of state. Python is a multi-paradigm language — it supports FP idioms natively (functions as first-class objects, lambda, map/filter, comprehensions, functools) without forcing you to abandon imperative or object-oriented code where those fit better.

What Functional Programming Means in Python

Functional programming is not a strict switch Python has; it is a STYLE you can lean into using ordinary Python features. The core ideas: functions are values you can pass around and combine, computation is expressed as composing functions rather than mutating variables in a loop, and (where practical) functions avoid side effects so their output depends only on their input.

Python is NOT a purely functional language like Haskell — it has no built-in enforcement of immutability or purity, and idiomatic Python code freely mixes functional, imperative, and object-oriented styles depending on what best fits the problem.

First-Class Functions

In Python, functions are objects like any other: they can be assigned to variables, stored in data structures, passed as arguments, and returned from other functions. This "first-class function" property is the foundation everything else in functional-style Python is built on.

def shout(text: str) -> str:
    return text.upper() + "!"

greeting = shout          # assign the function itself to a name
print(greeting("hello"))  # HELLO!

operations = [str.upper, str.lower, str.title]  # functions stored in a list
for op in operations:
    print(op("Python"))

Higher-Order Functions

A higher-order function either accepts a function as an argument, returns a function as a result, or both. This lets you parameterize behavior itself, not just data — the essence of functional composition.

def apply_twice(fn, value):
    return fn(fn(value))

def make_multiplier(factor: int):
    def multiplier(x: int) -> int:
        return x * factor
    return multiplier

double = make_multiplier(2)
print(apply_twice(double, 5))   # 20 -> double(double(5)) = double(10) = 20

Pure Functions and Side Effects

A pure function's output depends only on its inputs, and it produces no observable side effects (no mutating external state, no I/O, no modifying its arguments in place). Pure functions are easier to test, reason about, and safely reuse or parallelize, because calling them repeatedly with the same inputs always gives the same result and changes nothing else.

A function that mutates a mutable argument in place is also impure, even without touching globals — because the caller observes a change beyond the return value:

# Impure: depends on and mutates external state
total = 0
def add_to_total(x):
    global total
    total += x   # side effect: mutates state outside the function
    return total

# Pure: output depends only on inputs, no external state touched
def add(a: int, b: int) -> int:
    return a + b

# Impure: mutates the caller's list as a side effect
def add_item_impure(items: list[str], item: str) -> None:
    items.append(item)

# Pure: returns a new list, leaves the original untouched
def add_item_pure(items: list[str], item: str) -> list[str]:
    return items + [item]

original = ["a", "b"]
new_list = add_item_pure(original, "c")
print(original)  # ['a', 'b'] — untouched
print(new_list)  # ['a', 'b', 'c']

Immutability Concepts

Functional style favors building new values over mutating existing ones. Python's immutable built-in types (str, tuple, frozenset, numbers) support this naturally; for mutable types like list and dict, functional-style code deliberately avoids in-place mutation, preferring to construct new containers (via comprehensions, +, or library functions) even though the language would allow mutation.

numbers = (1, 2, 3, 4, 5)  # tuple: immutable by construction

# Functional style: derive a new tuple, don't mutate
doubled = tuple(n * 2 for n in numbers)
print(numbers)   # (1, 2, 3, 4, 5) — original unchanged
print(doubled)   # (2, 4, 6, 8, 10)

Declarative vs Imperative Style

Imperative code describes HOW to compute a result step by step (loops, explicit mutation); declarative/functional code describes WHAT result is wanted, letting the underlying operation handle the how. Comprehensions and functions like map/filter/sum are Python's most common declarative constructs.

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

# Imperative: explicit loop and mutation
evens_imperative = []
for n in numbers:
    if n % 2 == 0:
        evens_imperative.append(n)

# Declarative: describes the result directly
evens_declarative = [n for n in numbers if n % 2 == 0]

print(evens_imperative == evens_declarative)  # True — same result, different style

Functional Tools in the Standard Library

Python's standard library provides solid functional-style building blocks without requiring a separate FP framework: map, filter, functools.reduce, functools.partial, functools.lru_cache, sorting with a key function, and the operator module for turning operators into callables. These are covered in depth in their own dedicated topics; this page focuses on the underlying paradigm they express.

from functools import reduce

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

total = reduce(lambda acc, n: acc + n, numbers, 0)
print(total)  # 15 — computed by composing an accumulation function, not a manual loop

Closures Capture Behavior, Not Just Data

A closure — a function that remembers variables from its enclosing scope — is a key functional building block for generating specialized functions on the fly, without a class.

def make_validator(min_length: int):
    def validate(text: str) -> bool:
        return len(text) >= min_length
    return validate

password_check = make_validator(8)
print(password_check("short"))     # False
print(password_check("longenough"))  # True

When Functional Style Fits (and When It Doesn't)

Functional style tends to shine for data transformation pipelines (filter, then map, then reduce), stateless utility logic, and anywhere immutability reduces bugs from shared mutable state. It tends to fit poorly for code that is naturally stateful (a game loop, a stream of I/O events) or where an explicit imperative loop is simply more readable than a deeply nested functional expression — Python's philosophy ("readability counts") favors whichever style reads more clearly for the situation at hand.

Practical Usage

Idiomatic Python typically uses functional techniques selectively: comprehensions for straightforward transformations, sorted(..., key=...) for custom ordering, small pure helper functions for testable business logic, and closures/decorators for reusable behavior — while still using classes, loops, and mutation freely where they are the clearer fit.

Key Takeaways

Python supports functional programming as one available style, not as an enforced paradigm — it freely mixes with imperative and object-oriented code.

First-class functions (assignable, passable, returnable) are the foundation that higher-order functions, closures, and decorators all build on.

Pure functions avoid side effects and depend only on their inputs, making them easier to test and reason about; mutating a mutable argument in place is a side effect even without touching globals.

Functional style favors building new values (comprehensions, +, new containers) over in-place mutation, even for Python's mutable types.

Declarative constructs (comprehensions, map/filter/reduce, key= functions) describe WHAT result is wanted; imperative loops describe HOW — choose whichever reads more clearly for the task.

def add_bonus(scores: list[int], bonus: int) -> None: for i in range(len(scores)): scores[i] += bonus # mutates the caller's list — hidden side effect def add_bonus(scores: list[int], bonus: int) -> list[int]: return [s + bonus for s in scores] # returns a new list, no side effect

Mutating an argument in place is a side effect, even though no global state is touched — it silently changes what the caller sees. A pure function should return a new value instead.

result = [x * 2 if x % 2 == 0 else x for x in data if x > 0] # a comprehension is often clearer than chained map/filter/lambda

Functional tools are a means to readable code, not an end in themselves — Python's comprehensions frequently express the same logic more clearly than nested map/filter/lambda chains.

count = 0 def increment(): global count count += 1 return count # relying on hidden global mutation makes this function's output depend on call history def make_counter(): count = 0 def increment(): nonlocal count count += 1 return count return increment counter = make_counter() # state is scoped, not global — explicit and contained

A function relying on module-level global state is impure and hard to test in isolation; scoping the mutable state inside a closure (or avoiding it entirely) keeps the effect contained and explicit.

Is Python a purely functional language? Explain.

No. Python is multi-paradigm — it supports functional-style programming (first-class functions, map/filter/reduce, comprehensions) as one available approach, but it does not enforce immutability or purity, and freely mixes with imperative and object-oriented code.

What does it mean for functions to be 'first-class' in Python?

Functions are ordinary objects: they can be assigned to variables, stored in data structures, passed as arguments to other functions, and returned as results — the same as any other value.

Define a pure function, and explain why a function that appends to a list argument in place is not pure.

A pure function's output depends only on its inputs and it produces no observable side effects. A function that appends to a list argument in place mutates state outside its own return value — the caller's list changes — which is a side effect, making it impure even without touching any global variable.

What is a higher-order function? Give an example pattern.

A function that takes another function as an argument, returns a function as a result, or both. Example: a function like apply_twice(fn, value) that takes fn as an argument, or a factory function like make_multiplier(factor) that returns a new function.

Why does functional style favor creating new containers over mutating existing ones, even for Python's mutable types like list?

Avoiding in-place mutation prevents aliasing bugs (unexpected changes visible through other references to the same object) and keeps functions pure/predictable — the tradeoff is some extra memory/copying versus easier reasoning and safer reuse.

What is the difference between declarative and imperative code, with a concrete example?

Imperative code describes step-by-step how to compute something (e.g., a for loop appending to a list); declarative code describes what result is wanted (e.g., a list comprehension or filter() call), leaving the how to the underlying implementation.

How does a closure enable functional-style code without using a class?

A closure is a function that remembers variables from its enclosing scope, letting you generate specialized, stateful-feeling functions (like make_multiplier(2) returning a doubling function) dynamically, without defining a full class with __call__.

Write a pure function discount_prices(prices, rate) that returns a NEW list with each price reduced by rate fraction, without mutating the input list. Demonstrate the input is unchanged after calling it.

def discount_prices(prices: list[float], rate: float) -> list[float]: return [p * (1 - rate) for p in prices] original = [100.0, 50.0, 20.0] discounted = discount_prices(original, 0.1) print(original) # [100.0, 50.0, 20.0] — unchanged print(discounted) # [90.0, 45.0, 18.0]

The original list remains [100.0, 50.0, 20.0] because discount_prices builds and returns a brand-new list via a comprehension rather than mutating the input — this is what makes it a pure function.

What does this print, and what functional concept does make_greeter demonstrate?

It prints 'Hello, Sam!' then 'Hola, Sam!'. make_greeter demonstrates closures and higher-order functions: it returns a new function that remembers its own 'greeting' value from the enclosing scope, so hello and hola behave independently despite sharing the same code.

Write a higher-order function compose(f, g) that returns a new function equivalent to f(g(x)), then use it to combine two simple functions.

def compose(f, g): def composed(x): return f(g(x)) return composed def double(x: int) -> int: return x * 2 def increment(x: int) -> int: return x + 1 double_then_increment = compose(increment, double) print(double_then_increment(5)) # increment(double(5)) = increment(10) = 11

11 — compose(increment, double) returns a function that first applies double, then increment, matching the mathematical composition f(g(x)) where f=increment and g=double.

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

hello = make_greeter("Hello")
hola = make_greeter("Hola")
print(hello("Sam"))
print(hola("Sam"))