为什么这两个函数在下反汇编时具有相同的字节码dis.dis？

Question

下面是四个具有相同输出的函数，但是它们要么是用列表理解编写的，要么是紧循环，还有一个对vs的内联条件的函数调用。

有趣的是，a和{}在反汇编时有相同的字节码，但是b比{}快得多。

此外，d，它使用一个没有函数调用的紧循环，比使用列表理解和函数调用的a快。

为什么函数a和b有相同的字节码，为什么b的性能比给定的相同字节码好得多？

import dis

def my_filter(n):
    return n < 5

def a():
    # list comprehension with function call
    return [i for i in range(10) if my_filter(i)]

def b():
    # list comprehension without function call
    return [i for i in range(10) if i < 5]

def c():
    # tight loop with function call
    values = []
    for i in range(10):
        if my_filter(i):
            values.append(i)
    return values

def d():
    # tight loop without function call
    values = []
    for i in range(10):
        if i < 5:
            values.append(i)
    return values

assert a() == b() == c() == d()

import sys
>>> sys.version_info[:]
(3, 6, 5, 'final', 0)

# list comprehension with function call
>>> dis.dis(a)
  2           0 LOAD_CONST               1 (<code object <listcomp> at 0x00000211CBE8B300, file "<stdin>", line 2>)
              2 LOAD_CONST               2 ('a.<locals>.<listcomp>')
              4 MAKE_FUNCTION            0
              6 LOAD_GLOBAL              0 (range)
              8 LOAD_CONST               3 (10)
             10 CALL_FUNCTION            1
             12 GET_ITER
             14 CALL_FUNCTION            1
             16 RETURN_VALUE

# list comprehension without function call
>>> dis.dis(b)
  2           0 LOAD_CONST               1 (<code object <listcomp> at 0x00000211CBB64270, file "<stdin>", line 2>)
              2 LOAD_CONST               2 ('b.<locals>.<listcomp>')
              4 MAKE_FUNCTION            0
              6 LOAD_GLOBAL              0 (range)
              8 LOAD_CONST               3 (10)
             10 CALL_FUNCTION            1
             12 GET_ITER
             14 CALL_FUNCTION            1
             16 RETURN_VALUE

# a and b have the same byte code?
# Why doesn't a have a LOAD_GLOBAL (my_filter) and CALL_FUNCTION?
# c below has both of these    

# tight loop with function call
>>> dis.dis(c)
  2           0 BUILD_LIST               0
              2 STORE_FAST               0 (values)

  3           4 SETUP_LOOP              34 (to 40)
              6 LOAD_GLOBAL              0 (range)
              8 LOAD_CONST               1 (10)
             10 CALL_FUNCTION            1
             12 GET_ITER
        >>   14 FOR_ITER                22 (to 38)
             16 STORE_FAST               1 (i)

  4          18 LOAD_GLOBAL              1 (my_filter)
             20 LOAD_FAST                1 (i)
             22 CALL_FUNCTION            1
             24 POP_JUMP_IF_FALSE       14

  5          26 LOAD_FAST                0 (values)
             28 LOAD_ATTR                2 (append)
             30 LOAD_FAST                1 (i)
             32 CALL_FUNCTION            1
             34 POP_TOP
             36 JUMP_ABSOLUTE           14
        >>   38 POP_BLOCK

  6     >>   40 LOAD_FAST                0 (values)
             42 RETURN_VALUE

# tight loop without function call
>>> dis.dis(d)
  2           0 BUILD_LIST               0
              2 STORE_FAST               0 (values)

  3           4 SETUP_LOOP              34 (to 40)
              6 LOAD_GLOBAL              0 (range)
              8 LOAD_CONST               1 (10)
             10 CALL_FUNCTION            1
             12 GET_ITER
        >>   14 FOR_ITER                22 (to 38)
             16 STORE_FAST               1 (i)

  4          18 LOAD_FAST                1 (i)
             20 LOAD_CONST               2 (5)
             22 COMPARE_OP               0 (<)
             24 POP_JUMP_IF_FALSE       14

  5          26 LOAD_FAST                0 (values)
             28 LOAD_ATTR                1 (append)
             30 LOAD_FAST                1 (i)
             32 CALL_FUNCTION            1
             34 POP_TOP
             36 JUMP_ABSOLUTE           14
        >>   38 POP_BLOCK

  6     >>   40 LOAD_FAST                0 (values)
             42 RETURN_VALUE

import timeit

>>> timeit.timeit(a)  # list comprehension with my_filter
1.2435139456834463
>>> timeit.timeit(b)  # list comprehension without my_filter
0.6717423789164627
>>> timeit.timeit(c)  # no list comprehension with my_filter
1.326850592144865
>>> timeit.timeit(d)  # no list comprehension no my_filter
0.7743895521070954

