map(), filter(), reduce()

Functional programming Trio

These three functions are the classic trio of functional programming, they are the building blocks for processing collections of data without loops. They each take a function and an iterable (a list, for example) and apply that function to the data in a specific way:

• map: transform every element
• filter: select only elements that meet a condition
• reduce: collapse all elements into a single value

The idea is to describe what you want done to the data, and let the function handle the iteration for you. This is the declarative spirit of functional programming. All three originate from functional languages like Lisp and Haskell, and have since been adopted widely across modern languages.

In Python, map() and filter() are built-in, while reduce() lives in the functools module. All three return lazy iterators in Python 3, meaning they don’t compute results until needed, which is memory efficient.

Immediate evaluation

Wrapping them in list() forces immediate evaluation.

Lazy vs. immediate

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

# map() returns a lazy iterator — nothing is computed yet
lazy_result = map(lambda x: x ** 2, nums)
print(lazy_result)          # <map object at 0x10f3a2d30>  ← not the values!

# Wrapping in list() forces it to evaluate immediately
eager_result = list(map(lambda x: x ** 2, nums))
print(eager_result)         # [1, 4, 9, 16, 25]  ← actual values

The lazy iterator is like a set of instructions that sits and waits: it knows how to compute the squares, but hasn’t done it yet. Only when you consume it (via list(), a for loop, or similar) does it actually run.

Force evaluation

# Other ways to force evaluation
nums = [1, 2, 3, 4, 5]
lazy = map(lambda x: x ** 2, nums)

# Via a for loop
for val in lazy:
    print(val)              # 1, 4, 9, 16, 25 — computed one at a time

# Via next() — one value at a time
lazy = map(lambda x: x ** 2, nums)
print(next(lazy))           # 1
print(next(lazy))           # 4
print(next(lazy))           # 9

The practical benefit is memory efficiency: if you have a million items, a lazy iterator doesn’t load them all at once. It produces each value only when asked.

Wrapping in list() is convenient but trades that efficiency for immediate access to all values.

Watch out

The for loop does begin forcing evaluation from the start, and it could stop early because you have put a break. It’s not a clean demonstration of laziness because you’re relying on break to stop it, if you forgot the break, it would evaluate all 1,000,000 values.

Whereas with next() and filter(), the laziness is structural, there is no loop that could accidentally run away. You explicitly pull one value at a time, and nothing else is ever evaluated unless you ask for it.

Under the hood: realistic scenarios

Need 5 out of a million

# Simulating a very large dataset
def million_numbers():
    for i in range(1_000_000):
        yield i

# ❌ list() — loads ALL 1,000,000 squares into memory at once
eager = list(map(lambda x: x ** 2, million_numbers()))     # 1M values sitting in RAM

# ✅ lazy — computes one value at a time, only when needed
lazy = map(lambda x: x ** 2, million_numbers())

# next() pulls exactly one value at a time — the remaining 999,995 are never touched
print(next(lazy))   # 0
print(next(lazy))   # 1
print(next(lazy))   # 4
print(next(lazy))   # 9
print(next(lazy))   # 16

Each next() call evaluates exactly one item on demand. The iterator simply sits and waits between calls. This is the purest demonstration of lazy evaluation: compute only what you explicitly ask for, nothing more.

Searching a large log file

def read_logs():
    for i in range(1_000_000):
        print(f"  generating line {i}...")          # shows exactly what gets evaluated
        yield f"LOG {i}: user_action=click, status={'error' if i == 357 else 'ok'}"

logs = read_logs()
errors = filter(lambda log: "error" in log, logs)

first_error = next(errors)
print(first_error)

# Output:
#   generating line 0...
#   generating line 1...
#   generating line 2...
#   ... (every line up to 357 is checked by filter)
#   generating line 357...
# LOG 357: user_action=click, status=error
# ← stops here, lines 358–999,999 never generated

The only nuance worth noting is that lines 0–356 are evaluated, the filter has to check each one and reject it before reaching 357. So it’s not that only one line is processed, but rather that the pipeline stops as early as possible the moment the condition is met.

The key insight is:

	list(map(...))	lazy map(...)
Memory used	All N items at once	One item at a time
Computation	Everything upfront	Only what is consumed
Best when	You need all results	You may stop early

Laziness is most valuable when your data is large and you only need part of it: why compute a million squares if you only needed the first five?

map(func, iterable) — Transform Every Element

