python - python中的"Precompile"函数，编译时计算

Question

如果我们用Python编写一个函数，其执行依赖于已知的外部变量，Python每次仍然会检查它

我是说

def fun():
    return 1 if False else 5

每次调用此函数时都会重新检查此“False”

这可以通过简单的方式进行简单检查:

def pp(t, s):
    print(s)
    return t

def returner(t):
    return t if pp(True, "YAY") else 0

list(map(returner,[1,2,3,4,5]))

将打印“YAY”5次

是否有一种方法可以“预编译”函数，以便每次调用函数时都不会检查此类条件，而仅在编译时才检查

也就是说，一种告诉编译器“这个表达式在编译时已知，找出并替换它。

添加是为了回复 @Cepner 的帖子:

你是对的，但还有第三者:执行速度。

在您的示例中:

X = 5

def fun():
    return __precompute__(X * 5)

X = 7

我真的可以只写return 25，但是如果该函数是在另一个函数内定义的，并且其定义取决于传递给发生此定义的函数的参数，该怎么办？我无法立即手写返回值，因为我不知道传入的参数，但定义函数知道。

在这种情况下，假设编译时参数是传递给父函数的参数，并且它永远不会再改变。

示例

def parent(parent_1, parent_2, parent_3, parent_4, long_array):
    def child(x):
        s = 0
        if parent_1:
            s += x**2
        if parent_2:
            s += x**x
        if parent_3:
            s += 2*x
        if parent_4:
            s += 74
        return s

    return sum(list(map(child, long_array)))

这样的话，这些参数不会改变，每次检查都会花很长时间，根本无法完成

在“快速语言”中，例如C++，在这种情况下，子函数在程序执行过程中绝对无法被优化。但我们处理的是 Python，其中程序可以在运行时更改自身，因此理论上可以在运行时进行此类子函数的优化和编译。

我的问题是，有没有技术手段可以在运行时对函数进行这样的优化和编译？

Answer 1

识别可以在像 Python 这样的动态语言中安全地减少的表达式总是有成本的。例如，

X = 5

def fun():
    return X * 5

无法优化

def fun():
    return 25

没有进行整个程序分析来验证 X 从未被分配过不同的值。 Python 本身没有指定任何此类优化，但各个实现可以自由地添加他们认为合适的优化。例如，CPython 会优化某些常量表达式并消除某些条件下的死代码。您可以使用 dis 模块查看为给定函数生成的字节代码。

>>> def fun(): return 5*5
...
>>> dis.dis(fun)
  1           0 LOAD_CONST               1 (25)
              2 RETURN_VALUE

或

>>> def fun():
...     if False:
...         return 1
...     else:
...         return 5
...
>>> dis.dis(fun)
  5           0 LOAD_CONST               1 (5)
              2 RETURN_VALUE

条件表达式没有类似地优化。

>>> def fun():
...     return 1 if False else 5
...
>>> dis.dis(fun)
  2           0 LOAD_CONST               1 (False)
              2 POP_JUMP_IF_FALSE        8
              4 LOAD_CONST               2 (1)
              6 RETURN_VALUE
        >>    8 LOAD_CONST               3 (5)
             10 RETURN_VALUE

我怀疑这是因为优化器不想深入到表达式来识别死代码，而只是语句(存在于 AST 的更高级别)。您可以通过将 False 替换为可在编译时计算为 False 的表达式来停止优化，但优化器同样不会这样做。

>>> def fun():
...     if 3 == 5:
...         return 1
...     else: return 5
...
>>> dis.dis(fun)
  2           0 LOAD_CONST               1 (3)
              2 LOAD_CONST               2 (5)
              4 COMPARE_OP               2 (==)
              6 POP_JUMP_IF_FALSE       12

  3           8 LOAD_CONST               3 (1)
             10 RETURN_VALUE

  4     >>   12 LOAD_CONST               2 (5)
             14 RETURN_VALUE
             16 LOAD_CONST               0 (None)
             18 RETURN_VALUE

---

好吧，自动识别可以安全简化的代码是很困难的；也许有一种方法可以标记要简化的代码。但即使这样的语法仍然需要验证优化是否安全。考虑上面的第一个例子；你可以说优化X * 5是安全的，但是Python应该对以下内容做什么？

X = 5

def fun():
    return __precompute__(X * 5)

X = 7

如果您预先计算 fun，它将始终返回 25，即使您在 fun 之前更改了 X 的值code> 曾经被调用过。这只会使 fun 的定义变得困惑，如果您的意图是这样的话，您可以首先编写 return 25 。请记住，代码生成器受可以做什么的限制，而不是您打算做什么。

考虑到此类标记的代码仍然必须进行安全性分析，是否真的值得将语法复杂化以获取比自动优化更有用的东西？