Sometimes you might face situations in which you need to perform the same operation on all the items of an input iterable to build a new iterable. The quickest and most common approach to this problem is to use a Python
for loop. However, you can also tackle this problem without an explicit loop by using
In the following three sections, you’ll learn how
map() works and how you can use it to process and transform iterables without a loop.
map() loops over the items of an input iterable (or iterables) and returns an iterator that results from applying a transformation function to every item in the original input iterable.
According to the documentation,
map() takes a function object and an iterable (or multiple iterables) as arguments and returns an iterator that yields transformed items on demand. The function’s signature is defined as follows:
map(function, iterable[, iterable1, iterable2,..., iterableN])
function to each item in
iterable in a loop and returns a new iterator that yields transformed items on demand.
function can be any Python function that takes a number of arguments equal to the number of iterables you pass to
Note: The first argument to
map() is a function object, which means that you need to pass a function without calling it. That is, without using a pair of parentheses.
This first argument to
map() is a transformation function. In other words, it’s the function that transforms each original item into a new (transformed) item. Even though the Python documentation calls this argument
function, it can be any Python callable. This includes built-in functions, classes, methods,
lambda functions, and user-defined functions.
The operation that
map() performs is commonly known as a mapping because it maps every item in an input iterable to a new item in a resulting iterable. To do that,
map() applies a transformation function to all the items in the input iterable.
To better understand
map(), suppose you need to take a list of numeric values and transform it into a list containing the square value of every number in the original list. In this case, you can use a
for loop and code something like this:
>>> numbers = [1, 2, 3, 4, 5] >>> squared =  >>> for num in numbers: ... squared.append(num ** 2) ... >>> squared [1, 4, 9, 16, 25]
When you run this loop on
numbers, you get a list of square values. The
for loop iterates over
numbers and applies a power operation on each value. Finally, it stores the resulting values in
You can achieve the same result without using an explicit loop by using
map(). Take a look at the following reimplementation of the above example:
>>> def square(number): ... return number ** 2 ... >>> numbers = [1, 2, 3, 4, 5] >>> squared = map(square, numbers) >>> list(squared) [1, 4, 9, 16, 25]
square() is a transformation function that maps a number to its square value. The call to
square() to all of the values in
numbers and returns an iterator that yields square values. Then you call
map() to create a list object containing the square values.
map() is written in C and is highly optimized, its internal implied loop can be more efficient than a regular Python
for loop. This is one advantage of using
A second advantage of using
map() is related to memory consumption. With a
for loop, you need to store the whole list in your system’s memory. With
map(), you get items on demand, and only one item is in your system’s memory at a given time.
Note: In Python 2.x,
map() returns a list. This behavior changed in Python 3.x. Now,
map() returns a map object, which is an iterator that yields items on demand. That’s why you need to call
list() to create the desired list object.
For another example, say you need to convert all the items in a list from a string to an integer number. To do that, you can use
map() along with
int() as follows:
>>> str_nums = ["4", "8", "6", "5", "3", "2", "8", "9", "2", "5"] >>> int_nums = map(int, str_nums) >>> int_nums <map object at 0x7fb2c7e34c70> >>> list(int_nums) [4, 8, 6, 5, 3, 2, 8, 9, 2, 5] >>> str_nums ["4", "8", "6", "5", "3", "2", "8", "9", "2", "5"]
int() to every value in
map() returns an iterator (a map object), you’ll need call
list() so that you can exhaust the iterator and turn it into a list object. Note that the original sequence doesn’t get modified in the process.
You can use any kind of Python callable with
map(). The only condition would be that the callable takes an argument and returns a concrete and useful value. For example, you can use classes, instances that implement a special method called
__call__(), instance methods, class methods, static methods, and functions.
There are some built-in functions that you can use with
map(). Consider the following examples:
>>> numbers = [-2, -1, 0, 1, 2] >>> abs_values = list(map(abs, numbers)) >>> abs_values [2, 1, 0, 1, 2] >>> list(map(float, numbers)) [-2.0, -1.0, 0.0, 1.0, 2.0] >>> words = ["Welcome", "to", "Real", "Python"] >>> list(map(len, words)) [7, 2, 4, 6]
You can use any built-in function with
map(), provided that the function takes an argument and returns a value.
A common pattern that you’ll see when it comes to using
map() is to use a
lambda function as the first argument.
lambda functions are handy when you need to pass an expression-based function to
map(). For example, you can reimplement the example of square values using a
lambda function as follows:
>>> numbers = [1, 2, 3, 4, 5] >>> squared = map(lambda num: num ** 2, numbers) >>> list(squared) [1, 4, 9, 16, 25]
lambda functions are quite useful when it comes to using
map(). They can play the role of the first argument to
map(). You can use
lambda functions along with
map() to quickly process and transform your iterables.
If you supply multiple iterables to
map(), then the transformation function must take as many arguments as iterables you pass in. Each iteration of
map() will pass one value from each iterable as an argument to
function. The iteration stops at the end of the shortest iterable.
Consider the following example that uses
>>> first_it = [1, 2, 3] >>> second_it = [4, 5, 6, 7] >>> list(map(pow, first_it, second_it)) [1, 32, 729]
pow() takes two arguments,
y, and returns
x to the power of
y. In the first iteration,
x will be
y will be
4, and the result will be
1. In the second iteration,
x will be
y will be
5, and the result will be
32, and so on. The final iterable is only as long as the shortest iterable, which is
first_it in this case.
This technique allows you to merge two or more iterables of numeric values using different kinds of math operations. Here are some examples that use
lambda functions to perform different math operations on several input iterables:
>>> list(map(lambda x, y: x - y, [2, 4, 6], [1, 3, 5])) [1, 1, 1] >>> list(map(lambda x, y, z: x + y + z, [2, 4], [1, 3], [7, 8])) [10, 15]
In the first example, you use a subtraction operation to merge two iterables of three items each. In the second example, you add together the values of three iterables.