Python: 使用 dis 分析列表理解
Python: analyze a list comprehension with dis
最近，我在 SO 上有一个关于以下两段代码的 （请参阅上下文）：
res = [d.get(next((k for k in d if k in s), None), s) for s in lst]
并且：
res = [next((v for k,v in d.items() if k in s), s) for s in lst]
都遍历列表 lst 中的字符串 s 并在字典 d 中查找 s。如果找到 s，则返回关联值，否则返回 s。我很确定第二段代码比第一段快，因为（对于每个s）字典中没有查找，只是对（键，值）对的迭代。
问题是：
如何检查这是否真的是幕后发生的事情？
我第一次尝试 dis 模块，但结果令人失望 (python 3.6.3):
>>> dis.dis("[d.get(next((k for k in d if k in s), None), s) for s in lst]")
1 0 LOAD_CONST 0 (<code object <listcomp> at 0x7f8e302039c0, file "<dis>", line 1>)
2 LOAD_CONST 1 ('<listcomp>')
4 MAKE_FUNCTION 0
6 LOAD_NAME 0 (lst)
8 GET_ITER
10 CALL_FUNCTION 1
12 RETURN_VALUE
>>> dis.dis("[next((v for k,v in d.items() if k in s), s) for s in lst]")
1 0 LOAD_CONST 0 (<code object <listcomp> at 0x7f8e302038a0, file "<dis>", line 1>)
2 LOAD_CONST 1 ('<listcomp>')
4 MAKE_FUNCTION 0
6 LOAD_NAME 0 (lst)
8 GET_ITER
10 CALL_FUNCTION 1
12 RETURN_VALUE
如何获得更详细的信息？
编辑
正如@abarnert 在第一条评论中所建议的那样，我尝试 timeit 这两种解决方案。我玩了以下代码：
from faker import Faker
from timeit import timeit
fake = Faker()
d = {fake.word():fake.word() for _ in range(50000)}
lst = fake.words(500000)
def f():return [d.get(next((k for k in d if k in s), None), s) for s in lst]
def g():return [next((v for k,v in d.items() if k in s), s) for s in lst]
print(timeit(f, number=1))
print(timeit(g, number=1))
assert f() == g()
也许我错过了什么，但令我惊讶的是，第一段代码 (f) 总是比第二段 (g) 快。因此第二个问题：有人有解释吗？
EDIT 2 下面是反汇编代码中最有趣的部分（带有一些格式以插入内循环）。
对于 f:
2 0 BUILD_LIST 0
2 LOAD_FAST 0 (.0)
>> 4 FOR_ITER 36 (to 42)
6 STORE_DEREF 0 (s)
8 LOAD_GLOBAL 0 (d)
10 LOAD_ATTR 1 (get)
12 LOAD_GLOBAL 2 (next)
14 LOAD_CLOSURE 0 (s)
16 BUILD_TUPLE 1
18 LOAD_CONST 0 (<code object <genexpr> at 0x7ff191b1d8a0, file "test.py", line 2>)
2 0 LOAD_FAST 0 (.0)
>> 2 FOR_ITER 18 (to 22)
4 STORE_FAST 1 (k)
6 LOAD_FAST 1 (k)
8 LOAD_DEREF 0 (s)
10 COMPARE_OP 6 (in)
12 POP_JUMP_IF_FALSE 2
14 LOAD_FAST 1 (k)
16 YIELD_VALUE
18 POP_TOP
20 JUMP_ABSOLUTE 2
>> 22 LOAD_CONST 0 (None)
24 RETURN_VALUE
20 LOAD_CONST 1 ('f.<locals>.<listcomp>.<genexpr>')
22 MAKE_FUNCTION 8
24 LOAD_GLOBAL 0 (d)
26 GET_ITER
28 CALL_FUNCTION 1
30 LOAD_CONST 2 (None)
32 CALL_FUNCTION 2
34 LOAD_DEREF 0 (s)
36 CALL_FUNCTION 2
38 LIST_APPEND 2
40 JUMP_ABSOLUTE 4
>> 42 RETURN_VALUE
对于g：
3 0 BUILD_LIST 0
2 LOAD_FAST 0 (.0)
>> 4 FOR_ITER 32 (to 38)
6 STORE_DEREF 0 (s)
8 LOAD_GLOBAL 0 (next)
10 LOAD_CLOSURE 0 (s)
12 BUILD_TUPLE 1
14 LOAD_CONST 0 (<code object <genexpr> at 0x7ff1905171e0, file "test.py", line 3>)
3 0 LOAD_FAST 0 (.0)
>> 2 FOR_ITER 22 (to 26)
4 UNPACK_SEQUENCE 2
6 STORE_FAST 1 (k)
8 STORE_FAST 2 (v)
10 LOAD_FAST 1 (k)
12 LOAD_DEREF 0 (s)
14 COMPARE_OP 6 (in)
16 POP_JUMP_IF_FALSE 2
18 LOAD_FAST 2 (v)
20 YIELD_VALUE
22 POP_TOP
24 JUMP_ABSOLUTE 2
>> 26 LOAD_CONST 0 (None)
28 RETURN_VALUE
16 LOAD_CONST 1 ('g.<locals>.<listcomp>.<genexpr>')
18 MAKE_FUNCTION 8
20 LOAD_GLOBAL 1 (d)
22 LOAD_ATTR 2 (items)
24 CALL_FUNCTION 0
26 GET_ITER
28 CALL_FUNCTION 1
30 LOAD_DEREF 0 (s)
32 CALL_FUNCTION 2
34 LIST_APPEND 2
36 JUMP_ABSOLUTE 4
>> 38 RETURN_VALUE
可以看到（同样由@abarnert 建议）g 的内部循环包含一些额外的成本：
- （隐藏）迭代器在
d.items() 上构造 2-uples
- 一个
UNPACK_SEQUENCE 2 解压那些 2-uples 然后把 k 和 v 放在堆栈上
- 两个
STORE_FAST 从堆栈中弹出 k 和 v 以将它们存储在 co_varnames.
在最终加载 k 之前将其与 s 进行比较，如 f 中所示。这个内部循环被迭代 |lst|*|d| 并且似乎这些操作有所不同。
如果像我想的那样优化，d.items() 迭代器会首先将 k 放入堆栈以测试 k in s，然后，仅当 [=45] =] 为真，将 v 放入 YIELD_VALUE.
的堆栈
您已经获得了有关评估列表理解的代码的所有详细信息。
但是列表推导等同于创建然后调用一个函数。 （这就是它们有自己的作用域的方式，所以它们不会，例如，将循环变量泄漏到外部作用域中。）因此，名为 <listcomp> 的 automatically-generated 函数才是您真正想要看到的代码对于.
如果你想反汇编它——好吧，请注意 LOAD_CONST 0 说它正在加载 <code object <listcomp> at 0x7f8e302038a0？那就是你想要的。但是我们做不到，因为我们所做的只是为了反汇编而编译一个字符串，然后丢弃结果，所以 listcomp 函数不再存在了。
但是用真实的代码很容易看出来：
>>> def f():
... return [next((v for k,v in d.items() if k in s), s) for s in lst]
>>> dis.dis(f)
2 0 LOAD_CONST 1 (<code object <listcomp> at 0x11da9c660, file "<ipython-input-942-698335d58585>", line 2>)
2 LOAD_CONST 2 ('f.<locals>.<listcomp>')
4 MAKE_FUNCTION 0
6 LOAD_GLOBAL 0 (lst)
8 GET_ITER
10 CALL_FUNCTION 1
12 RETURN_VALUE
又是那个代码对象 const——但现在它不仅仅是我们编译后立即丢弃的 const，它是我们可以访问的函数的一部分。
我们如何访问它？好吧，这在 inspect 模块文档中有记录，这可能不是您首先要看的地方。函数在其 __code__ 成员中有一个代码对象，代码对象在其 co_consts 成员中有一系列常量，我们正在寻找常量 #1，因此：
>>> dis.dis(f.__code__.co_consts[1])
2 0 BUILD_LIST 0
2 LOAD_FAST 0 (.0)
>> 4 FOR_ITER 32 (to 38)
6 STORE_DEREF 0 (s)
8 LOAD_GLOBAL 0 (next)
10 LOAD_CLOSURE 0 (s)
12 BUILD_TUPLE 1
14 LOAD_CONST 0 (<code object <genexpr> at 0x11dd20030, file "<ipython-input-942-698335d58585>", line 2>)
16 LOAD_CONST 1 ('f.<locals>.<listcomp>.<genexpr>')
18 MAKE_FUNCTION 8
20 LOAD_GLOBAL 1 (d)
22 LOAD_ATTR 2 (items)
24 CALL_FUNCTION 0
26 GET_ITER
28 CALL_FUNCTION 1
30 LOAD_DEREF 0 (s)
32 CALL_FUNCTION 2
34 LIST_APPEND 2
36 JUMP_ABSOLUTE 4
>> 38 RETURN_VALUE
当然，您有一个生成器表达式嵌套在您的列表推导式中，而且，正如您可能猜到的那样，这也等同于创建然后调用一个生成器函数。但是生成器函数的代码很容易找到（如果输入起来更乏味）：f.__code__.co_consts[1].co_consts[0].
最近，我在 SO 上有一个关于以下两段代码的
res = [d.get(next((k for k in d if k in s), None), s) for s in lst]
并且：
res = [next((v for k,v in d.items() if k in s), s) for s in lst]
都遍历列表 lst 中的字符串 s 并在字典 d 中查找 s。如果找到 s，则返回关联值，否则返回 s。我很确定第二段代码比第一段快，因为（对于每个s）字典中没有查找，只是对（键，值）对的迭代。
问题是： 如何检查这是否真的是幕后发生的事情？
我第一次尝试 dis 模块，但结果令人失望 (python 3.6.3):
>>> dis.dis("[d.get(next((k for k in d if k in s), None), s) for s in lst]")
1 0 LOAD_CONST 0 (<code object <listcomp> at 0x7f8e302039c0, file "<dis>", line 1>)
2 LOAD_CONST 1 ('<listcomp>')
4 MAKE_FUNCTION 0
6 LOAD_NAME 0 (lst)
8 GET_ITER
10 CALL_FUNCTION 1
12 RETURN_VALUE
>>> dis.dis("[next((v for k,v in d.items() if k in s), s) for s in lst]")
1 0 LOAD_CONST 0 (<code object <listcomp> at 0x7f8e302038a0, file "<dis>", line 1>)
2 LOAD_CONST 1 ('<listcomp>')
4 MAKE_FUNCTION 0
6 LOAD_NAME 0 (lst)
8 GET_ITER
10 CALL_FUNCTION 1
12 RETURN_VALUE
如何获得更详细的信息？
编辑
正如@abarnert 在第一条评论中所建议的那样，我尝试 timeit 这两种解决方案。我玩了以下代码：
from faker import Faker
from timeit import timeit
fake = Faker()
d = {fake.word():fake.word() for _ in range(50000)}
lst = fake.words(500000)
def f():return [d.get(next((k for k in d if k in s), None), s) for s in lst]
def g():return [next((v for k,v in d.items() if k in s), s) for s in lst]
print(timeit(f, number=1))
print(timeit(g, number=1))
assert f() == g()
也许我错过了什么，但令我惊讶的是，第一段代码 (f) 总是比第二段 (g) 快。因此第二个问题：有人有解释吗？
EDIT 2 下面是反汇编代码中最有趣的部分（带有一些格式以插入内循环）。
对于 f:
2 0 BUILD_LIST 0
2 LOAD_FAST 0 (.0)
>> 4 FOR_ITER 36 (to 42)
6 STORE_DEREF 0 (s)
8 LOAD_GLOBAL 0 (d)
10 LOAD_ATTR 1 (get)
12 LOAD_GLOBAL 2 (next)
14 LOAD_CLOSURE 0 (s)
16 BUILD_TUPLE 1
18 LOAD_CONST 0 (<code object <genexpr> at 0x7ff191b1d8a0, file "test.py", line 2>)
2 0 LOAD_FAST 0 (.0)
>> 2 FOR_ITER 18 (to 22)
4 STORE_FAST 1 (k)
6 LOAD_FAST 1 (k)
8 LOAD_DEREF 0 (s)
10 COMPARE_OP 6 (in)
12 POP_JUMP_IF_FALSE 2
14 LOAD_FAST 1 (k)
16 YIELD_VALUE
18 POP_TOP
20 JUMP_ABSOLUTE 2
>> 22 LOAD_CONST 0 (None)
24 RETURN_VALUE
20 LOAD_CONST 1 ('f.<locals>.<listcomp>.<genexpr>')
22 MAKE_FUNCTION 8
24 LOAD_GLOBAL 0 (d)
26 GET_ITER
28 CALL_FUNCTION 1
30 LOAD_CONST 2 (None)
32 CALL_FUNCTION 2
34 LOAD_DEREF 0 (s)
36 CALL_FUNCTION 2
38 LIST_APPEND 2
40 JUMP_ABSOLUTE 4
>> 42 RETURN_VALUE
对于g：
3 0 BUILD_LIST 0
2 LOAD_FAST 0 (.0)
>> 4 FOR_ITER 32 (to 38)
6 STORE_DEREF 0 (s)
8 LOAD_GLOBAL 0 (next)
10 LOAD_CLOSURE 0 (s)
12 BUILD_TUPLE 1
14 LOAD_CONST 0 (<code object <genexpr> at 0x7ff1905171e0, file "test.py", line 3>)
3 0 LOAD_FAST 0 (.0)
>> 2 FOR_ITER 22 (to 26)
4 UNPACK_SEQUENCE 2
6 STORE_FAST 1 (k)
8 STORE_FAST 2 (v)
10 LOAD_FAST 1 (k)
12 LOAD_DEREF 0 (s)
14 COMPARE_OP 6 (in)
16 POP_JUMP_IF_FALSE 2
18 LOAD_FAST 2 (v)
20 YIELD_VALUE
22 POP_TOP
24 JUMP_ABSOLUTE 2
>> 26 LOAD_CONST 0 (None)
28 RETURN_VALUE
16 LOAD_CONST 1 ('g.<locals>.<listcomp>.<genexpr>')
18 MAKE_FUNCTION 8
20 LOAD_GLOBAL 1 (d)
22 LOAD_ATTR 2 (items)
24 CALL_FUNCTION 0
26 GET_ITER
28 CALL_FUNCTION 1
30 LOAD_DEREF 0 (s)
32 CALL_FUNCTION 2
34 LIST_APPEND 2
36 JUMP_ABSOLUTE 4
>> 38 RETURN_VALUE
可以看到（同样由@abarnert 建议）g 的内部循环包含一些额外的成本：
- （隐藏）迭代器在
d.items() 上构造 2-uples
- 一个
UNPACK_SEQUENCE 2解压那些 2-uples 然后把k和v放在堆栈上 - 两个
STORE_FAST从堆栈中弹出k和v以将它们存储在co_varnames.
在最终加载 k 之前将其与 s 进行比较，如 f 中所示。这个内部循环被迭代 |lst|*|d| 并且似乎这些操作有所不同。
如果像我想的那样优化，d.items() 迭代器会首先将 k 放入堆栈以测试 k in s，然后，仅当 [=45] =] 为真，将 v 放入 YIELD_VALUE.
您已经获得了有关评估列表理解的代码的所有详细信息。
但是列表推导等同于创建然后调用一个函数。 （这就是它们有自己的作用域的方式，所以它们不会，例如，将循环变量泄漏到外部作用域中。）因此，名为 <listcomp> 的 automatically-generated 函数才是您真正想要看到的代码对于.
如果你想反汇编它——好吧，请注意 LOAD_CONST 0 说它正在加载 <code object <listcomp> at 0x7f8e302038a0？那就是你想要的。但是我们做不到，因为我们所做的只是为了反汇编而编译一个字符串，然后丢弃结果，所以 listcomp 函数不再存在了。
但是用真实的代码很容易看出来：
>>> def f():
... return [next((v for k,v in d.items() if k in s), s) for s in lst]
>>> dis.dis(f)
2 0 LOAD_CONST 1 (<code object <listcomp> at 0x11da9c660, file "<ipython-input-942-698335d58585>", line 2>)
2 LOAD_CONST 2 ('f.<locals>.<listcomp>')
4 MAKE_FUNCTION 0
6 LOAD_GLOBAL 0 (lst)
8 GET_ITER
10 CALL_FUNCTION 1
12 RETURN_VALUE
又是那个代码对象 const——但现在它不仅仅是我们编译后立即丢弃的 const，它是我们可以访问的函数的一部分。
我们如何访问它？好吧，这在 inspect 模块文档中有记录，这可能不是您首先要看的地方。函数在其 __code__ 成员中有一个代码对象，代码对象在其 co_consts 成员中有一系列常量，我们正在寻找常量 #1，因此：
>>> dis.dis(f.__code__.co_consts[1])
2 0 BUILD_LIST 0
2 LOAD_FAST 0 (.0)
>> 4 FOR_ITER 32 (to 38)
6 STORE_DEREF 0 (s)
8 LOAD_GLOBAL 0 (next)
10 LOAD_CLOSURE 0 (s)
12 BUILD_TUPLE 1
14 LOAD_CONST 0 (<code object <genexpr> at 0x11dd20030, file "<ipython-input-942-698335d58585>", line 2>)
16 LOAD_CONST 1 ('f.<locals>.<listcomp>.<genexpr>')
18 MAKE_FUNCTION 8
20 LOAD_GLOBAL 1 (d)
22 LOAD_ATTR 2 (items)
24 CALL_FUNCTION 0
26 GET_ITER
28 CALL_FUNCTION 1
30 LOAD_DEREF 0 (s)
32 CALL_FUNCTION 2
34 LIST_APPEND 2
36 JUMP_ABSOLUTE 4
>> 38 RETURN_VALUE
当然，您有一个生成器表达式嵌套在您的列表推导式中，而且，正如您可能猜到的那样，这也等同于创建然后调用一个生成器函数。但是生成器函数的代码很容易找到（如果输入起来更乏味）：f.__code__.co_consts[1].co_consts[0].