map() takes a function and an iterable, and applies the function to every element in the iterable. It doesn’t modify the original, it returns a new lazy iterator with the transformed values.

Think of it as an assembly line: each item passes through the same operation and comes out the other side changed. Each element passes through the same function, one at a time, independently of the others, exactly like items on an assembly line going through the same machine.

The assembly line

  map(lambda x: x ** 2, [1, 2, 3, 4, 5])

  Input                Function              Output
  ─────                ────────              ──────

  [ 1 ] ──────────── (x => x ** 2) ──────── [ 1  ]
  [ 2 ] ──────────── (x => x ** 2) ──────── [ 4  ]
  [ 3 ] ──────────── (x => x ** 2) ──────── [ 9  ]
  [ 4 ] ──────────── (x => x ** 2) ──────── [ 16 ]
  [ 5 ] ──────────── (x => x ** 2) ──────── [ 25 ]

  [1, 2, 3, 4, 5]                           [1, 4, 9, 16, 25]
  original unchanged                         new iterator

Here the Python code:

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

# map(func, iterable) — transform every element
squared = list(map(lambda x: x ** 2, nums))
strings = list(map(str, nums))              # built-in functions work too

print(squared)      # [1, 4, 9, 16, 25]
print(strings)      # ['1', '2', '3', '4', '5']

Lazy iterator

It returns neither a list nor an array: it returns a map object, which is a lazy iterator. You can verify this directly:

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

result = map(lambda x: x ** 2, nums)
print(result)           # <map object at 0x10f3a2d30>  ← not a list!
print(type(result))     # <class 'map'>

You only get a list if you explicitly ask for one by wrapping it in list():

result = list(map(lambda x: x ** 2, nums))
print(result)           # [1, 4, 9, 16, 25]  ← now it's a list
print(type(result))     # <class 'list'>

This is a Python 3 behaviour worth knowing. In Python 2, map() did return a list directly, but Python 3 changed it to return a lazy iterator for memory efficiency, as we covered earlier. So the wrapping in list() is not just a convention, it’s a necessary step if you actually want a list back.

Exhaustability lazy iterators

Exhaustability is a fundamental property of all lazy iterators. It follows directly from how they work: they don’t store values, they produce them one at a time and move forward. There is no memory of what came before, so there is no way to go back.

This is the full picture of lazy iterators:

Property	Description
Lazy	values are computed on demand, not upfront
One-time	can only be consumed once, then exhausted
No indexing	you cannot do lazy[0] — no random access
No length	you cannot do len(lazy) — size is unknown
Forward only	you cannot rewind or reset

lazy = map(lambda x: x ** 2, [1, 2, 3])

print(lazy[0])      # ❌ TypeError: 'map' object is not subscriptable
print(len(lazy))    # ❌ TypeError: object of type 'map' has no len()

This is the fundamental trade-off of laziness:

        Lists                       Lazy Iterators
        ─────                       ──────────────
✅ reusable                         ❌ one-time only
✅ indexable                        ❌ forward only
✅ has length                       ❌ no length
❌ all in memory                    ✅ one value at a time
❌ computed upfront                 ✅ computed on demand

So when you need to reuse, index, or measure convert to a list. When you need memory efficiency and early exit keep it lazy.

filter(func, iterable) — Select Matching Elements

filter() takes a function and an iterable, and tests every element against the function. Only elements where the function returns True pass through, the rest are discarded.

Unlike map() which transforms every element, filter() makes a yes/no decision on each one, acting like a gatekeeper that only lets certain items through.

Think of it as: “keep only the items that pass this test.”

  filter(lambda x: x % 2 == 0, [1, 2, 3, 4, 5, 6])

  Input        Test (x % 2 == 0)      Output
  ─────        ─────────────────      ──────

  [ 1 ] ───────── False ───────────── ✗ discarded
  [ 2 ] ───────── True  ───────────── [ 2 ] ──┐
  [ 3 ] ───────── False ───────────── ✗ discarded
  [ 4 ] ───────── True  ───────────── [ 4 ] ──┤
  [ 5 ] ───────── False ───────────── ✗ discarded
  [ 6 ] ───────── True  ───────────── [ 6 ] ──┤
                                              │
  [1, 2, 3, 4, 5, 6]                    [2, 4, 6]
  original unchanged                    new iterator

Each element faces the same test, it either passes and is kept, or fails and is dropped. The order of the surviving elements is always preserved.

Here the Python code:

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

