Map, Filter and Reduce in Python
SkillVeris Team
Engineering Team
map, filter, and reduce are functional tools: map transforms every item, filter selects items, and reduce combines items into one value.
In this guide, you'll learn:
- map(func, iterable) applies a function to each element and returns a lazy iterator you wrap in list() to see.
- filter(func, iterable) keeps only the elements for which the function returns True.
- reduce(func, iterable) lives in functools and folds a sequence into a single accumulated result.
- map and filter return lazy iterators, saving memory on large data by producing values on demand.
1Map, Filter and Reduce in Python
map, filter, and reduce are three functional-programming tools for processing sequences in Python. Each takes a function and applies it across an iterable: map transforms every item, filter keeps only items that pass a test, and reduce combines all items into a single value. Together they cover transform, select, and aggregate.
map and filter are built in and ready to use; reduce lives in the functools module and must be imported. All three encourage a declarative style where you describe what to do to each element rather than writing the loop mechanics yourself.
- from functools import reduce
- nums = [1, 2, 3, 4]
- list(map(lambda x: x * 2, nums)) # [2, 4, 6, 8]
- list(filter(lambda x: x % 2 == 0, nums)) # [2, 4]
- reduce(lambda a, b: a + b, nums) # 10
2map: Transform Every Item
map(function, iterable) applies the function to each element and returns a map object — a lazy iterator that produces values only as you consume them. Wrap it in list() to materialize the results. map can also take several iterables, applying the function across them in parallel.
- names = ['ava', 'raj']
- list(map(str.upper, names)) # ['AVA', 'RAJ']
- list(map(len, names)) # [3, 3]
- a = [1, 2, 3]; b = [10, 20, 30]
- list(map(lambda x, y: x + y, a, b)) # [11, 22, 33]
🔑Key Idea
map returns a lazy iterator, not a list. It computes each result only when asked, which saves memory on large sequences — but you must consume it with list() or a loop to see the values.
3filter: Select Matching Items
filter(function, iterable) keeps only the elements for which the function returns a truthy value, discarding the rest. Like map, it returns a lazy iterator. If you pass None as the function, filter removes all falsy values such as 0, empty strings, and None.
- nums = [-2, -1, 0, 1, 2]
- list(filter(lambda n: n > 0, nums)) # [1, 2]
- words = ['hi', '', 'ok', None]
- list(filter(None, words)) # ['hi', 'ok'] — drops falsy values
4reduce: Combine Into One Value
reduce(function, iterable) folds a sequence into a single result by repeatedly applying a two-argument function: it combines the first two items, then combines that result with the third, and so on. It is ideal for running totals, products, and finding a cumulative extreme. An optional third argument sets the starting value.
- from functools import reduce
- reduce(lambda a, b: a + b, [1, 2, 3, 4]) # 10
- reduce(lambda a, b: a * b, [1, 2, 3, 4]) # 24
- reduce(lambda a, b: a if a > b else b, [3, 9, 2]) # 9
- reduce(lambda a, b: a + b, [1, 2, 3], 100) # 106 — with initial value
Prefer a Built-in When One Exists
Many reduce use cases have a clearer built-in. Use sum() for totals, max() and min() for extremes, and math.prod() for products. Reserve reduce for genuinely custom accumulations that no built-in covers.
sum([1, 2, 3, 4]) # 10 — clearer than reduce
max([3, 9, 2]) # 9
import math; math.prod([1, 2, 3, 4]) # 245Map and Filter vs Comprehensions
In modern Python, a list comprehension frequently expresses map and filter more readably, especially when a lambda would otherwise be involved. Comprehensions read top to bottom in one expression and are often the community-preferred style.
- # map + filter:
- list(map(lambda x: x * 2, filter(lambda x: x > 0, nums)))
- # equivalent comprehension — usually clearer:
- [x * 2 for x in nums if x > 0]
💡Pro Tip
Use a comprehension when you would need a lambda inside map or filter. Reserve map and filter for passing an existing named function, where they read cleanly without a lambda.
6Common Mistakes to Avoid
These are the errors that most often trip people up with these functions.
- Forgetting that map and filter return iterators — printing one shows a map object, not the values; wrap in list().
- Consuming a map/filter iterator twice — after the first pass it is exhausted and yields nothing.
- Forgetting to import reduce from functools.
- Using reduce where sum, max, or math.prod would be clearer.
- Nesting map inside filter inside map until the line is unreadable — switch to a comprehension.
⚠️Watch Out
map and filter iterators are single-use. Once you loop over one or call list() on it, it is empty. Store the result in a list if you need to use it more than once.
7Laziness and Chaining
Because map and filter return lazy iterators, you can chain them without building intermediate lists, and nothing is computed until you consume the final result. This is memory-efficient for large data pipelines, but it also means you should materialize with list() at the end when you need concrete values.
- nums = range(1, 1_000_000)
- pipeline = map(lambda x: x * x, filter(lambda x: x % 2, nums))
- # nothing computed yet — pipeline is a lazy iterator
- first_five = [next(pipeline) for _ in range(5)] # pulls only five values
💡Pro Tip
Chaining lazy iterators lets you process data streams larger than memory. Just remember each iterator is single-use — consuming it once exhausts it.
8Key Takeaways
The three functions map cleanly onto three verbs.
- map transforms every item; filter selects items; reduce combines them.
- map and filter return lazy, single-use iterators.
- reduce lives in functools and folds a sequence to one value.
- Comprehensions often replace map and filter more readably.
- Prefer sum, max, min, and math.prod over reduce when they fit.
9Frequently Asked Questions
Q: What is the difference between map, filter, and reduce? A: map applies a function to every item and returns transformed values; filter keeps only items that pass a test; reduce combines all items into a single accumulated value. Transform, select, and aggregate, respectively.
Q: Why does printing a map object not show the values? A: Because map returns a lazy iterator, not a list. It computes values only when consumed. Wrap it in list(), or loop over it, to actually see or use the results.
Q: Where does reduce come from in Python? A: reduce is in the functools module, so you must write from functools import reduce before using it. It was moved out of the built-ins in Python 3 to encourage clearer alternatives like sum and explicit loops.
Q: Should I use map and filter or a list comprehension? A: A list comprehension is usually more readable, especially if you would otherwise pass a lambda to map or filter. Use map and filter mainly when you already have a named function to apply, where no lambda is needed.
Related Reading
Get The Print Version
Download a PDF of this article for offline reading.
About the Publisher
SkillVeris Team
Engineering Team
Our engineering writers turn abstract code concepts into hands-on, project-driven learning experiences.
View all postsRelated Posts
Never miss an update
Get the latest tutorials and guides delivered to your inbox.
No spam. Unsubscribe anytime.