Python:使用 dis 分析列表理解

Question

最近，我有一个 discussion关于以下两段代码的 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 的内部循环包含一些额外的成本:

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 放在堆栈上以测试 s 中的 k ，然后，仅当 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] .