Functional Programming Style in Python: map and filter

Functional programming is a style where you describe what you want rather than spelling out every step of how to get it. Python isn’t a purely functional language, but it borrows the best functional ideas — and knowing when to apply them makes your code shorter, more readable, and far easier to test.

Functional vs Imperative Style

The difference becomes clear with a simple example — doubling a list of numbers:

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

# Imperative: you manage state, initialise an empty list, and drive the loop
doubled = []
for n in numbers:
    doubled.append(n * 2)

# Functional / declarative: you describe the transformation
doubled = list(map(lambda n: n * 2, numbers))

# Pythonic equivalent — a comprehension that reads like English
doubled = [n * 2 for n in numbers]

The functional version has no loop, no temporary state, and no mutation — just a transformation applied to data.

Pure Functions

A pure function always returns the same output for the same input and produces no side effects (no writes to disk, no network calls, no changes to global state). Pure functions are trivial to test and safe to cache.

# Pure — depends only on its arguments
def total_price(price: float, quantity: int) -> float:
    return price * quantity

# Impure — reads from global state, result can vary
discount_rate = 0.1

def discounted_price(price: float) -> float:
    return price * (1 - discount_rate)   # depends on external variable

Aim to write as many pure functions as possible. Push side effects (database writes, API calls, file I/O) to the edges of your program, keeping the core logic pure and testable.

`map()` — Transform Every Element

map(function, iterable) applies a function to every element of an iterable and returns a lazy iterator.

prices = [100.0, 250.0, 500.0]

# Apply 18% GST to every price
prices_with_gst = list(map(lambda p: p * 1.18, prices))
print(prices_with_gst)  # [118.0, 295.0, 590.0]

# Named function for complex logic
def classify_score(marks: int) -> str:
    if marks >= 90:
        return "A"
    elif marks >= 75:
        return "B"
    elif marks >= 50:
        return "C"
    return "F"

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

`filter()` — Keep Only Matching Elements

filter(function, iterable) returns a lazy iterator containing only elements for which the function returns True.

products = [
    {"name": "Laptop",   "price": 999, "in_stock": True},
    {"name": "Mouse",    "price": 29,  "in_stock": False},
    {"name": "Keyboard", "price": 79,  "in_stock": True},
    {"name": "Monitor",  "price": 399, "in_stock": False},
]

# Keep only in-stock products
available = list(filter(lambda p: p["in_stock"], products))
print([p["name"] for p in available])   # ['Laptop', 'Keyboard']

# Keep products under $100
budget = list(filter(lambda p: p["price"] < 100, products))
print([p["name"] for p in budget])      # ['Mouse', 'Keyboard']

`reduce()` — Collapse a Collection to a Single Value

reduce(function, iterable) from functools applies a two-argument function cumulatively, reducing the sequence to a single result.

from functools import reduce

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

# Sum: ((((1+2)+3)+4)+5) = 15
total = reduce(lambda x, y: x + y, numbers)
print(total)   # 15

# Product: ((((1*2)*3)*4)*5) = 120
product = reduce(lambda x, y: x * y, numbers)
print(product) # 120

# Find the most expensive product
most_expensive = reduce(
    lambda a, b: a if a["price"] > b["price"] else b,
    products
)
print(most_expensive["name"])  # Laptop

reduce() is powerful but can hurt readability when overused. For simple totals and products, Python’s built-in sum(), max(), and min() are clearer. Reserve reduce() for custom accumulation logic that has no built-in equivalent.

`functools.partial` — Partial Application

functools.partial lets you pre-fill some arguments of a function, creating a new specialised version of it.

from functools import partial

def apply_discount(price: float, rate: float) -> float:
    return price * (1 - rate)

# Create specialised discount functions
ten_percent_off = partial(apply_discount, rate=0.10)
half_price      = partial(apply_discount, rate=0.50)

print(ten_percent_off(200))   # 180.0
print(half_price(200))        # 100.0

# Useful with map — apply a fixed discount to every price
prices = [100, 250, 500]
sale_prices = list(map(ten_percent_off, prices))
print(sale_prices)   # [90.0, 225.0, 450.0]

Chaining Operations

You can chain map, filter, and other functional tools into a readable pipeline. For Python, combining comprehensions with sum/max/min is often the most readable approach.

from functools import reduce

inventory = [
    {"name": "Laptop",   "price": 999, "in_stock": True,  "qty": 5},
    {"name": "Mouse",    "price": 29,  "in_stock": False, "qty": 0},
    {"name": "Keyboard", "price": 79,  "in_stock": True,  "qty": 12},
    {"name": "Monitor",  "price": 399, "in_stock": True,  "qty": 3},
]

# Pipeline: filter in-stock → extract price × qty → sum
total_value = sum(
    p["price"] * p["qty"]
    for p in inventory
    if p["in_stock"]
)
print(f"Total stock value: ${total_value:,.2f}")   # $6,850.00

# Using map + filter explicitly (equivalent)
in_stock   = filter(lambda p: p["in_stock"], inventory)
values     = map(lambda p: p["price"] * p["qty"], in_stock)
total_alt  = reduce(lambda a, b: a + b, values)
print(f"Total stock value: ${total_alt:,.2f}")     # $6,850.00

When to Use Functional Style vs Comprehensions

Prefer map/filter when…

You already have a named function (avoids creating a redundant lambda): list(map(str.upper, words))
You are composing a pipeline with partial or passing operations as arguments
You want lazy evaluation and will not materialise the full list

Prefer comprehensions when…

You are writing a one-off transformation inline — comprehensions are more readable to most Python developers
You need both filtering and transformation in one step
The result needs to be a list, dict, or set specifically

# Comprehension is cleaner here
upper_words = [w.upper() for w in words if w]

# map equivalent — less readable
upper_words = list(map(str.upper, filter(None, words)))

Immutability in Practice

Functional programming favours immutable data — data that is never modified in-place. Python gives you several tools for this:

from typing import NamedTuple

# NamedTuple — immutable record
class Product(NamedTuple):
    name: str
    price: float

p = Product("Laptop", 999.0)

# "Update" by creating a new instance — original unchanged
cheaper = p._replace(price=899.0)
print(p.price)       # 999.0
print(cheaper.price) # 899.0

# Frozen dict (Python 3.9+) — via types.MappingProxyType
from types import MappingProxyType

config = MappingProxyType({"debug": False, "version": "1.0"})
# config["debug"] = True   # raises TypeError

You don’t have to go fully immutable. A practical rule: treat function arguments as read-only, return new values rather than mutating inputs, and limit mutation to clearly defined “update” operations.

Core Python

Advanced Python

Pydantic

Functional Programming Style in Python: map and filter

Functional vs Imperative Style

Pure Functions

`map()` — Transform Every Element

`filter()` — Keep Only Matching Elements

`reduce()` — Collapse a Collection to a Single Value

`functools.partial` — Partial Application

Chaining Operations

When to Use Functional Style vs Comprehensions

Immutability in Practice

​Functional vs Imperative Style

​Pure Functions

​map() — Transform Every Element

​filter() — Keep Only Matching Elements

​reduce() — Collapse a Collection to a Single Value

​functools.partial — Partial Application

​Chaining Operations

​When to Use Functional Style vs Comprehensions

​Immutability in Practice

Functional vs Imperative Style

Pure Functions

`map()` — Transform Every Element

`filter()` — Keep Only Matching Elements

`reduce()` — Collapse a Collection to a Single Value

`functools.partial` — Partial Application

Chaining Operations

When to Use Functional Style vs Comprehensions

Immutability in Practice