我运行了一个快速测试，比较了调用对象方法的三种方法。在这种情况下，时间差可以忽略不计，这是函数的问题(参见@Alex Martelli的回复)。在这里，我研究了以下方法:

# map_lambda
list(map(lambda x: x.add(), vals))

# map_operator
from operator import methodcaller
list(map(methodcaller("add"), vals))

# map_comprehension
[x.add() for x in vals]

我查看了整数(Python int)和浮点数(Python float)的列表(存储在变量vals中)，以增加列表的大小。考虑以下虚拟类DummyNum:

class DummyNum(object):
    """Dummy class"""
    __slots__ = 'n',

    def __init__(self, n):
        self.n = n

    def add(self):
        self.n += 5

具体来说，就是add方法。__slots__属性是Python中的一个简单优化，用于定义类(属性)所需的总内存，减少内存大小。 这里是结果图。

如前所述，所使用的技术只会产生最小的差异，您应该以对您来说最易读的方式进行编码，或者在特定的情况下进行编码。在这种情况下，列表理解(map_comprehension技术)对于对象中的两种类型的添加是最快的，特别是对于较短的列表。

访问这个粘贴文件以获取用于生成图表和数据的源。

我用perfplot(我的一个项目)计算了一些结果。

正如其他人所注意到的，map实际上只返回一个迭代器，因此它是一个常量时间操作。当通过list()实现迭代器时，它与列表推导式相当。根据不同的表达方式，任何一种都可能有轻微的优势，但并不显著。

注意，像x ** 2这样的算术运算在NumPy中要快得多，特别是如果输入数据已经是NumPy数组的话。

hex:

X ** 2:

代码重现图:

import perfplot


def standalone_map(data):
    return map(hex, data)


def list_map(data):
    return list(map(hex, data))


def comprehension(data):
    return [hex(x) for x in data]


b = perfplot.bench(
    setup=lambda n: list(range(n)),
    kernels=[standalone_map, list_map, comprehension],
    n_range=[2 ** k for k in range(20)],
    equality_check=None,
)
b.save("out.png")
b.show()

import perfplot
import numpy as np


def standalone_map(data):
    return map(lambda x: x ** 2, data[0])


def list_map(data):
    return list(map(lambda x: x ** 2, data[0]))


def comprehension(data):
    return [x ** 2 for x in data[0]]


def numpy_asarray(data):
    return np.asarray(data[0]) ** 2


def numpy_direct(data):
    return data[1] ** 2


b = perfplot.bench(
    setup=lambda n: (list(range(n)), np.arange(n)),
    kernels=[standalone_map, list_map, comprehension, numpy_direct, numpy_asarray],
    n_range=[2 ** k for k in range(20)],
    equality_check=None,
)
b.save("out2.png")
b.show()

性能测量

图片来源:Experfy

你可以自己看看在列表理解和映射函数之间哪个更好。

(与map函数相比，列表理解处理100万条记录所需的时间更少。)

这里有一个可能的例子:

map(lambda op1,op2: op1*op2, list1, list2)

对比:

[op1*op2 for op1,op2 in zip(list1,list2)]

我猜，如果坚持使用列表推导式而不是映射，那么zip()是一种不幸的、不必要的开销。如果有人能肯定或否定地澄清这一点，那就太好了。

Python 2:你应该使用map和filter而不是列表推导式。

一个客观的原因是，即使它们不是“Pythonic”，你也应该喜欢它们: 它们需要函数/lambdas作为参数，这引入了一个新的作用域。

我不止一次被这个问题困扰过:

for x, y in somePoints:
    # (several lines of code here)
    squared = [x ** 2 for x in numbers]
    # Oops, x was silently overwritten!

但如果我说:

for x, y in somePoints:
    # (several lines of code here)
    squared = map(lambda x: x ** 2, numbers)

那一切都会好起来的。

你可以说我在相同的作用域中使用相同的变量名是愚蠢的。

我不是。代码本来是好的——两个x不在同一个作用域内。 直到我将内部块移动到代码的不同部分后，问题才出现(即:问题发生在维护期间，而不是开发期间)，而且我没有预料到。

是的，如果你从来没有犯过这个错误，那么列表推导式会更优雅。 但从个人经验(以及看到其他人犯同样的错误)来看，我已经见过很多次这样的情况，所以我认为当这些错误渗透到代码中时，不值得你经历这种痛苦。

结论:

使用映射和过滤器。它们可以防止微妙的、难以诊断的范围相关错误。

注:

不要忘记考虑使用imap和filter(在itertools中)，如果它们适合你的情况!

所以从Python 3开始，map()是一个迭代器，你需要记住你需要什么:一个迭代器或列表对象。

正如@AlexMartelli已经提到的，只有在不使用lambda函数的情况下，map()才比列表理解更快。

我会给你们看一些时间比较。

Python 3.5.2和CPythonI已经使用了Jupiter笔记本电脑，特别是%timeit内置的魔法命令 测量:s == 1000 ms == 1000 * 1000µs = 1000 * 1000 * 1000 ns

设置:

x_list = [(i, i+1, i+2, i*2, i-9) for i in range(1000)]
i_list = list(range(1000))

内置函数:

%timeit map(sum, x_list)  # creating iterator object
# Output: The slowest run took 9.91 times longer than the fastest. 
# This could mean that an intermediate result is being cached.
# 1000000 loops, best of 3: 277 ns per loop

%timeit list(map(sum, x_list))  # creating list with map
# Output: 1000 loops, best of 3: 214 µs per loop

%timeit [sum(x) for x in x_list]  # creating list with list comprehension
# Output: 1000 loops, best of 3: 290 µs per loop

lambda函数:

%timeit map(lambda i: i+1, i_list)
# Output: The slowest run took 8.64 times longer than the fastest. 
# This could mean that an intermediate result is being cached.
# 1000000 loops, best of 3: 325 ns per loop

%timeit list(map(lambda i: i+1, i_list))
# Output: 1000 loops, best of 3: 183 µs per loop

%timeit [i+1 for i in i_list]
# Output: 10000 loops, best of 3: 84.2 µs per loop

还有类似生成器表达式的东西，参见PEP-0289。所以我认为把它添加到比较中是有用的

%timeit (sum(i) for i in x_list)
# Output: The slowest run took 6.66 times longer than the fastest. 
# This could mean that an intermediate result is being cached.
# 1000000 loops, best of 3: 495 ns per loop

%timeit list((sum(x) for x in x_list))
# Output: 1000 loops, best of 3: 319 µs per loop

%timeit (i+1 for i in i_list)
# Output: The slowest run took 6.83 times longer than the fastest. 
# This could mean that an intermediate result is being cached.
# 1000000 loops, best of 3: 506 ns per loop

%timeit list((i+1 for i in i_list))
# Output: 10000 loops, best of 3: 125 µs per loop

你需要列表对象:

如果是自定义函数，则使用列表推导式;如果是内置函数，则使用list(map())

你不需要列表对象，你只需要一个可迭代对象:

总是使用map()!