函数闭包性能

Question

我认为替换这段代码可以提高性能：

def f(a, b):
  return math.sqrt(a) * b
result = []
a = 100
for b in range(1000000):
  result.append(f(a, b))

与：

def g(a):
  def f(b):
    return math.sqrt(a) * b
  return f
result = []
a = 100
func = g(a)
for b in range(1000000):
  result.append(func(b))

我假设由于在执行闭包时a 是固定的，解释器会预先计算涉及a 的所有内容，因此math.sqrt(a) 将只重复一次而不是1000000 次。

我的理解是否总是正确的，或者总是不正确的，或者是正确的/不正确的，取决于实现？

我注意到func 的代码对象是在运行时之前构建的（至少在 CPython 中），并且是不可变的。然后代码对象似乎使用全局环境来实现关闭。这似乎表明我希望的优化没有发生。

Answer 1

我假设由于在执行闭包时 a 是固定的，解释器会预先计算涉及 a 的所有内容，因此 math.sqrt(a) 只会重复一次，而不是 1000000 次。

这个假设是错误的，我不知道它来自哪里。闭包仅捕获变量绑定，在您的情况下，它捕获a 的值，但这并不意味着正在发生更多魔术：每次调用f 时仍会评估表达式math.sqrt(a)。

毕竟，它必须每次都被计算，因为解释器不知道sqrt 是“纯”的（返回值只取决于参数，没有副作用执行）。像您期望的优化在函数式语言中是实用的（引用透明性和静态类型在这里有很大帮助），但在 Python 中很难实现，Python 是一种命令式和动态类型的语言。

也就是说，如果你想预先计算 math.sqrt(a) 的值，你需要明确地这样做：

def g(a):
  s = math.sqrt(a)
  def f(b):
    return s * b
  return f

或者使用lambda:

def g(a): 
  s = math.sqrt(a)
  return lambda b: s * b

既然g 确实返回了一个带有 1 个参数的函数，那么您必须只使用一个参数来调用结果。

Answer 2

代码不是静态评估的；函数内部的代码还是每次都计算。函数对象包含表示函数中代码的所有字节码；它不评估任何一个。您可以通过计算一次昂贵的值来改善问题：

def g(a):
    root_a = math.sqrt(a)
    def f(b):
        return root_a * b
    return f
result = []
a = 100
func = g(a)
for b in range(1000000):
    result.append(func(b))

当然，在这个简单的示例中，您可以进一步提高性能：

a = 100
root_a = math.sqrt(a)
result = [root_a * b for b in range(1000000)]

但我认为您正在处理一个比无法扩展的更复杂的示例？

Answer 3

像往常一样，timeit 模块是您的朋友。尝试一些事情，看看效果如何。如果您不关心编写丑陋的代码，这可能也会有所帮助：

def g(a):
   def f(b,_local_func=math.sqrt):
      return _local_func(a)*b

显然，python 在尝试访问“全局”变量/函数时会降低性能。如果您可以在本地进行访问，您可以节省一点时间。