# Understanding the map function

### Question

``````map(function, iterable, ...)
``````

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 role does this play in making a Cartesian product?

``````content = map(tuple, array)
``````

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.

1
280
2/7/2016 1:05:13 AM

`map` isn't particularly pythonic. I would recommend using list comprehensions instead:

``````map(f, iterable)
``````

is basically equivalent to:

``````[f(x) for x in iterable]
``````

`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))
``````
388
6/3/2015 1:16:09 PM

`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:

``````[func(i) for i in iterable]
``````

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']]
``````