Understanding the map function
Apply function to every item of iterable and return a list of the results. If additional iterable arguments are passed, function must take that many arguments and is applied to the items from all iterables in parallel. If one iterable is shorter than another it is assumed to be extended with None items. If function is None , the identity function is assumed; if there are multiple arguments, map() returns a list consisting of tuples containing the corresponding items from all iterables (a kind of transpose operation). The iterable arguments may be a sequence or any iterable object; the result is always a list.
What effect does putting a tuple anywhere in there have? I also noticed that without the map function the output is abc and with it, it’s a, b, c . I want to fully understand this function. The reference definitions is also hard to understand. Too much fancy fluff.
@WebMaster yes, per the first sentence in the documentation that you pasted — «Apply function to every item of iterable». The rest of the paragraph is about more complex cases — like map(None, a, b, c) turns out to do zip(a, b, c) . But you very rarely see that in practice, precisely because the zip call is equivalent.
tuple is a function (well, its more nuanced than that, but it behaves like a function) that takes an iterable, and gives you a tuple with the same elements — so tuple([1, 2, 3]) is equivalent to (1, 2, 3) . For map(tuple, array) , array would be an iterable of iterables (think a list of lists), and it gives you back each inner list turned into a tuple.
In general, it is the first sentence of the documentation of any function that matters the most. If you understand that, you get the gist of it. The rest of it specifies the behaviour in great detail, and some of that will be a bit opaque to start with, and you may need to come across an odd idiom based on it before you see «oh, that’s what that means!». But once you get that lightbulb moment for a few builtins, you should start being able to understand the docs a bit more easily.
@WebMaster see my updated answer for an example of that. The original code of functions is available on python.org, but a lot of it won’t help you much — it is often written in C using the Python API, and very highly optimised making it harder to understand. We say things like «is equivalent to this somewhat easy to understand Python code» rather than «is implemented thus» for a reason.
6 Answers 6
map isn’t particularly pythonic. I would recommend using list comprehensions instead:
is basically equivalent to:
map on its own can’t do a Cartesian product, because the length of its output list is always the same as its input list. You can trivially do a Cartesian product with a list comprehension though:
[(a, b) for a in iterable_a for b in iterable_b] The syntax is a little confusing — that’s basically equivalent to:
result = [] for a in iterable_a: for b in iterable_b: result.append((a, b)) I find using map much less verbose than list comprehensions, at least for the case you are demonstrating.
How do I use map for properties? What is the map -equivalent of [v.__name__ for v in (object, str)] ?
map is faster since it doesn’t call functions based on length of iterators .. calling functions has overhead .. Watch 6:00 youtube.com/watch?v=SiXyyOA6RZg&t=813s
@anati I thought map was sometimes faster than comprehensions, sometimes not, precisely because of function call overhead? In particular, the heuristic I learned is that when using map requires you to introduce an extra function call, comprehensions are faster? E.g. I was led to believe that map(lambda foo: foo.bar, my_list) is slower than foo.bar for foo in my_list , and that even map(operator.add, my_list_of_pairs) is slower than x + y for x, y in my_list_of_pairs , precisely because of the additional function call.
map doesn’t relate to a Cartesian product at all, although I imagine someone well versed in functional programming could come up with some impossible to understand way of generating a one using map .
map in Python 3 is equivalent to this:
def map(func, iterable): for i in iterable: yield func(i) and the only difference in Python 2 is that it will build up a full list of results to return all at once instead of yield ing.
Although Python convention usually prefers list comprehensions (or generator expressions) to achieve the same result as a call to map , particularly if you’re using a lambda expression as the first argument:
As an example of what you asked for in the comments on the question — «turn a string into an array», by ‘array’ you probably want either a tuple or a list (both of them behave a little like arrays from other languages) —
>>> a = "hello, world" >>> list(a) ['h', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd'] >>> tuple(a) ('h', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd') A use of map here would be if you start with a list of strings instead of a single string — map can listify all of them individually:
>>> a = ["foo", "bar", "baz"] >>> list(map(list, a)) [['f', 'o', 'o'], ['b', 'a', 'r'], ['b', 'a', 'z']] Note that map(list, a) is equivalent in Python 2, but in Python 3 you need the list call if you want to do anything other than feed it into a for loop (or a processing function such as sum that only needs an iterable, and not a sequence). But also note again that a list comprehension is usually preferred:
>>> [list(b) for b in a] [['f', 'o', 'o'], ['b', 'a', 'r'], ['b', 'a', 'z']] map (fun x -> (x,x)) doesn’t seem hard to understand. (though getting a true cartesian product out of map would be impossible, anything map produces is always some form of a list)
map creates a new list by applying a function to every element of the source:
xs = [1, 2, 3] # all of those are equivalent — the output is [2, 4, 6] # 1. map ys = map(lambda x: x * 2, xs) # 2. list comprehension ys = [x * 2 for x in xs] # 3. explicit loop ys = [] for x in xs: ys.append(x * 2) n-ary map is equivalent to zipping input iterables together and then applying the transformation function on every element of that intermediate zipped list. It’s not a Cartesian product:
xs = [1, 2, 3] ys = [2, 4, 6] def f(x, y): return (x * 2, y // 2) # output: [(2, 1), (4, 2), (6, 3)] # 1. map zs = map(f, xs, ys) # 2. list comp zs = [f(x, y) for x, y in zip(xs, ys)] # 3. explicit loop zs = [] for x, y in zip(xs, ys): zs.append(f(x, y)) I’ve used zip here, but map behaviour actually differs slightly when iterables aren’t the same size — as noted in its documentation, it extends iterables to contain None .
Unfortunately all of these are not equivalent — the output is [2,4,6] for the list comprehension and the explicit loops, but the map returns a map object — for example I get this:
Simplifying a bit, you can imagine map() doing something like this:
def mymap(func, lst): result = [] for e in lst: result.append(func(e)) return result As you can see, it takes a function and a list, and returns a new list with the result of applying the function to each of the elements in the input list. I said «simplifying a bit» because in reality map() can process more than one iterable:
If additional iterable arguments are passed, function must take that many arguments and is applied to the items from all iterables in parallel. If one iterable is shorter than another it is assumed to be extended with None items.
For the second part in the question: What role does this play in making a Cartesian product? well, map() could be used for generating the cartesian product of a list like this:
lst = [1, 2, 3, 4, 5] from operator import add reduce(add, map(lambda i: map(lambda j: (i, j), lst), lst)) . But to tell the truth, using product() is a much simpler and natural way to solve the problem:
from itertools import product list(product(lst, lst)) Either way, the result is the cartesian product of lst as defined above:
[(1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (5, 1), (5, 2), (5, 3), (5, 4), (5, 5)] The map() function is there to apply the same procedure to every item in an iterable data structure, like lists, generators, strings, and other stuff.
Let’s look at an example: map() can iterate over every item in a list and apply a function to each item, than it will return (give you back) the new list.
Imagine you have a function that takes a number, adds 1 to that number and returns it:
def add_one(num): new_num = num + 1 return new_num You also have a list of numbers:
if you want to increment every number in the list, you can do the following:
>>> map(add_one, my_list) [2, 4, 7, 8, 9, 11] Note: At minimum map() needs two arguments. First a function name and second something like a list.
Let’s see some other cool things map() can do. map() can take multiple iterables (lists, strings, etc.) and pass an element from each iterable to a function as an argument.
list_one = [1, 2, 3, 4, 5] list_two = [11, 12, 13, 14, 15] list_three = [21, 22, 23, 24, 25] map() can make you a new list that holds the addition of elements at a specific index.
Now remember map() , needs a function. This time we’ll use the builtin sum() function. Running map() gives the following result:
>>> map(sum, list_one, list_two, list_three) [33, 36, 39, 42, 45] REMEMBER:
In Python 2 map() , will iterate (go through the elements of the lists) according to the longest list, and pass None to the function for the shorter lists, so your function should look for None and handle them, otherwise you will get errors. In Python 3 map() will stop after finishing with the shortest list. Also, in Python 3, map() returns an iterator, not a list.
Python3 — map(func, iterable)
One thing that wasn’t mentioned completely (although @BlooB kinda mentioned it) is that map returns a map object NOT a list. This is a big difference when it comes to time performance on initialization and iteration. Consider these two tests.
import time def test1(iterable): a = time.clock() map(str, iterable) a = time.clock() - a b = time.clock() [ str(x) for x in iterable ] b = time.clock() - b print(a,b) def test2(iterable): a = time.clock() [ x for x in map(str, iterable)] a = time.clock() - a b = time.clock() [ str(x) for x in iterable ] b = time.clock() - b print(a,b) test1(range(2000000)) # Prints ~1.7e-5s ~8s test2(range(2000000)) # Prints ~9s ~8s As you can see initializing the map function takes almost no time at all. However iterating through the map object takes longer than simply iterating through the iterable. This means that the function passed to map() is not applied to each element until the element is reached in the iteration. If you want a list use list comprehension. If you plan to iterate through in a for loop and will break at some point, then use map.