Question

The Python 2 documentation says:

Built-in Functions: 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.

Answer 1

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))