Python：用dis分析列表理解

Question

最近，我讨论了关于以下两段代码的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在列表lst和寻找s在一个字典d 。 如果找到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的内部循环包含一些额外的成本：

1. （隐藏）由d.items()上的迭代器构造的2-uples
2. 一个UNPACK_SEQUENCE 2解包那些2-uples然后将k和v放在堆栈上
3. 两个STORE_FAST从堆栈中弹出k和v以将它们存储在co_varnames 。

之前，最后装入k可进行对比的s在f 。 这个内循环迭代|lst|*|d| 似乎那些行动有所不同。

如果按照我的想法进行了优化，那么d.items()迭代器会在堆栈中放置第一个k来测试k in s ，然后，只有当k in s为真时，才将v放在堆栈上为YIELD_VALUE 。

Answer 1

您已经获得了有关评估列表理解的代码的所有详细信息。

但是列表推导等同于创建然后调用函数。 （这是他们有自己的范围，所以他们不会，例如，将循环变量泄漏到外部范围。）因此，自动生成的名为<listcomp>函数是您真正想要查看的代码。

如果你想要反汇编它，请注意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] 。