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

`map`

?`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.willbe a bit opaque to start with, and you may need to come across an odd idiom based on it before you see "oh,that'swhat 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.7more comments