理解map函数

Question

map(function, iterable, ...)

将函数应用于迭代的每一项，并返回结果列表。如果传递了额外的可迭代参数，函数必须接受这么多参数，并并行应用于所有迭代的项。

如果一个迭代比另一个迭代短，则假定它是用无项扩展的。

如果函数是无，则假定身份函数；如果有多个参数，map（）返回包含所有迭代中相应项的元组组成的列表（一种转置操作）。

可迭代参数可以是序列或任何可迭代对象；结果总是一个列表。

这在制造笛卡尔积时扮演什么角色？

content = map(tuple, array)

把元组放在任何地方都有什么效果？我还注意到，没有map函数，输出是abc，有了它，输出是a、b、c。

我想完全理解这个功能。参考定义也很难理解。太多花哨的绒毛。

Answer 1

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当iterables大小不同时，行为实际上略有不同-正如其文档中所指出的，它将iterables扩展为包含None。

Answer 2

map与笛卡尔积毫无关系，尽管我认为精通函数式编程的人可能会想出一些不可能理解的方法来使用map生成笛卡尔积。

Python 3中的map等效于此：

def map(func, iterable):
    for i in iterable:
        yield func(i)

Python2唯一的区别是它将建立一个完整的结果列表，一次返回所有结果，而不是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）在Python2中是等效的，但是在Python3中，如果您不想将其送入for循环（或者只需要iterable而不需要序列的sum等处理函数），则需要调用list。但请再次注意，通常首选列表理解：

>>> [list(b) for b in a]
[['f', 'o', 'o'], ['b', 'a', 'r'], ['b', 'a', 'z']]

Answer 3

map并不特别像蟒蛇。我建议改为使用列表理解：

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