Python map() Function Explained

Python’s map() function applies the same function to each item in an iterable.

This is useful when you want to transform data, such as:

• converting numbers to strings
• changing strings to integers
• doubling every value in a list

The main thing beginners need to know is this:

• map() does not return a list in Python 3
• it returns a map object
• you often convert that result with list()

Quick example #

numbers = [1, 2, 3, 4]
result = map(str, numbers)
print(list(result))

Output:

['1', '2', '3', '4']

Use map(function, iterable) to apply the same function to each item. Convert the result to list() if you want to see all mapped values at once.

What map() does #

map() applies a function to each item in an iterable.

An iterable is something you can loop over, such as:

• a list
• a tuple
• a string
• a range object

The basic form is:

map(function, iterable)

For each item in the iterable, Python calls the function and produces a new value.

Important: the result is a map object, not a list.

If you want to understand iterables better, see iterators and iterable objects explained.

Basic syntax #

map() needs at least two parts:

• Function: the function to run on each item
• Iterable: the values to process

Basic syntax:

map(function, iterable)

You can pass:

• built-in functions like str, int, or abs
• your own custom function
• a lambda function for short one-line logic

If you are new to lambda functions, see lambda functions in Python explained.

You will often see map() used like this:

list(map(function, values))

That is because list() turns the map object into a normal list you can print or reuse.

Simple example #

Here is a simple example that converts numbers to strings:

numbers = [10, 20, 30]
result = map(str, numbers)

print(list(result))

Output:

['10', '20', '30']

What happens here:

• numbers contains integers
• map(str, numbers) passes each number to str()
• str(10) becomes '10'
• str(20) becomes '20'
• str(30) becomes '30'

So map() applies str() one item at a time.

If you want to understand list() better, see Python list() function explained.

Using map() with your own function #

You can also use map() with a function you define yourself.

def double(x):
    return x * 2

numbers = [1, 2, 3, 4]
result = map(double, numbers)

print(list(result))

Output:

[2, 4, 6, 8]

How this works:

• map() takes the function double
• it sends each item from numbers into that function
• the returned values become the mapped result

In other words, Python does this behind the scenes:

• double(1) → 2
• double(2) → 4
• double(3) → 6
• double(4) → 8

Using map() with multiple iterables #

map() can also work with more than one iterable.

When you do that, the function must accept the same number of arguments.

Example:

def add_numbers(a, b):
    return a + b

list1 = [1, 2, 3]
list2 = [10, 20, 30]

result = map(add_numbers, list1, list2)

print(list(result))

Output:

[11, 22, 33]

Here:

• the first values are used together: add_numbers(1, 10)
• then add_numbers(2, 20)
• then add_numbers(3, 30)

map() stops at the shortest iterable #

If the iterables have different lengths, map() stops when the shortest one ends.

def add_numbers(a, b):
    return a + b

list1 = [1, 2, 3, 4]
list2 = [10, 20]

result = map(add_numbers, list1, list2)

print(list(result))

Output:

[11, 22]

Only two results are produced because list2 has only two items.

map() returns an iterator-like object #

In Python 3, map() returns a map object.

This object is lazy, which means values are produced only when needed.

Why print(result) looks strange #

Beginners often expect this:

numbers = [1, 2, 3]
result = map(str, numbers)

print(result)

Output will look something like this:

<map object at 0x...>

That happens because you are printing the map object itself, not the values inside it.

To see the mapped values, convert it to a list or loop over it:

numbers = [1, 2, 3]
result = map(str, numbers)

print(list(result))

Output:

['1', '2', '3']

You can loop over a map object directly #

numbers = [1, 2, 3]
result = map(str, numbers)

for item in result:
    print(item)

Output:

1
2
3

A map object is exhausted after use #

Once you consume a map object, it is empty the next time.

numbers = [1, 2, 3]
result = map(str, numbers)

print(list(result))
print(list(result))

Output:

['1', '2', '3']
[]

The second list is empty because the map object was already used.

If you need the values more than once, store them in a list:

numbers = [1, 2, 3]
result = list(map(str, numbers))

print(result)
print(result)

Output:

['1', '2', '3']
['1', '2', '3']

When to use map() #

map() is a good choice when you want to apply one function to every item.

It works especially well with simple built-in functions such as:

• str
• int
• abs

Example:

values = ['1', '2', '3']
numbers = list(map(int, values))

print(numbers)

Output:

[1, 2, 3]

For beginners, a list comprehension is often easier to read.

For example, these do similar work:

numbers = [1, 2, 3]
result = list(map(str, numbers))
print(result)

numbers = [1, 2, 3]
result = [str(n) for n in numbers]
print(result)

Both produce:

['1', '2', '3']

A simple rule:

• use map() when applying a clear function to every item
• use a for loop when you need more steps or more explanation
• use a list comprehension when you want a compact and readable transformation

If you want more practice with that style, see how to use list comprehensions in Python.

Common beginner mistakes #

1. Forgetting to convert the result to list() #

This is very common:

numbers = [1, 2, 3]
result = map(str, numbers)

print(result)

This prints the map object, not the values.

Fix:

print(list(result))

2. Calling the function instead of passing it #

Wrong:

numbers = [1, 2, 3]
result = map(str(), numbers)

This is wrong because str() is being called immediately. map() needs the function itself, not the result of calling it.

Correct:

numbers = [1, 2, 3]
result = map(str, numbers)

print(list(result))

3. Using a function with the wrong number of parameters #

If your function needs two arguments, but you pass only one iterable, it will fail.

Wrong:

def add(a, b):
    return a + b

numbers = [1, 2, 3]
result = map(add, numbers)

print(list(result))

Correct:

def add(a, b):
    return a + b

list1 = [1, 2, 3]
list2 = [10, 20, 30]
result = map(add, list1, list2)

print(list(result))

4. Reusing the same map object #

Wrong:

numbers = [1, 2, 3]
result = map(str, numbers)

print(list(result))
print(list(result))

The second result is empty.

Fix: create a new map object, or convert once and save the list.

Helpful checks while debugging #

If map() is not doing what you expect, these quick checks can help:

print(result)
print(list(result))
print(type(result))
for item in result:
    print(item)

What these show:

• print(result) shows that you have a map object
• print(list(result)) shows the actual mapped values
• print(type(result)) confirms the result type
• looping over result lets you inspect items one by one

Be careful: list(result) and a for loop consume the map object.

FAQ #

Does map() return a list in Python? #

No. In Python 3, map() returns a map object. Use list(map(...)) if you need a list.

Is map() better than a for loop? #

Not always. map() is shorter for simple transformations, but a for loop can be easier to read.

Can map() use more than one list? #

Yes. Pass multiple iterables, and use a function that accepts one argument for each iterable.

Why is my map object empty the second time? #

A map object is consumed as you iterate over it. Create a new one if you need to use it again.

See also #

• Python filter() function explained
• Python list() function explained
• How to filter a list in Python
• How to use list comprehensions in Python
• Iterators and iterable objects explained