Python字节码编译器；删除不必要的变量？

Question

考虑到以下情况：

def foo():
    x = a_method_returning_a_long_list()
    y = a_method_which_filters_a_list(x)
    return y

Python 的字节码编译器会保留 x & 吗？ y 在内存中，或者它是否足够聪明，可以将其简化为以下内容？

def foo():
   return a_method_which_filters_a_list(a_method_returning_a_long_list())

Answer 1

它将 x 和 y 保留在内存中：

import dis
dis.dis(foo)
  2           0 LOAD_GLOBAL              0 (a_method_returning_a_long_list)
              3 CALL_FUNCTION            0
              6 STORE_FAST               0 (x)

  3           9 LOAD_GLOBAL              1 (a_method_which_filters_a_list)
             12 LOAD_FAST                0 (x)
             15 CALL_FUNCTION            1
             18 STORE_FAST               1 (y)

  4          21 LOAD_FAST                1 (y)
             24 RETURN_VALUE

整个操作非常高效，因为它是使用 LOAD_FAST 和 STORE_FAST 代码完成的。

正如 Roadrunner-EX 在其中一条评论中所说，两个版本的 foo 使用的内存量基本相同，如 x 和 y 只是结果的引用（即指针）。

Answer 2

In [1]: import dis

In [2]: def f():
   ...:     x = f1()
   ...:     y = f2(x)
   ...:     return y
   ...: 

In [3]: dis.dis(f)
  2           0 LOAD_GLOBAL              0 (f1)
              3 CALL_FUNCTION            0
              6 STORE_FAST               0 (x)

  3           9 LOAD_GLOBAL              1 (f2)
             12 LOAD_FAST                0 (x)
             15 CALL_FUNCTION            1
             18 STORE_FAST               1 (y)

  4          21 LOAD_FAST                1 (y)
             24 RETURN_VALUE        

所以看起来这两个变量是分开保存的。

Answer 3

我不确定，但我猜这会让它们留在记忆中，原因有两个。首先，这样做可能付出的努力超过了其价值。无论哪种方式，都不会有巨大的性能变化。其次，变量 x 和 y 本身可能占用内存（以指针/引用的形式），由于赋值的显式性质，编译器不会触及这些内存。