python - python会重用重复的计算结果吗？

Question

如果我希望在 Python 中计算一个表达式，例如下面代码片段中的 r 表达式，Python 解释器会聪明地重用子结果 x+ y+z，或者只计算两次？我也有兴趣知道这个问题的答案对于编译语言是否相同，例如C.

x = 1
y = 2
z = 3
r = (x+y+z+1) + (x+y+z+2)

有人建议这个问题类似于this question 。我相信这是相似的。然而，我相信链接的问题并不是一个“最小的例子”。此外，在链接的问题中，操作顺序没有歧义，例如，在与此问题类似的示例中，没有定义的操作顺序(数学上)，具体取决于各个函数调用的顺序(它们是不明确)，可能会完成更差或更好的优化工作。考虑 (abba)(abba)(baa*b)，存在嵌套的重复子字符串，并且根据预处理的顺序和数量，可以执行许多不同的优化。

Answer 1

您可以使用 dis.dis 进行检查。输出为:

  2           0 LOAD_CONST               0 (1)
              2 STORE_NAME               0 (x)

  3           4 LOAD_CONST               1 (2)
              6 STORE_NAME               1 (y)

  4           8 LOAD_CONST               2 (3)
             10 STORE_NAME               2 (z)

  5          12 LOAD_NAME                0 (x)
             14 LOAD_NAME                1 (y)
             16 BINARY_ADD
             18 LOAD_NAME                2 (z)
             20 BINARY_ADD
             22 LOAD_CONST               0 (1)
             24 BINARY_ADD
             26 LOAD_NAME                0 (x)
             28 LOAD_NAME                1 (y)
             30 BINARY_ADD
             32 LOAD_NAME                2 (z)
             34 BINARY_ADD
             36 LOAD_CONST               1 (2)
             38 BINARY_ADD
             40 BINARY_ADD
             42 STORE_NAME               3 (r)
             44 LOAD_CONST               3 (None)
             46 RETURN_VALUE

因此它不会缓存括号中表达式的结果。尽管对于特定情况这是可能的，但一般来说这是不可能的，因为自定义类可以定义 __add__ (或任何其他二元运算)来修改自身。例如:

class Foo:
    def __init__(self, value):
        self.value = value

    def __add__(self, other):
        self.value += 1
        return self.value + other

x = Foo(1)
y = 2
z = 3
print(x + y + z + 1)  # prints 8
print(x + y + z + 1)  # prints 9

如果您有一个昂贵的函数并希望缓存其结果，您可以通过 functools.lru_cache 来实现。例如。

另一方面，编译器会执行 constant folding从下面的例子可以看出:

>>> import dis
>>> dis.dis("x = 'abc' * 5")
  1           0 LOAD_CONST               0 ('abcabcabcabcabc')
              2 STORE_NAME               0 (x)
              4 LOAD_CONST               1 (None)
              6 RETURN_VALUE
>>> dis.dis("x = 1 + 2 + 3 + 4")
  1           0 LOAD_CONST               0 (10)
              2 STORE_NAME               0 (x)
              4 LOAD_CONST               1 (None)
              6 RETURN_VALUE