map, filter and reduce in Python

What are map, filter, reduce

map, filter and reduce are three tools for processing a list without writing full loops. map changes every item, filter keeps only some items, and reduce boils the whole list down to one value. They come from functional programming and make list work compact.

map — transform every item

nums = [1, 2, 3, 4]
doubled = map(lambda x: x * 2, nums)
print(list(doubled))

map applies a function to every item and returns a new sequence. We wrap it in list() to see the values, because map returns a lazy iterator.

filter — select items

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

filter keeps only the items for which the function returns True. Here it keeps even numbers. It can return fewer items than the original.

reduce — combine into one

from functools import reduce
nums = [1, 2, 3, 4]
total = reduce(lambda a, b: a + b, nums)
print(total)

reduce takes two items at a time and combines them, then combines the result with the next, and so on — folding the whole list into one value. Note it must be imported from functools.

Using lambda

A lambda is a tiny unnamed function, perfect to pass into these tools.

square = lambda x: x * x
print(square(5))          # 25
# same idea used inline:
print(list(map(lambda x: x * x, [1, 2, 3])))

lambda x: x * x is a one-line function. You can name it or drop it straight into map/filter/reduce.

map/filter vs comprehension

Often a list comprehension does the same job more readably.

# map:
list(map(lambda x: x * 2, nums))
# comprehension (clearer):
[x * 2 for x in nums]

For simple transforms and filters, a comprehension is usually the Pythonic choice. Use map/filter when you already have a named function to apply.

Common mistakes

• Forgetting list(). map and filter return iterators — wrap them to see values.
• Not importing reduce. It comes from functools, unlike map and filter.
• Overusing lambda. For anything complex, a named def function is clearer.
• Reusing an iterator. A map/filter result is consumed once; convert to a list to reuse.

Summary

• map transforms every item into a new sequence.
• filter keeps only items that pass a test.
• reduce (from functools) combines all items into one value.
• lambda gives a quick one-line function to pass in.
• For simple cases, a list comprehension is often clearer.

Next, compare with list comprehension, or organise data with list, tuple, set and dict.