map(), filter(), and reduce() in Python

python map filter reduce cover three distinct jobs that come up constantly when processing data: transforming every item, selecting only some of them, and boiling a whole collection down to a single value. This article covers all three in depth, including where they still earn their place next to (or in place of) list comprehensions.

Introduction: Functional-Style Data Processing in Python

map(), filter(), and reduce() all apply an operation across an entire iterable at once, rather than requiring you to write an explicit loop yourself. They come from a functional programming tradition — Python isn't a purely functional language, but it borrows these tools from that style, and they're genuinely useful in the right situations.

Origins worth knowing

map() and filter() are Python built-ins — always available, no import required. reduce(), by contrast, was moved out of Python's builtins and into the functools module in Python 3, meaning it requires an explicit import:

from functools import reduce

This move was deliberate — Guido van Rossum has been fairly open that he considers reduce() less readable than the alternatives for most cases, and demoting it out of the builtins was a small, intentional nudge toward using it more sparingly. More on that in Section 5.

Three distinct jobs

  • map() — transforming every element.

  • filter() — selecting only some elements.

  • reduce() — aggregating everything down to a single value.

map(): Transforming Every Element

Basic syntax and example
numbers = [1, 2, 3, 4, 5]
squared = map(lambda x: x ** 2, numbers)
print(list(squared))   # [1, 4, 9, 16, 25]

map() applies the given function to every item in the iterable, one at a time, producing a corresponding transformed value for each.

prices = [19.999, 34.501, 8.25]
rounded = map(lambda p: round(p, 2), prices)
print(list(rounded))   # [20.0, 34.5, 8.25]
Important: map() returns a lazy iterator

In Python 3, map() doesn't return a list directly — it returns a lazy iterator, computing each result only as it's actually requested:

result = map(lambda x: x ** 2, [1, 2, 3])
print(result)         # <map object at 0x...> — not a list yet
print(list(result))   # [1, 4, 9] — now materialized as a list

This is why every example above wraps map() in list() — without it, you'd just be looking at the iterator object itself, not its contents. The laziness is intentional and often efficient (results are computed on demand rather than all up front), but it does mean you need to explicitly convert to a list, or otherwise consume the iterator, to actually see or reuse the results.

Bonus: map() with multiple iterables

map() can accept more than one iterable at once, as long as the function you pass it accepts a matching number of arguments — one from each iterable, paired up positionally:

prices = [10, 20, 30]
quantities = [2, 3, 1]

totals = map(lambda price, qty: price * qty, prices, quantities)
print(list(totals))   # [20, 60, 30]

Here, map() pulls one item from prices and one from quantities on each step, passing both into the lambda together. If the iterables are different lengths, map() stops as soon as the shortest one is exhausted, rather than raising an error.

filter(): Selecting Matching Elements

Basic syntax and example
numbers = [1, 2, 3, 4, 5, 6, 7, 8]
evens = filter(lambda x: x % 2 == 0, numbers)
print(list(evens))   # [2, 4, 6, 8]
names = ["Al", "Alexander", "Sam", "Bartholomew"]
short_names = filter(lambda name: len(name) <= 3, names)
print(list(short_names))   # ['Al', 'Sam']
The function must return truthy or falsy

Whatever function you pass to filter() needs to return something Python can evaluate as truthy or falsy (as covered in the earlier booleans article) — items where the function returns something truthy get kept; everything else is dropped.

words = ["", "hello", "", "world", ""]
n filter(None, words)   # a special case: None as the function means "keep truthy items"
print(list(non_empty))   # ['hello', 'world']

That last example is a handy shortcut worth knowing: passing None as filter()'s first argument (instead of an actual function) tells it to simply keep whichever items are already truthy on their own — useful for quickly stripping out empty strings, None values, zeros, and other falsy values from a list in one call.

A practical real-world example

Filtering a list of dictionaries by some field is a genuinely common real-world pattern:

users = [
    {"name": "Alex", "active": True},
    {"name": "Sam", "active": False},
    {"name": "Jordan", "active": True},
]

active_users = filter(lambda user: user["active"], users)
print([user["name"] for user in active_users])   # ['Alex', 'Jordan']
products = [
    {"name": "Widget", "stock": 5},
    {"name": "Gadget", "stock": 0},
    {"name": "Gizmo", "stock": 12},
]

in_stock = filter(lambda p: p["stock"] > 0, products)
print([p["name"] for p in in_stock])   # ['Widget', 'Gizmo']

reduce(): Aggregating to a Single Value

Importing and basic syntax
from functools import reduce

numbers = [1, 2, 3, 4, 5]
total = reduce(lambda acc, x: acc + x, numbers)
print(total)   # 15
How it accumulates, step by step

