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

接下来是四个具有相同输出的函数，但是使用列表理解或紧密循环以及对vs内联条件的函数调用编写。

有趣的是，a并且b在反汇编时具有相同的字节码，但是b比快得多a。

此外，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在拆卸时具有相同的字节码？我本来希望b有更好看的字节码。值得注意的是，我会认为a需要a LOAD_GLOBAL ? (my_filter)和a CALL FUNCTION。例如，与列表理解c相同a但没有列表理解，它在地址18和22上使用这些字节码。

但是，即使使用相同的字节码，其b性能也比更好a。这里发生了什么？

甚至更有趣的是d，它使用紧密循环但没有调用my_filter，它比b使用列表推导但具有的调用要快my_filter。看起来使用函数的开销超过了紧密循环的开销。

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