为什么列表理解可能比Python中的map（）更快？

Question

我正在研究Python中循环结构的性能问题，并发现以下语句：

除了列表推导的句法益处之外，它们通常比等效使用map更快或更快。 （ 性能提示 ）

列表推导比等效的for循环运行得快一点（除非你只是扔掉结果）。 （ Python速度 ）

我想知道引擎盖下有什么区别可以让列表理解这个优势。 谢谢。

Answer 1

测试一 ：扔掉结果。

这是我们的虚拟功能：

def examplefunc(x):
    pass

以下是我们的挑战者：

def listcomp_throwaway():
    [examplefunc(i) for i in range(100)]

def forloop_throwaway():
    for i in range(100):
        examplefunc(i)

根据OP的问题，我不会对其原始速度进行分析，只是为什么 。 让我们来看看机器代码的差异。

--- List comprehension
+++ For loop
@@ -1,15 +1,16 @@
- 55           0 BUILD_LIST               0
+ 59           0 SETUP_LOOP              30 (to 33)
               3 LOAD_GLOBAL              0 (range)
               6 LOAD_CONST               1 (100)
               9 CALL_FUNCTION            1
              12 GET_ITER            
-        >>   13 FOR_ITER                18 (to 34)
+        >>   13 FOR_ITER                16 (to 32)
              16 STORE_FAST               0 (i)
-             19 LOAD_GLOBAL              1 (examplefunc)
+
+ 60          19 LOAD_GLOBAL              1 (examplefunc)
              22 LOAD_FAST                0 (i)
              25 CALL_FUNCTION            1
-             28 LIST_APPEND              2
-             31 JUMP_ABSOLUTE           13
-        >>   34 POP_TOP             
-             35 LOAD_CONST               0 (None)
-             38 RETURN_VALUE        
+             28 POP_TOP             
+             29 JUMP_ABSOLUTE           13
+        >>   32 POP_BLOCK           
+        >>   33 LOAD_CONST               0 (None)
+             36 RETURN_VALUE     

比赛开始了。 Listcomp的第一步是建立一个空列表，而for循环是建立一个循环。 然后它们都继续加载全局范围（），常量100，并调用生成器的范围函数。 然后他们都获得当前的迭代器并获得下一个项目，并将其存储到变量i中。 然后他们加载examplefunc和i并调用examplefunc。 Listcomp将它附加到列表并再次开始循环。 For循环在三个指令中执行相同而不是两个。 然后他们都加载None并返回它。

那么谁在这个分析中似乎更好？ 在这里，列表理解会执行一些冗余操作，例如构建列表并附加到它，如果您不关心结果。 For循环也非常有效。

如果你计时，使用for循环比列表理解快三分之一。 （在这个测试中，examplefunc将其参数除以5并将其抛弃而不是什么都不做。）

测试二 ：保持结果正常。

这个测试没有虚函数。 所以这是我们的挑战者：

def listcomp_normal():
    l = [i*5 for i in range(100)]


def forloop_normal():
    l = []
    for i in range(100):
        l.append(i*5)

差异对我们今天没用。 它只是两个块中的两个机器码。

列出comp的机器代码：

 55           0 BUILD_LIST               0
              3 LOAD_GLOBAL              0 (range)
              6 LOAD_CONST               1 (100)
              9 CALL_FUNCTION            1
             12 GET_ITER            
        >>   13 FOR_ITER                16 (to 32)
             16 STORE_FAST               0 (i)
             19 LOAD_FAST                0 (i)
             22 LOAD_CONST               2 (5)
             25 BINARY_MULTIPLY     
             26 LIST_APPEND              2
             29 JUMP_ABSOLUTE           13
        >>   32 STORE_FAST               1 (l)
             35 LOAD_CONST               0 (None)
             38 RETURN_VALUE        

对于循环的机器代码：

 59           0 BUILD_LIST               0
              3 STORE_FAST               0 (l)

 60           6 SETUP_LOOP              37 (to 46)
              9 LOAD_GLOBAL              0 (range)
             12 LOAD_CONST               1 (100)
             15 CALL_FUNCTION            1
             18 GET_ITER            
        >>   19 FOR_ITER                23 (to 45)
             22 STORE_FAST               1 (i)

 61          25 LOAD_FAST                0 (l)
             28 LOAD_ATTR                1 (append)
             31 LOAD_FAST                1 (i)
             34 LOAD_CONST               2 (5)
             37 BINARY_MULTIPLY     
             38 CALL_FUNCTION            1
             41 POP_TOP             
             42 JUMP_ABSOLUTE           19
        >>   45 POP_BLOCK           
        >>   46 LOAD_CONST               0 (None)
             49 RETURN_VALUE        

正如您可能已经知道的那样，列表理解的指令少于循环。

列表理解的清单：

1. 构建一个匿名的空列表。
2. 负载range 。
3. 加载100 。
4. 通话range 。
5. 获取迭代器。
6. 获取该迭代器上的下一个项目。
7. 将该项目存储到i 。
8. 加载i 。
9. 加载整数五。
10. 乘以五倍。
11. 附上清单。
12. 重复步骤6-10，直到范围为空。
13. 将l指向匿名空列表。

对于循环的核对清单：

1. 构建一个匿名的空列表。
2. 将l指向匿名空列表。
3. 设置一个循环。
4. 负载range 。
5. 加载100 。
6. 通话range 。
7. 获取迭代器。
8. 获取该迭代器上的下一个项目。
9. 将该项目存储到i 。
10. 加载列表l 。
11. 在该列表中加载属性append 。
12. 加载i 。
13. 加载整数五。
14. 乘以五倍。
15. 呼叫append 。
16. 转到顶部。
17. 去绝对。

（不包括以下步骤：加载None ，返回。）

列表理解不必执行以下操作：

• 每次加载列表的附加，因为它被预先绑定为局部变量。
• 每个循环加载i两次
• 花两条指令到顶部
• 直接附加到列表而不是调用附加列表的包装器

总之，如果要使用这些值，listcomp要快得多，但如果不这样做，那么速度非常慢。

真正的速度

测试一：for循环速度快三分之一*

测试二：列表理解速度提高了大约三分之二*

*关于 - >小数点后第二位