reduce() applies the given function cumulatively, carrying an accumulated result forward across each pair of elements:

reduce(lambda acc, x: acc + x, [1, 2, 3, 4, 5])

Step 1: acc=1, x=2  → 1 + 2 = 3
Step 2: acc=3, x=3  → 3 + 3 = 6
Step 3: acc=6, x=4  → 6 + 4 = 10
Step 4: acc=10, x=5 → 10 + 5 = 15

Final result: 15

Each step takes the running accumulated value (acc) and the next item (x), combines them, and carries that combined result forward into the next step.

The optional initializer argument

reduce() accepts an optional third argument — a starting value for the accumulator, used before the first real element is processed:

numbers = [1, 2, 3, 4, 5]
total = reduce(lambda acc, x: acc + x, numbers, 100)
print(total)   # 115 — starts accumulating from 100 instead of the list's first item

This initializer is also genuinely important for safely handling empty iterables. Without one, calling reduce() on an empty list raises an error, since there's no first element to use as a starting point:

reduce(lambda acc, x: acc + x, [])
# TypeError: reduce() of empty iterable with no initial value

result = reduce(lambda acc, x: acc + x, [], 0)
print(result)   # 0 — safely handled, since an explicit starting value was provided
Practical examples

Summing (though sum() alone would be simpler here — this is purely illustrative):

numbers = [1, 2, 3, 4, 5]
total = reduce(lambda acc, x: acc + x, numbers)

Finding a maximum:

numbers = [4, 9, 2, 7, 5]
maximum = reduce(lambda acc, x: x if x > acc else acc, numbers)
print(maximum)   # 9

Concatenating strings:

words = ["Python", "is", "fun"]
sentence = reduce(lambda acc, word: acc + " " + word, words)
print(sentence)   # Python is fun

Building a dictionary from pairs:

pairs = [("a", 1), ("b", 2), ("c", 3)]
result = reduce(lambda acc, pair: {**acc, pair[0]: pair[1]}, pairs, {})
print(result)   # {'a': 1, 'b': 2, 'c': 3}

Chaining Them Together, and When to Use List Comprehensions Instead

A combined real-world pipeline

Here's an example chaining filter(), map(), and reduce() together — a realistic pipeline calculating total revenue from a list of orders, filtered down to only completed ones, with each order's revenue extracted before summing:

from functools import reduce

orders = [
    {"status": "completed", "total": 49.99},
    {"status": "cancelled", "total": 19.99},
    {"status": "completed", "total": 89.50},
    {"status": "completed", "total": 12.00},
]

completed = filter(lambda order: order["status"] == "completed", orders)
totals = map(lambda order: order["total"], completed)
revenue = reduce(lambda acc, total: acc + total, totals, 0)

print(revenue)   # 151.49

Each stage handles exactly one job: filter() selects the relevant orders, map() extracts just the field needed, and reduce() aggregates everything down to the final number.

An honest comparison with list comprehensions

Here's the same logic rewritten as a list comprehension combined with the built-in sum():

completed_totals = [order["total"] for order in orders if order["status"] == "completed"]
revenue = sum(completed_totals)
print(revenue)   # 151.49

For this specific case — filtering plus transforming plus summing — the comprehension version is arguably more readable, and it's genuinely the more common, more idiomatic choice among Python developers for exactly this kind of combined filter-and-transform logic.

So where do map() and filter() still genuinely earn their place? A few situations:

  • Working with an existing named function, rather than a throwaway lambda — map(str.upper, words) reads cleanly without needing a wrapping lambda at all, where a comprehension would need [str.upper(w) for w in words] (only marginally different, but map() occasionally reads more directly when the function already exists and needs no adaptation).

  • Genuine laziness matters — if you're working with a huge or infinite iterable and only need to process it incrementally, map()'s lazy iterator behavior can be a real, meaningful advantage.

  • Custom combining logic in reduce() that goes beyond what sum(), max(), or min() already provide directly — the dictionary-building example above is a reasonable case where reduce() does something a simple built-in can't.

Quick guidance: use reduce() sparingly

As a practical rule: reach for reduce() only when Python's built-ins genuinely don't already cover what you need. sum(), max(), min(), and any()/all() handle the overwhelming majority of common aggregation needs directly, more readably, and without an import. Save reduce() for situations with genuinely custom accumulation logic — building up a dictionary, applying a sequence of transformations, or combining values in a way none of the built-ins directly express.

# Unnecessary reduce() — sum() already does exactly this, more clearly
total = reduce(lambda acc, x: acc + x, numbers)

# Preferred
total = sum(numbers)

PREVIOUSNEXT LESSON