# filter(func, iterable) — keep only elements where func returns True
evens    = list(filter(lambda x: x % 2 == 0, nums))
above_3  = list(filter(lambda x: x > 3, nums))

print(evens)        # [2, 4, 6]
print(above_3)      # [4, 5, 6]

reduce(func, iterable) — Collapse to a Single Value

reduce() takes a function and an iterable, and folds all elements into a single result by repeatedly applying the function to pairs of values. It carries an accumulator, a running result that gets updated with each element until the list is exhausted.

Unlike map() and filter() which preserve the shape of the collection, reduce() collapses it entirely, like a snowball rolling down a hill, growing with each step until there is nothing left to consume.

Think of it as: “fold all items together into one result.”

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

  Step     Accumulator      Next Element        Result
  ────     ───────────      ────────────        ──────

   1          [ 1 ]    +        [ 2 ]     =     [ 3 ]
   2          [ 3 ]    +        [ 3 ]     =     [ 6 ]
   3          [ 6 ]    +        [ 4 ]     =     [ 10 ]
   4          [ 10 ]   +        [ 5 ]     =     [ 15 ]
                                                  │
                                                  ▼
                                            single value
                                               [ 15 ]

The first element always seeds the accumulator, reduce() then walks through the remaining elements one by one, combining each with the running total until only one value remains.

Note

Repeatedly applies a function to pairs of elements, accumulating a single final result. Unlike map and filter, it doesn’t return a collection, it returns one value.

from functools import reduce

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

# reduce(func, iterable) — accumulate into a single value
total   = reduce(lambda acc, x: acc + x, nums)   # sum
product = reduce(lambda acc, x: acc * x, nums)   # product

print(total)        # 15
print(product)      # 120

The accumulation happens step by step:

[1, 2, 3, 4, 5]
 1+2 → 3
     3+3 → 6
         6+4 → 10
              10+5 → 15

The Trio Together

They compose naturally, you can chain them to build expressive data pipelines:

from functools import reduce

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

# Sum of squares of even numbers
result = reduce(
    lambda acc, x: acc + x,
    map(lambda x: x ** 2,
        filter(lambda x: x % 2 == 0, nums))
)

print(result)       # 220  (4 + 16 + 36 + 64 + 100)

Step by step explanation

  Input: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

  ═══════════════════════════════════════════════════
  STEP 1 — filter(lambda x: x % 2 == 0, nums)
  ═══════════════════════════════════════════════════

  [ 1 ] ── False ── ✗
  [ 2 ] ── True  ── [ 2 ] ───┐
  [ 3 ] ── False ── ✗        │
  [ 4 ] ── True  ── [ 4 ] ───┤
  [ 5 ] ── False ── ✗        │
  [ 6 ] ── True  ── [ 6 ] ───┤
  [ 7 ] ── False ── ✗        │
  [ 8 ] ── True  ── [ 8 ] ───┤
  [ 9 ] ── False ── ✗        │
  [ 10 ] ── True ── [ 10 ] ──┤
                             │
                      [2, 4, 6, 8, 10]
                             │
                             ▼
  ═══════════════════════════════════════════════════
  STEP 2 — map(lambda x: x ** 2, ...)
  ═══════════════════════════════════════════════════

  [ 2  ] ── (x ** 2) ── [ 4   ] ───┐
  [ 4  ] ── (x ** 2) ── [ 16  ] ───┤
  [ 6  ] ── (x ** 2) ── [ 36  ] ───┤
  [ 8  ] ── (x ** 2) ── [ 64  ] ───┤
  [ 10 ] ── (x ** 2) ── [ 100 ] ───┤
                                   │
                          [4, 16, 36, 64, 100]
                                   │
                                   ▼
  ═══════════════════════════════════════════════════
  STEP 3 — reduce(lambda acc, x: acc + x, ...)
  ═══════════════════════════════════════════════════

  Step    Accumulator      Next         Result
  ────    ───────────      ────         ──────
   1         [ 4 ]    +   [ 16  ]  =   [ 20  ]
   2         [ 20 ]   +   [ 36  ]  =   [ 56  ]
   3         [ 56 ]   +   [ 64  ]  =   [ 120 ]
   4         [ 120 ]  +   [ 100 ]  =   [ 220 ]
                                          │
                                          ▼
                                    single value
                                       [ 220 ]

The three steps form a pipeline, each step feeds directly into the next, and no intermediate list is ever fully materialised in memory. Data flows through filter → map → reduce lazily, one element at a time.