为什么a和{}在反汇编时具有相同的字节码？我本来希望b有更好的字节码。值得注意的是，我认为a需要一个LOAD_GLOBAL ? (my_filter)和一个CALL FUNCTION。例如，c与a相同，但没有列表理解，它使用这些字节码这些地址18和22。

然而，即使使用相同的字节码，b也比a好得多。这是怎么回事？

更有趣的是，d使用了一个紧循环，但没有调用my_filter，它比使用列表理解但调用my_filter的b快。看起来使用函数的开销超过了紧循环的开销。

我的目标是想弄清楚是否可以将列表理解的条件分解成一个函数，使列表理解更容易阅读。

Answer 1

列表理解被转换为内部函数，因为它们构建了一个单独的命名空间。a和b中LC的内部函数不同：

>>> dis.dis(a.__code__.co_consts[1])
  3           0 BUILD_LIST               0
              2 LOAD_FAST                0 (.0)
        >>    4 FOR_ITER                16 (to 22)
              6 STORE_FAST               1 (i)
              8 LOAD_GLOBAL              0 (my_filter)
             10 LOAD_FAST                1 (i)
             12 CALL_FUNCTION            1
             14 POP_JUMP_IF_FALSE        4
             16 LOAD_FAST                1 (i)
             18 LIST_APPEND              2
             20 JUMP_ABSOLUTE            4
        >>   22 RETURN_VALUE
>>> dis.dis(b.__code__.co_consts[1])
  3           0 BUILD_LIST               0
              2 LOAD_FAST                0 (.0)
        >>    4 FOR_ITER                16 (to 22)
              6 STORE_FAST               1 (i)
              8 LOAD_FAST                1 (i)
             10 LOAD_CONST               0 (5)
             12 COMPARE_OP               0 (<)
             14 POP_JUMP_IF_FALSE        4
             16 LOAD_FAST                1 (i)
             18 LIST_APPEND              2
             20 JUMP_ABSOLUTE            4
        >>   22 RETURN_VALUE

在这里您可以看到a中的函数调用和b中的比较。在

Answer 2

请注意，a和b的字节码都只运行在别处定义的<listcomp>对象。在

2           0 LOAD_CONST               1 (<code object <listcomp> at 0x00000211CBE8B300, file "<stdin>", line 2>)

由于包装器函数a和{}是相同的，它们的字节码是相同的，只是listcomp的地址不同。在

在Python3.7中，dis模块还打印listcomp，下面是完整的代码和输出：

^{pr2}$

在

3.7.3 (default, May 19 2019, 21:16:26) 
[Clang 10.0.1 (clang-1001.0.46.4)]
                                   
  9           0 LOAD_CONST               1 (<code object <listcomp> at 0x1065c61e0, file "/w/test/x.py", line 9>)
              2 LOAD_CONST               2 ('a.<locals>.<listcomp>')
              4 MAKE_FUNCTION            0
              6 LOAD_GLOBAL              0 (range)
              8 LOAD_CONST               3 (10)
             10 CALL_FUNCTION            1
             12 GET_ITER
             14 CALL_FUNCTION            1
             16 RETURN_VALUE

Disassembly of <code object <listcomp> at 0x1065c61e0, file "/w/test/x.py", line 9>:
  9           0 BUILD_LIST               0
              2 LOAD_FAST                0 (.0)
        >>    4 FOR_ITER                16 (to 22)
              6 STORE_FAST               1 (i)
              8 LOAD_GLOBAL              0 (my_filter)
             10 LOAD_FAST                1 (i)
             12 CALL_FUNCTION            1
             14 POP_JUMP_IF_FALSE        4
             16 LOAD_FAST                1 (i)
             18 LIST_APPEND              2
             20 JUMP_ABSOLUTE            4
        >>   22 RETURN_VALUE
                                   
 13           0 LOAD_CONST               1 (<code object <listcomp> at 0x1066188a0, file "/w/test/x.py", line 13>)
              2 LOAD_CONST               2 ('b.<locals>.<listcomp>')
              4 MAKE_FUNCTION            0
              6 LOAD_GLOBAL              0 (range)
              8 LOAD_CONST               3 (10)
             10 CALL_FUNCTION            1
             12 GET_ITER
             14 CALL_FUNCTION            1
             16 RETURN_VALUE

Disassembly of <code object <listcomp> at 0x1066188a0, file "/w/test/x.py", line 13>:
 13           0 BUILD_LIST               0
              2 LOAD_FAST                0 (.0)
        >>    4 FOR_ITER                16 (to 22)
              6 STORE_FAST               1 (i)
              8 LOAD_FAST                1 (i)
             10 LOAD_CONST               0 (5)
             12 COMPARE_OP               0 (<)
             14 POP_JUMP_IF_FALSE        4
             16 LOAD_FAST                1 (i)
             18 LIST_APPEND              2
             20 JUMP_ABSOLUTE            4
        >>   22 RETURN_VALUE

对于Python<；3.7。见Python: analyze a list comprehension with dis