Functional programming

Functional programming is a declarative paradigm that treats computation as the evaluation of mathematical functions — emphasizing immutability, pure functions, higher-order functions, first-class functions, recursion, and avoidance of side effects and mutable state. In 2026, functional programming principles are deeply embedded in Python’s ecosystem, powering scalable data processing (Dask, Polars), concurrent and async code (asyncio, trio, anyio), clean APIs (FastAPI with Pydantic), and modern ML pipelines (JAX, PyTorch functional API) — making code more predictable, testable, composable, and parallel-friendly compared to imperative styles.

Here’s a complete, practical guide to functional programming in Python: core concepts, pure functions & immutability, higher-order functions, real-world patterns (earthquake data pipelines, log processing), and modern best practices with type hints, functools, toolz/fn, Dask/Polars integration, and 2026 ecosystem trends (Polars lazy API, JAX functional transforms, uv/Ruff for clean FP code).

Core functional concepts in Python — what makes code "functional".

Pure functions — same input ? same output, no side effects (no print, no mutation, no I/O).
Immutability — prefer new objects over modifying existing ones (tuples, frozensets, frozen dataclasses).
First-class & higher-order functions — functions as values: pass, return, store in variables/lists/dicts.
Recursion & iteration — prefer recursion or comprehensions over loops when possible.
Declarative style — describe what to compute (map/filter/reduce) rather than how (imperative loops).
Composition — chain small functions to build complex behavior.

Pure functions & immutability — avoid side effects, make code predictable.


# Impure: mutates input, has side effect
def add_to_list(lst, item):
    lst.append(item)  # mutation
    print("Added!")   # side effect
    return lst

# Pure: returns new list, no side effects
def add_to_list_pure(lst, item):
    return lst + [item]  # new list

# Immutability with frozen dataclasses
from dataclasses import dataclass
from typing import FrozenSet

@dataclass(frozen=True)
class Event:
    id: int
    mag: float
    place: str

# Can't modify after creation
event = Event(1, 7.2, "Japan")
# event.mag = 7.5  # FrozenInstanceError

Higher-order functions & composition — pass/return functions, build pipelines.


from functools import partial, reduce
from operator import add, mul

# Higher-order: takes function as arg
def apply_twice(func, x):
    return func(func(x))

square = lambda x: x ** 2
print(apply_twice(square, 3))  # 81

# Composition with reduce
add_all = reduce(add, [1, 2, 3, 4])     # 10
product = reduce(mul, [1, 2, 3, 4])     # 24

# Partial application
double = partial(mul, 2)
print(double(5))  # 10

# Pipeline composition
def add_one(x): return x + 1
def square(x): return x ** 2
def negate(x): return -x

pipeline = lambda x: negate(square(add_one(x)))
print(pipeline(3))  # -16

Real-world pattern: functional pipeline for earthquake data — clean, filter, aggregate using map/filter/reduce.


import dask.bag as db
import json

bag = db.read_text('quakes/*.jsonl').map(json.loads)

# Functional pipeline
strong_shallow = (
    bag
    .filter(lambda e: e.get('mag', 0) >= 7.0)
    .filter(lambda e: e.get('depth', 1000) <= 70)
    .map(lambda e: {
        'year': pd.to_datetime(e['time']).year,
        'country': e['place'].split(',')[-1].strip() if ',' in e['place'] else 'Unknown',
        'mag': e['mag']
    })
)

# Aggregate: count per country using reduce-like groupby
from collections import defaultdict

def count_per_country(acc: dict, event: dict):
    country = event['country']
    acc[country] = acc.get(country, 0) + 1
    return acc

country_counts = strong_shallow.fold(count_per_country, initial=defaultdict(int)).compute()
top_countries = sorted(country_counts.items(), key=lambda x: x[1], reverse=True)[:10]

print("Top 10 countries by strong shallow events:")
for country, count in top_countries:
    print(f"{country}: {count}")

Best practices for functional programming in Python 2026. Write pure functions — no side effects, deterministic. Modern tip: use Polars lazy API — pl.scan_csv(...).filter(...).group_by(...) — functional & fast; Dask Bags for unstructured. Prefer immutability — tuples, frozensets, frozen dataclasses. Use functools.partial — for currying. Compose with reduce — for cumulative ops. Use lambda sparingly — prefer named functions for clarity. Add type hints — def square(x: int) -> int. Use toolz/fn.py — functional utilities (compose, curry). Use recursion judiciously — Python has recursion limit; prefer iteration/comprehensions. Use list/dict comprehensions — concise functional style. Test pure functions — easy to test without mocks. Use hypothesis — property-based testing for pure funcs. Use Ruff — lint functional code. Use mypy — strict typing for FP. Use uv — fast dependency management. Use mkdocs — document FP pipelines. Profile — scalene for pure vs impure code.

Functional programming in Python emphasizes pure functions, immutability, higher-order functions, and composition — powering clean, testable, parallel pipelines in Dask, Polars, and beyond. In 2026, use Polars lazy API for columnar FP, Dask Bags for unstructured, persist intermediates, and monitor dashboard. Master functional approaches, and you’ll write predictable, scalable, maintainable code for data science and engineering.

Next time you process data — think functionally. It’s Python’s cleanest way to say: “Transform data with pure, composable functions — easy to reason about, test, and scale.”

Generating content...