pythonmap什么意思_python - 理解map函数

python - 理解map函数

map(function, iterable, ...)

将函数应用于iterable的每个项目并返回结果列表。 如果传递了其他可迭代参数，则函数必须采用那么多参数，并且并行地应用于所有迭代的项。

如果一个iterable比另一个短，则假定使用None项扩展。

如果函数是abc，则假定为identity函数; 如果有多个参数，则a, b, c返回一个由包含所有迭代中相应项的元组组成的列表(一种转置操作)。

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

这在制作笛卡尔积的过程中扮演什么角色？

content = map(tuple, array)

将元组放在哪里有什么影响？ 我也注意到没有map函数输出的是abc，有了它，它是a, b, c。

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

6个解决方案

325 votes

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

dave answered 2019-02-21T08:02:45Z

77 votes

map根本不涉及笛卡尔积，尽管我认为精通函数式编程的人可能会想出一些不可能理解的使用map(list, a)生成一个的方法。

Python 3中的map(list, a)等同于：

def map(func, iterable):

for i in iterable:

yield func(i)

并且Python 2的唯一区别在于它将构建一个完整的结果列表，以便一次性返回，而不是map(list, a)ing。

虽然Python约定通常更喜欢列表推导(或生成器表达式)来实现与调用map(list, a)相同的结果，特别是如果您使用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(list, a) - list可以单独分解所有这些字符串：

>>> a = ["foo", "bar", "baz"]

>>> list(map(list, a))

[['f', 'o', 'o'], ['b', 'a', 'r'], ['b', 'a', 'z']]

请注意，map(list, a)在Python 2中是等效的，但是在Python 3中，如果您想要做任何其他操作而不是将其提供给for循环(或者只需要可迭代的处理函数，如sum，而不是序列，则需要list调用)。 但同样请注意，列表理解通常是首选：

>>> [list(b) for b in a]

[['f', 'o', 'o'], ['b', 'a', 'r'], ['b', 'a', 'z']]

lvc answered 2019-02-21T08:04:07Z

29 votes

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

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扩展为包含None。

Cat Plus Plus answered 2019-02-21T08:04:58Z

20 votes

简化一下，你可以想象lst做这样的事情：

def mymap(func, lst):

result = []

for e in lst:

result.append(func(e))

return result

如您所见，它接受一个函数和一个列表，并返回一个新列表，其中包含将函数应用于输入列表中的每个元素的结果。 我说“简化一点”因为实际上lst可以处理多个迭代：

如果传递了其他可迭代参数，则函数必须采用那么多参数，并且并行地应用于所有迭代的项。 如果一个iterable比另一个短，则假定使用None项扩展。

对于问题的第二部分：这在制作笛卡尔积中起到了什么作用？ 好吧，lst可用于生成列表的笛卡尔积，如下所示：

lst = [1, 2, 3, 4, 5]

from operator import add

reduce(add, map(lambda i: map(lambda j: (i, j), lst), lst))

...但说实话，使用lst是解决问题的一种更简单自然的方法：

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

Óscar López answered 2019-02-21T08:06:08Z

14 votes

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()可以做的其他一些很酷的事情。sum()可以使用多个iterables(列表，字符串等)，并将每个iterable中的元素作为参数传递给函数。

我们有三个清单：

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 2 map()中，将根据最长列表迭代(遍历列表的元素)，并将None传递给较短列表的函数，因此您的函数应查找None并处理它们，否则您将收到错误。 在Python 3中，map()将在完成最短列表后停止。 此外，在Python 3中，map()返回迭代器，而不是列表。

BlooB answered 2019-02-21T08:08:21Z

1 votes

Python3 - map(func，iterable)

没有完全提到的一件事(虽然@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对象需要的时间比简单地遍历iterable要长。 这意味着传递给map()的函数不会应用于每个元素，直到迭代中到达元素。 如果你想要一个列表使用列表理解。 如果你计划在for循环中迭代并在某个时刻中断，那么使用map。

Ranga answered 2019-02-21T08:09:18Z