map(function, iterable, ...)
将函数应用于可迭代的每个项目并返回结果列表。如果传递了额外的可迭代参数，则函数必须接受那么多参数并并行应用于所有可迭代的项目。
如果一个可迭代对象比另一个更短，则假定使用 None 项进行扩展。
如果 function 是None，则假定恒等函数；如果有多个参数，则map()返回一个由元组组成的列表，其中包含来自所有可迭代对象的相应项（一种转置操作）。
可迭代参数可以是序列或任何可迭代对象；结果始终是一个列表。
这在制作笛卡尔积中起什么作用？
content = map(tuple, array)
将元组放在其中有什么影响？我还注意到，如果没有 map 函数，输出abc是a, b, c.
我想完全理解这个功能。参考定义也很难理解。太多花哨的绒毛。
map不是特别pythonic。我建议改用列表推导：
map(f, iterable)
基本上相当于：
[f(x) for x in iterable]
map单靠它自己不能做笛卡尔积，因为它的输出列表的长度总是和它的输入列表一样。不过，您可以通过列表理解轻松地做笛卡尔积：
[(a, b) for a in iterable_a for b in iterable_b]
语法有点混乱——基本上相当于：
result = []
for a in iterable_a:
for b in iterable_b:
result.append((a, b))
map根本与笛卡尔积无关，尽管我想精通函数式编程的人可能会想出一些无法理解的使用map.
map在 Python 3 中等价于：
def map(func, iterable):
for i in iterable:
yield func(i)
Python 2 的唯一区别是它会建立一个完整的结果列表来一次返回所有结果，而不是yielding。
尽管 Python 约定通常更喜欢列表推导（或生成器表达式）来实现与调用相同的结果map，特别是如果您使用 lambda 表达式作为第一个参数：
[func(i) for i in iterable]
作为您在问题评论中所要求的示例 - “将字符串转换为数组”，通过“数组”，您可能想要一个元组或一个列表（它们的行为都有点像其他语言的数组） -
>>> 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')
map如果您从字符串列表而不是单个字符串开始，则此处的用途是-map可以单独列出所有这些：
>>> a = ["foo", "bar", "baz"]
>>> list(map(list, a))
[['f', 'o', 'o'], ['b', 'a', 'r'], ['b', 'a', 'z']]
请注意，这map(list, a)在 Python 2 中是等价的，但在 Python 3 中，list如果您想要执行任何操作而不是将其输入for循环（或诸如sum只需要可迭代而不是序列的处理函数），则需要调用。但还要再次注意，通常首选列表推导式：
>>> [list(b) for b in a]
[['f', 'o', 'o'], ['b', 'a', 'r'], ['b', 'a', 'z']]
map通过将函数应用于源的每个元素来创建一个新列表：
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-arymap相当于将输入迭代压缩在一起，然后将转换函数应用于该中间压缩列表的每个元素。它不是笛卡尔积：
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))
我在zip这里使用过，但是map当可迭代对象的大小不同时，行为实际上会略有不同——正如其文档中所述，它将可迭代对象扩展为包含None.
稍微简化一下，你可以想象map()做这样的事情：
def mymap(func, lst):
result = []
for e in lst:
result.append(func(e))
return result
如您所见，它接受一个函数和一个列表，并返回一个新列表，其中包含将函数应用于输入列表中的每个元素的结果。我说“简化一点”是因为实际上map()可以处理多个可迭代对象：
如果传递了额外的可迭代参数，则函数必须接受那么多参数并并行应用于所有可迭代的项目。如果一个可迭代对象比另一个更短，则假定使用 None 项进行扩展。
对于问题的第二部分：这在制作笛卡尔积中起什么作用？好吧，map() 可以用于生成这样的列表的笛卡尔积：
lst = [1, 2, 3, 4, 5]
from operator import add
reduce(add, map(lambda i: map(lambda j: (i, j), lst), lst))
...但说实话，使用product()是解决问题的一种更简单自然的方法：
from itertools import product
list(product(lst, lst))
无论哪种方式，结果都是lst如上定义的笛卡尔积：
[(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)]
该map()函数用于将相同的过程应用于可迭代数据结构中的每个项目，如列表、生成器、字符串和其他内容。
让我们看一个例子：
map()可以遍历列表中的每个项目并对每个项目应用一个函数，然后它将返回（返回）新列表。
想象一下，你有一个函数，它接受一个数字，将该数字加 1 并返回它：
def add_one(num):
new_num = num + 1
return new_num
您还有一个数字列表：
my_list = [1, 3, 6, 7, 8, 10]
如果要递增列表中的每个数字，可以执行以下操作：
>>> map(add_one, my_list)
[2, 4, 7, 8, 9, 11]
注意：至少map()需要两个参数。首先是函数名称，其次是列表。
让我们看看其他一些很酷的事情map()可以做。
map()可以采用多个可迭代对象（列表、字符串等）并将每个可迭代对象的元素作为参数传递给函数。
我们有三个列表：
list_one = [1, 2, 3, 4, 5]
list_two = [11, 12, 13, 14, 15]
list_three = [21, 22, 23, 24, 25]
map()可以为您创建一个新列表，其中包含在特定索引处添加的元素。
现在记住map()，需要一个函数。这次我们将使用内置sum()函数。运行map()给出以下结果：
>>> map(sum, list_one, list_two, list_three)
[33, 36, 39, 42, 45]
记住：
在 Python 2map()中，将根据最长的列表进行迭代（遍历列表的元素），并将None较短的列表传递给函数，因此您的函数应该查找None并处理它们，否则会出错。在 Python 3map()中，将在完成最短列表后停止。此外，在 Python 3 中，map()返回一个迭代器，而不是一个列表。
没有完全提到的一件事（尽管@BlooB 有点提到它）是 map 返回一个地图对象而不是一个列表。在初始化和迭代的时间性能方面，这是一个很大的区别。考虑这两个测试。
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
如您所见，初始化 map 函数几乎不需要任何时间。然而，遍历 map 对象比简单地遍历 iterable 需要更长的时间。这意味着在迭代中到达元素之前，传递给 map() 的函数不会应用于每个元素。如果您想要一个列表，请使用列表理解。如果您打算在 for 循环中迭代并在某个时候中断，请使用 map.