How to use Python map()

map() runs a function on each item of an iterable, like a list, and returns the results as a new collection with the same number of items. It’s one of 3 useful global functions Python provides to work with collections, along with filter() and reduce().

Tip: sometimes list comprehensions make more sense and are generally considered more pythonic

Here’s map() used to double each item in a list:

numbers = [1, 2, 3]

def double(a):
    return a * 2

result = map(double, numbers)

When the function is a one-liner, it’s common to use a lambda function:

numbers = [1, 2, 3]

double = lambda a : a * 2

result = map(double, numbers)

and even inline it:

numbers = [1, 2, 3]

result = map(lambda a : a * 2, numbers)

The original list is left untouched.

The result is not a list

map() returns a map object, an iterator. To print its content, you need to cast it to a list:

print(list(result)) # [2, 4, 6]

This laziness is intentional. Values are computed only when you iterate over them, so with a huge collection nothing happens until you actually consume the results.

But there’s a catch: an iterator can be consumed only once.

result = map(lambda a : a * 2, [1, 2, 3])

print(list(result)) # [2, 4, 6]
print(list(result)) # []

The second call prints an empty list, because the iterator is exhausted. If you need the values more than once, store list(result) in a variable and use that.

Using map() with multiple iterables

You can pass more than one iterable to map(). The function must accept one argument per iterable:

prices = [1.5, 2.25, 3.0]
quantities = [2, 3, 1]

totals = map(lambda price, qty: price * qty, prices, quantities)

print(list(totals)) # [3.0, 6.75, 3.0]

If the iterables have different lengths, map() stops at the shortest one. The extra items in the longer iterable are ignored.

The list comprehension alternative

For simple cases like doubling numbers, a list comprehension does the same job:

numbers = [1, 2, 3]

result = [a * 2 for a in numbers]

This gives you a real list right away, no cast needed. map() shines when you already have the function defined, or when you want the lazy evaluation.

Want me to talk about your product? You can sponsor this site.