Maps and Filters in python

When working with lists, it’s common to want to apply the same action to each item, or to select only certain items. Python provides two handy tools for this: map() and filter(). These functions help you write shorter, clearer code compared to writing full loops every time.

The map() Function

The map() function applies a given function to every item in a list (or any iterable). This is great when you want to transform data in one step.

numbers = [1, 2, 3, 4]

squares = list(map(lambda x: x**2, numbers))
print(squares)
# [1, 4, 9, 16]

Here, lambda x: x**2 is a small function that squares each number. map() applies it to every item in numbers and gives back the results.

Another example with text:

words = ["cat", "dog", "parrot"]

uppercased = list(map(str.upper, words))
print(uppercased)
# ['CAT', 'DOG', 'PARROT']

Why the list()?

map() doesn’t actually create a list — it creates a map object, which is an iterator. That means it knows how to give you items one by one, but you can only loop through it once. Wrapping it in list() turns the result into a list you can print, reuse, and work with normally.

Things to try

• Create a list of numbers and use map() to double each one.
• Make a list of names and use map() with str.lower to turn them all lowercase.

The filter() Function

The filter() function chooses items from a list based on a condition. Only items where the condition is True are kept.

numbers = [10, 15, 20, 25, 30]

evens = list(filter(lambda x: x % 2 == 0, numbers))
print(evens)
# [10, 20, 30]

Here, the function checks if each number is even (x % 2 == 0). Only the even numbers are returned.

Another example with words:

words = ["apple", "bat", "carrot", "dog"]

long_words = list(filter(lambda w: len(w) > 3, words))
print(long_words)
# ['apple', 'carrot']

Why the list()?

Just like map(), filter() gives you a filter object (another iterator). Wrapping it in list() makes the results visible and reusable. Without list(), printing it would just show something like <filter object at 0x...>.

Things to try

• Create a list of numbers and filter out only the numbers greater than 50.
• Make a list of words and filter to keep only those starting with the letter “a”.

Combining map() and filter()

You can use these functions together to process and clean data in a single readable chain.

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

# First filter even numbers, then square them
result = list(map(lambda x: x**2, filter(lambda x: x % 2 == 0, numbers)))
print(result)
# [4, 16, 36]

This code finds all the even numbers, then maps a function to square them. Instead of writing a longer loop, you have one short line.

Things to try

• Create a list of numbers 1–20. Use filter() to select only odd numbers, then map() to triple them.
• Make a list of names, filter those longer than four letters, then convert them to uppercase.

Comparison with List Comprehensions

Python also has list comprehensions, which often achieve the same result as map() and filter() but with a slightly different style. Some developers find them easier to read, while others prefer map()/filter() for clarity.

Here’s the even-squares example again:

Using map() and filter():

numbers = [1, 2, 3, 4, 5, 6]
result = list(map(lambda x: x**2, filter(lambda x: x % 2 == 0, numbers)))
print(result)
# [4, 16, 36]

Using a list comprehension:

numbers = [1, 2, 3, 4, 5, 6]
result = [x**2 for x in numbers if x % 2 == 0]
print(result)
# [4, 16, 36]

Both produce the same result — it’s just a matter of style and what feels clearer to you.

Things to try

• Rewrite a map() example as a list comprehension.
• Rewrite a filter() example as a list comprehension.

Wrapping Up

• map() transforms every item in a list using a function.
• filter() keeps only the items that meet a condition.
• Both return iterators, so you’ll usually wrap them in list() to see and reuse the results.
• They can be combined for powerful data transformations.
• List comprehensions often provide an alternative that many find even more readable.