python - 这种内部 Python 优化如何用于数学表达式？

Question

这是一道优化题。我在函数内部有一个表达式，如下所示:

>>> def x():
...     num = 2 * 4 * 100 * 20
...
>>> x.__code__.co_consts
(None, 2, 4, 100, 20, 8, 800, 16000)

表达式 2 * 4 * 100 * 20 的结果是 16000，所以如果我们反汇编 x:

>>> dis.dis(x)
  2           0 LOAD_CONST               7 (16000)
              3 STORE_FAST               0 (x)
              6 LOAD_CONST               0 (None)
              9 RETURN_VALUE       

16000 几乎是所需要的。 co_consts 存储 8 和 800 技术上不再需要我们有总数还是它们？

将上面的表达式与另一个表达式进行比较:

>>> def x():
...     num = 3 + 4 + 9  * 4
... 
>>> x.__code__.co_consts
(None, 3, 4, 9, 7, 36)

看起来字节码编译器接受二进制操作数并存储它们的计算值:

9 * 4   36 
3 + 4   7 

反汇编函数:

>>> dis.dis(x)
  2           0 LOAD_CONST               4 (7)
              3 LOAD_CONST               5 (36)
              6 BINARY_ADD          
              7 STORE_FAST               0 (num)
             10 LOAD_CONST               0 (None)
             13 RETURN_VALUE   

有趣的是，如果你采用这个表达式:2 + 5 * 8 - 5 + 23 * 4，co_consts 将是 (None, 2, 5, 8, 23, 4, 40, 92) 仅计算了乘法:5 * 8 和 23 * 4 忽略了加法和减法。

这种优化是如何真正起作用的？我只在 2.7 上测试过这个。

Answer 1

没有任何解释 ;-) 这意味着它是一个完全反射(reflect)实现细节的黑暗角落。不管是好是坏，负责的“窥孔优化器”不是在程序的解析树上工作，而是在生成的字节代码上工作。这使用起来很笨拙，所以很难预测会发生什么，而且它会随着版本的不同而变化。例如，这里在 Python 3.6.1 下:

>>> def f():
...     return 2 + 5 * 8 - 5 + 23 * 4
>>> f.__code__.co_consts
(None, 2, 5, 8, 23, 4, 40, 42, 37, 92, 129)
>>> import dis
>>> dis.dis(f)
  2           0 LOAD_CONST              10 (129)
              2 RETURN_VALUE

所以表达式被折叠成它的最终值，但所有中间值都留在常量元组中。

@COLDSPEED 已经在他们的评论中链接到源代码，关于它的任何问题的唯一真正答案必须来自盯着你的 CPython 版本中使用的 peephole.c重新运行。随着时间的推移，它慢慢变得更加雄心勃勃，但背后并没有真正的计划。