理解map函数

Question

map(function, iterable, ...)

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

如果一个iterable比另一个短，则假定扩展时不包含任何项。

如果函数为None，则假定为identity函数；如果有多个参数，则map()返回一个由元组组成的列表，其中包含所有可迭代变量中的相应项(一种转置操作)。

可迭代参数可以是序列或任何可迭代对象；结果始终是列表。

这在制造笛卡尔产品中扮演了什么角色？

content = map(tuple, array)

把一个元组放在任何地方会有什么效果？我还注意到，如果不使用map函数，则输出结果为abc，使用该函数时，输出结果为a, b, c。

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

Answer 1

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

Answer 2

虽然我认为精通函数式编程的人可能会想出一些不可能理解的方法来使用map生成一个笛卡尔产品，但map与笛卡尔产品一点关系都没有。

Python3中的map等同于：

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

Python2中唯一的不同之处在于，它将构建一个完整的结果列表，以一次性返回所有结果，而不是yielding。

尽管Python约定通常更喜欢列表理解(或生成器表达式)，以实现与调用map相同的结果，特别是当您使用lambda表达式作为第一个参数时：

[func(i) for i in iterable]

作为你在问题的注释中所要求的例子--“将字符串转换成数组”，通过“array"，你可能想要一个元组或一个列表(它们的行为都有点像其他语言中的数组)-

 >>> 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循环(或者像sum这样的只需要可迭代而不需要序列的处理函数)，则需要list调用。但也要再次注意，列表理解通常是首选的：

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

Answer 3

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元map等同于将输入迭代压缩在一起，然后在中间压缩列表的每个元素上应用转换函数。它不是笛卡尔乘积：

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。