如果有一个用 C 编写的函数/方法来获得一点额外的性能，我有时会使用map。然而，我最近重新审视了我的一些基准测试，并注意到 Python 3.5 和 3.6 之间的相对性能(与类似的列表理解相比)发生了巨大变化。
这不是实际的代码，而只是一个说明差异的最小示例：
import random
lst = [random.randint(0, 10) for _ in range(100000)]
assert list(map((5).__lt__, lst)) == [5 < i for i in lst]
%timeit list(map((5).__lt__, lst))
%timeit [5 < i for i in lst]
我意识到使用(5).__lt__不是一个好主意，但我现在想不出一个有用的例子。
Python-3.5 的时机有利于map方法：
15.1 ms ± 5.64 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
16.7 ms ± 35.6 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
虽然 Python-3.6 的时间实际上表明理解速度更快：
17.9 ms ± 755 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
14.3 ms ± 128 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
我的问题是在这种情况下发生了什么，使列表理解更快，map解决方案更慢？我意识到差异并不大，它只是让我很好奇，因为这是我有时(实际上很少)在性能关键代码中使用的"技巧"之一。
我认为公平的比较包括在Python 3.5和3.6中使用相同的函数和相同的测试条件，以及在所选Python版本中比较map列表理解。
在我的初始答案中，我进行了多次测试，表明与列表理解相比，map在两个版本的 Python 中仍然快了大约两倍。然而，有些结果并不是决定性的，所以我做了更多的测试。
首先让我引用你在问题中提出的一些观点：
"...[我]注意到[
map]的相对性能(与类似的列表理解相比)在Python 3.5和3.6之间发生了巨大变化。
你还会问：
"我的问题是，在这种情况下发生了什么，使列表理解更快，地图解决方案更慢？">
目前还不清楚你的意思是 map 比 Python 3.6 中的列表理解慢，或者你的意思是 Python 3.6 中的 map 比 3.5 中的慢，并且列表理解的性能有所提高(尽管不一定达到击败map的水平)。
根据我在第一次回答这个问题后进行的更广泛的测试，我想我对正在发生的事情有所了解。
但是，首先让我们为"公平"比较创造条件。为此，我们需要：
使用相同的函数比较不同 Python 版本中
map的性能;比较
map的性能，以使用相同的功能列出同一版本中的理解;对相同的数据运行测试;
最大限度地减少定时功能的影响。
以下是有关我的系统的版本信息：
Python 3.5.3 |Continuum Analytics, Inc.| (default, Mar 6 2017, 12:15:08)
[GCC 4.2.1 Compatible Apple LLVM 6.0 (clang-600.0.57)] on darwin
IPython 5.3.0 -- An enhanced Interactive Python.
和
Python 3.6.2 |Continuum Analytics, Inc.| (default, Jul 20 2017, 13:14:59)
[GCC 4.2.1 Compatible Apple LLVM 6.0 (clang-600.0.57)] on darwin
IPython 6.1.0 -- An enhanced Interactive Python. Type '?' for help.
让我们首先解决"相同数据"的问题。不幸的是，因为你有效地使用了seed(None)，每个数据集lst在两个版本的Python上都是不同的。这可能导致两个Python版本的性能差异。一种解决方法是设置，例如，random.seed(0)(或类似的东西)。我选择创建一次列表并使用numpy.save()保存它，然后在每个版本中加载它。这一点尤其重要，因为我选择稍微修改您的测试("循环"和"重复次数")，并且已将数据集的长度增加到 100,000,000：
import numpy as np
import random
lst = [random.randint(0, 10) for _ in range(100000000)]
np.save('lst', lst, allow_pickle=False)
其次，让我们使用timeit模块而不是IPython的魔术命令%timeit。这样做的原因来自在 Python 3.5 中执行的以下测试：
In [11]: f = (5).__lt__
In [12]: %timeit -n1 -r20 [f(i) for i in lst]
1 loop, best of 20: 9.01 s per loop
将此结果与相同版本的 Python 中的timeit结果进行比较：
>>> t = timeit.repeat('[f(i) for i in lst]', setup="f = (5).__lt__;
... import numpy; lst = numpy.load('lst.npy').tolist()", repeat=20,
... number=1); print(min(t), max(t), np.mean(t), np.std(t))
7.442819457995938 7.703615028003696 7.5105415405 0.0550515642854
由于我不知道的原因，与timeit软件包相比，IPython 的神奇%timeit增加了一些时间。因此，我将在测试中专门使用timeit。
注意：在下面的讨论中，我将只使用最小计时(min(t))。
Python 3.5.3 中的测试：
第 1 组：地图和列表理解测试
>>> import numpy as np
>>> import timeit
>>> t = timeit.repeat('list(map(f, lst))', setup="f = (5).__lt__; import numpy; lst = numpy.load('lst.npy').tolist()", repeat=20, number=1); print(min(t), max(t), np.mean(t), np.std(t))
4.666553302988177 4.811194089008495 4.72791638025 0.041115884397
>>> t = timeit.repeat('[f(i) for i in lst]', setup="f = (5).__lt__; import numpy; lst = numpy.load('lst.npy').tolist()", repeat=20, number=1); print(min(t), max(t), np.mean(t), np.std(t))
7.442819457995938 7.703615028003696 7.5105415405 0.0550515642854
>>> t = timeit.repeat('[5 < i for i in lst]', setup="import numpy; lst = numpy.load('lst.npy').tolist()", repeat=20, number=1); print(min(t), max(t), np.mean(t), np.std(t))
4.94656751700677 5.07807950800634 5.00670203845 0.0340474956945
>>> t = timeit.repeat('list(map(abs, lst))', setup="import numpy; lst = numpy.load('lst.npy').tolist()", repeat=20, number=1); print(min(t), max(t), np.mean(t), np.std(t))
4.167273573024431 4.320013975986512 4.2408865186 0.0378852782878
>>> t = timeit.repeat('[abs(i) for i in lst]', setup="import numpy; lst = numpy.load('lst.npy').tolist()", repeat=20, number=1); print(min(t), max(t), np.mean(t), np.std(t))
5.664627838006709 5.837686392012984 5.71560354655 0.0456700607748
请注意，第二次测试(使用f(i)的列表理解)明显比第三次测试(使用5 < i的列表理解)慢得多，这表明从代码角度来看，f = (5).__lt__与5 < i不相同(或几乎相同)。
第2组："个人"功能测试
>>> t = timeit.repeat('f(1)', setup="f = (5).__lt__", repeat=20, number=1000000); print(min(t), max(t), np.mean(t), np.std(t))
0.052280781004810706 0.05500587198184803 0.0531139718529 0.000877649561967
>>> t = timeit.repeat('5 < 1', repeat=20, number=1000000); print(min(t), max(t), np.mean(t), np.std(t))
0.030931947025237605 0.033691533986711875 0.0314959864045 0.000633274658428
>>> t = timeit.repeat('abs(1)', repeat=20, number=1000000); print(min(t), max(t), np.mean(t), np.std(t))
0.04685414198320359 0.05405496899038553 0.0483296330043 0.00162837880358
请注意，第一次测试(f(1))明显慢于第二次测试(5 < 1)，进一步支持f = (5).__lt__从代码角度来看与5 < i不相同(或几乎相同)。
Python 3.6.2 中的测试：
第 1 组：地图和列表理解测试
>>> import numpy as np
>>> import timeit
>>> t = timeit.repeat('list(map(f, lst))', setup="f = (5).__lt__; import numpy; lst = numpy.load('lst.npy').tolist()", repeat=20, number=1); print(min(t), max(t), np.mean(t), np.std(t))
4.599696700985078 4.743880658003036 4.6631793691 0.0425774678203
>>> t = timeit.repeat('[f(i) for i in lst]', setup="f = (5).__lt__; import numpy; lst = numpy.load('lst.npy').tolist()", repeat=20, number=1); print(min(t), max(t), np.mean(t), np.std(t))
7.316072431014618 7.572676292009419 7.3837024617 0.0574811241553
>>> t = timeit.repeat('[5 < i for i in lst]', setup="import numpy; lst = numpy.load('lst.npy').tolist()", repeat=20, number=1); print(min(t), max(t), np.mean(t), np.std(t))
4.570452399988426 4.679144663008628 4.61264215875 0.0265541828693
>>> t = timeit.repeat('list(map(abs, lst))', setup="import numpy; lst = numpy.load('lst.npy').tolist()", repeat=20, number=1); print(min(t), max(t), np.mean(t), np.std(t))
2.742673939006636 2.8282236389932223 2.78504617405 0.0260357089928
>>> t = timeit.repeat('[abs(i) for i in lst]', setup="import numpy; lst = numpy.load('lst.npy').tolist()", repeat=20, number=1); print(min(t), max(t), np.mean(t), np.std(t))
6.2177103200228885 6.428813881997485 6.28722427145 0.0493010620999
第2组："个人"功能测试
>>> t = timeit.repeat('f(1)', setup="f = (5).__lt__", repeat=20, number=1000000); print(min(t), max(t), np.mean(t), np.std(t))
0.051936342992121354 0.05764096099301241 0.0532974587506 0.00117079475737
>>> t = timeit.repeat('5 < 1', repeat=20, number=1000000); print(min(t), max(t), np.mean(t), np.std(t))
0.02675032999832183 0.032919151999522 0.0285137565021 0.00156522182488
>>> t = timeit.repeat('abs(1)', repeat=20, number=1000000); print(min(t), max(t), np.mean(t), np.std(t))
0.047831349016632885 0.0531779529992491 0.0482893927969 0.00112825297875
请注意，从代码的角度来看，第一次测试(f(1))明显慢于第二次测试(5 < 1)，进一步支持f = (5).__lt__与5 < i不相同(或几乎相同)。
讨论
我不知道这些时序测试的可靠性如何，也很难区分导致这些时序结果的所有因素。然而，我们可以从"第 2 组"测试中注意到，唯一显着改变其时间的"个人"测试是5 < 1测试：它在 Python 3.6 中从 Python 3.5 中的 0.0309s 下降到 0.0268s。这使得 Python 3.6 中的列表理解测试使用5 < i比 Python 3.5 中的类似测试运行得更快。但是，这并不意味着列表理解在Python 3.6中变得更快。
让我们比较map的相对性能，以列出同一 Python 版本中对相同函数的理解。然后我们进入Python 3.5：r(f) = 7.4428/4.6666 = 1.595，r(abs) = 5.665/4.167 = 1.359和Python 3.6：r(f) = 7.316/4.5997 = 1.591，r(abs) = 6.218/2.743 = 2.267。基于这些相对性能，我们可以看到，在 Python 3.6 中，map相对于列表理解性能的性能至少与 Python 3.5 中f = (5).__lt__函数的性能相同，对于 Python 3.6 中的abs()等函数，这个比率甚至有所提高。
无论如何，我相信没有证据表明列表理解在 Python 3.6 中无论是在相对意义上还是在绝对意义上都变得更快。唯一的性能改进是针对[5 < i for i in lst]测试，但那是因为5 < i本身在 Python 3.6 中变得更快，而不是由于列表理解本身更快。
我认为公平的比较将涉及使用相同的函数。在你的例子中，当比较公平时，map仍然胜出：
>>> import sys
>>> print(sys.version)
3.6.2 |Continuum Analytics, Inc.| (default, Jul 20 2017, 13:14:59)
[GCC 4.2.1 Compatible Apple LLVM 6.0 (clang-600.0.57)]
>>> import random
>>> lst = [random.randint(0, 10) for _ in range(100000)]
>>> assert list(map((5).__lt__, lst)) == [5 < i for i in lst]
>>> f = (5).__lt__
>>> %timeit list(map(f, lst))
4.63 ms ± 110 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
>>> %timeit [f(i) for i in lst]
9.17 ms ± 177 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
虽然在Python 3.5中(至少在我的系统上)，map比Python 3.6更快，但列表理解也是如此：
>>> print(sys.version)
3.5.3 |Continuum Analytics, Inc.| (default, Mar 6 2017, 12:15:08)
[GCC 4.2.1 Compatible Apple LLVM 6.0 (clang-600.0.57)]
>>> %timeit list(map(f, lst))
100 loops, best of 3: 4.36 ms per loop
>>> %timeit [f(i) for i in lst]
100 loops, best of 3: 8.12 ms per loop
尽管如此，当使用相同的函数时，map比 Python 3.5 和 3.6 中的列表理解快 ~2 倍。
编辑(对@user2357112评论的回应)：
我认为，进行"公平"比较对于回答OP的问题很重要："我的问题是在这种情况下发生了什么，使列表理解更快，地图解决方案更慢？">(最后一段)。然而，在第一段中，@MSeifert说："......[我]注意到Python 3.5和3.6之间的相对性能(与类似的列表理解相比)发生了巨大变化">也就是说，比较是在map和list comprehension之间。然而，@MSeifert测试设置如下：
timig_map_35 = Timing(list(map(f, lst)))
timing_list_35 = Timing([g(i) for i in lst])
这种测试使得很难找到时间差异的原因：是因为列表理解在 3.6 中变得更快，还是地图在 3.6 中变慢，或者f(i)在 3.6 中变慢g(i)在 3.6 中更快......
因此，我建议引入f = (5).__lt__并在map和列表理解测试中使用相同的功能。我还通过增加列表中的元素数量并重新编辑timeit中的"循环"数量来修改@MSeifert测试：
import random
lst = [random.randint(0, 10) for _ in range(1000000)] # 10x more elements
f = (5).__lt__
%timeit -n1 -r1000 list(map(f, lst)) # f = (5).__lt__
%timeit -n1 -r1000 [f(i) for i in lst] # f(i) = (5).__lt__(i)
%timeit -n1 -r1000 [5 < i for i in lst] # g(i) = 5 < i
%timeit -n1 -r1000 [1 for _ in lst] # h(i) = 1
在Python 3.6中，我得到：
43.5 ms ± 1.79 ms per loop (mean ± std. dev. of 1000 runs, 1 loop each)
82.2 ms ± 2.39 ms per loop (mean ± std. dev. of 1000 runs, 1 loop each)
43.6 ms ± 1.64 ms per loop (mean ± std. dev. of 1000 runs, 1 loop each)
23.8 ms ± 1.27 ms per loop (mean ± std. dev. of 1000 runs, 1 loop each)
在Python 3.5中，我得到：
1 loop, best of 1000: 43.7 ms per loop
1 loop, best of 1000: 78.9 ms per loop
1 loop, best of 1000: 46 ms per loop
1 loop, best of 1000: 26.8 ms per loop
在我看来，这表明列表理解在 3.6 中比在 3.5 中略快，除非使用f。因此，很难断定是 Python 3.6 中较慢的map，或者由于对f的调用较慢，因此首先timeit上面的较慢。因此，我又进行了两个测试：
%timeit -n1 -r1000 list(map(abs, lst))
%timeit -n1 -r1000 [abs(i) for i in lst]
%timeit -n1000000 -r1000 f(1)
在Python 3.6中，我得到：
25.8 ms ± 1.42 ms per loop (mean ± std. dev. of 1000 runs, 1 loop each)
67.1 ms ± 2.07 ms per loop (mean ± std. dev. of 1000 runs, 1 loop each)
64.7 ns ± 2.22 ns per loop (mean ± std. dev. of 1000 runs, 1000000 loops each)
在Python 3.5中，我得到：
1 loop, best of 1000: 38.3 ms per loop
1 loop, best of 1000: 56.4 ms per loop
1000000 loops, best of 1000: 59.6 ns per loop
这表明map在某些函数上可能比列表理解快得多：具体来说，对于abs(x)Python 3.6 中map与"列表理解"的相对性能67.1/25.8 = 2.60而在 Python 3.5 中它是56.4/38.3 = 1.47。因此，知道为什么@MSeifert测试显示map在Python 3.6中较慢是很有趣的。我上面的最后一个测试显示了f(1)"单独"的时间测试。我不确定这个测试的有效性如何(不幸的是) - 我想避免使用map或[for]来消除一个变量 - 但它表明在 Python 3.6 中f = (5).__lt__变得比在 Python 3.5 中慢。因此我的结论是，是函数f((5).__lt__)的特定形式，其计算速度变慢，而不是map函数。我知道最后一个"单独"测试可能是一个糟糕的测试，但是，map与abs一起使用时非常快(相对或绝对)的事实表明问题出在f而不是map。
注意：Python 3.5 使用 IPython5.3.0，Python 3.6 使用 IPython 6.1.0。