【发布时间】：2018-03-31 10:32:57
【问题描述】：
最近，我在 SO 上有一个discussion（请参阅上下文）关于以下两段代码：
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) 快。因此，第二个问题：有人有解释吗？
编辑 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，然后，只有当k in s 为真时，才将v 放入YIELD_VALUE 的堆栈。
【问题讨论】：
-
如果你想知道哪个更快，在你的头脑中处理它很好，深入研究编译的实现很好，但最重要的是拿出一些基准数据（这与你的问题）和
timeit不同的实现。如果你认为你可以证明一个更快，但事实证明它更慢，那么你的证明可能是错误的。 （或者你是对的，一个是对数线性的，另一个是线性的，但事实证明，对于最大数据来说，150 的常数因子比对数 N 更重要……） -
@abarnert 我最感兴趣的是理论观点。正如您所指出的，
timeit的结果将取决于数据。但请参阅我对故事其余部分的编辑。 -
您可能需要创建一个单独的问题来询问为什么
f比g快（包括指向此的链接，以及您从timeit和阅读中发现的内容的摘要字节码）。这使问题集中在狭窄的范围内，这意味着理解算法问题但不知道字节码的人可以帮助回答它。此外，包含Faker的一些实现的 minimal reproducible example 意味着其他人可以在他们的系统上重复测试，逐步了解正在发生的事情等。 -
我会做的。 Faker 是pypi.python.org/pypi/Faker
-
我对性能差异的第一个猜测是
g在不进行哈希表查找时所节省的成本被构建额外的(k,v)元组的成本所抵消。在非病态情况下，字典查找为O(1)，并且常量开销非常小（对于字符串键，除非使用已弃用的 C API 构建，散列被缓存在结构中）。
标签： python performance list-comprehension disassembly