jfe*_*ard 4 python performance list-comprehension disassembly
最近，我对 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]
两者都迭代s列表中的字符串并在 dict 中lst查找。如果找到，则返回关联值，否则返回。我很确定第二段代码比第一段更快，因为（对于每个）字典中没有查找，只是对（键，值）对进行迭代。sdsss
问题是： 如何检查这是否真的发生在幕后？
我第一次尝试该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) 快。因此第二个问题：有人有解释吗？
编辑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()UNPACK_SEQUENCE 2解压这些 2-uples，然后将k和v放入堆栈STORE_FAST弹出k和将它们存储在 中。vco_varnames在它最终加载之前将其与中的k进行比较。这个内部循环是迭代的，看起来这些操作会产生影响。sf|lst|*|d|
如果按照我的想法进行了优化，d.items()迭代器将首先将 放入k堆栈中进行测试k in s，然后，只有当为k in strue 时，才将 放入v堆栈中YIELD_VALUE。
您已经获得了有关评估列表理解的代码的所有详细信息。
\n\n但列表推导式相当于创建然后调用函数。（这就是它们拥有自己的作用域的方式，因此它们不会将循环变量泄漏到外部作用域中。）因此，自动生成的名为 name 的函数<listcomp>就是您真正希望看到的代码。
如果你想反汇编它\xe2\x80\x94well，请注意LOAD_CONST 0它正在加载一个<code object <listcomp> at 0x7f8e302038a0？那就是你想要的。但我们无法做到这一点，因为我们所做的只是为了反汇编而编译一个字符串，然后丢弃结果，因此 listcomp 函数不再存在。
但用真实的代码很容易看出：
\n\n>>> def f():\n... return [next((v for k,v in d.items() if k in s), s) for s in lst]\n>>> dis.dis(f)\n 2 0 LOAD_CONST 1 (<code object <listcomp> at 0x11da9c660, file "<ipython-input-942-698335d58585>", line 2>)\n 2 LOAD_CONST 2 (\'f.<locals>.<listcomp>\')\n 4 MAKE_FUNCTION 0\n 6 LOAD_GLOBAL 0 (lst)\n 8 GET_ITER\n 10 CALL_FUNCTION 1\n 12 RETURN_VALUE\n又是那个代码对象 const\xe2\x80\x94，但现在它不仅仅是我们编译并立即丢弃的 const，它是我们可以访问的函数的一部分。
\n\n我们如何访问它？好吧，这记录在inspect模块文档中，这可能不是您首先查看的地方。函数的成员中有一个代码对象__code__，代码对象的成员中有一系列常量co_consts，我们正在寻找常量 #1，因此：
>>> dis.dis(f.__code__.co_consts[1])\n 2 0 BUILD_LIST 0\n 2 LOAD_FAST 0 (.0)\n >> 4 FOR_ITER 32 (to 38)\n 6 STORE_DEREF 0 (s)\n 8 LOAD_GLOBAL 0 (next)\n 10 LOAD_CLOSURE 0 (s)\n 12 BUILD_TUPLE 1\n 14 LOAD_CONST 0 (<code object <genexpr> at 0x11dd20030, file "<ipython-input-942-698335d58585>", line 2>)\n 16 LOAD_CONST 1 (\'f.<locals>.<listcomp>.<genexpr>\')\n 18 MAKE_FUNCTION 8\n 20 LOAD_GLOBAL 1 (d)\n 22 LOAD_ATTR 2 (items)\n 24 CALL_FUNCTION 0\n 26 GET_ITER\n 28 CALL_FUNCTION 1\n 30 LOAD_DEREF 0 (s)\n 32 CALL_FUNCTION 2\n 34 LIST_APPEND 2\n 36 JUMP_ABSOLUTE 4\n >> 38 RETURN_VALUE\n当然，您的列表理解中嵌套了一个生成器表达式，并且正如您可能猜到的那样，这也相当于创建然后调用生成器函数。但是该生成器函数的代码也很容易找到（如果输入起来更乏味的话）：f.__code__.co_consts[1].co_consts[0]。