性能测量

图片来源:Experfy

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

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

我运行了一个快速测试，比较了调用对象方法的三种方法。在这种情况下，时间差可以忽略不计，这是函数的问题(参见@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技术)对于对象中的两种类型的添加是最快的，特别是对于较短的列表。

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

我的用例:

def sum_items(*args):
    return sum(args)


list_a = [1, 2, 3]
list_b = [1, 2, 3]

list_of_sums = list(map(sum_items,
                        list_a, list_b))
>>> [3, 6, 9]

comprehension = [sum(items) for items in iter(zip(list_a, list_b))]

我发现自己开始使用更多的map，我认为map可能比comp慢，因为传递和返回参数，这就是我找到这篇文章的原因。

我相信使用map可以更有可读性和灵活性，特别是当我需要构造列表的值时。

如果你用地图的话，你读的时候就明白了。

def pair_list_items(*args):
    return args

packed_list = list(map(pair_list_items,
                       lista, *listb, listc.....listn))

再加上灵活性奖励。 谢谢你其他的答案，再加上绩效奖金。

在某些情况下，Map可能会快得多(当您没有为此目的而使用lambda，而是在Map和列表推导中使用相同的函数时)。在其他情况下，列表推导式可能更快，大多数(不是所有)python主义者认为它们更直接、更清晰。

当使用完全相同的函数时，map的微小速度优势的例子:

$ python -m timeit -s'xs=range(10)' 'map(hex, xs)'
100000 loops, best of 3: 4.86 usec per loop

$ python -m timeit -s'xs=range(10)' '[hex(x) for x in xs]'
100000 loops, best of 3: 5.58 usec per loop

当map需要lambda时，性能比较完全颠倒的示例:

$ python -m timeit -s'xs=range(10)' 'map(lambda x: x+2, xs)'
100000 loops, best of 3: 4.24 usec per loop

$ python -m timeit -s'xs=range(10)' '[x+2 for x in xs]'
100000 loops, best of 3: 2.32 usec per loop

我发现列表推导式通常比映射式更能表达我想要做的事情——它们都能完成，但前者节省了试图理解复杂lambda表达式的精神负担。

在某个地方也有一个采访(我不能马上找到)，Guido列出lambdas和函数函数是他最后悔接受Python的东西，所以你可以认为它们是非Python的。

我用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()