Python 等价于内联函数或宏

Question

我刚刚意识到，这样做

x.real*x.real+x.imag*x.imag

快三倍

abs(x)**2

比 x 是复数的 numpy 数组 。为了代码的可读性，我可以定义一个比

def abs2(x):
    return x.real*x.real+x.imag*x.imag

abs(x)**2 快得多的函数，但这是以函数调用为代价的。是否可以内联这样的函数，就像我在 C 中使用宏或使用 inline 关键字所做的那样？

Answer 1

是否可以内联这样的函数，就像我在 C 中使用宏或使用 inline 关键字所做的那样？

不。在到达这个特定指令之前，Python 解释器甚至不知道是否存在这样的函数，更不用说它做什么了。

正如评论中所指出的，PyPy 将自动内联（上面的内容仍然成立 - 它“简单地”在运行时生成优化版本，从中受益，但在它失效时打破它），尽管在此特定情况并没有帮助，因为在 PyPy 上实现 NumPy 刚刚开始不久，而且至今还不是 beta 级别。但底线是：不要担心 Python 中这个级别的优化。实现要么自行优化，要么不优化，这不是您的责任。

Answer 2

不完全是OP所要求的，但接近：

Inliner 内联 Python 函数调用。 此概念证明
博客
帖子

来自内联导入内联

@排队
def add_stuff(x, y):
    返回 x + y

def add_lots_of_numbers():
    结果=[]
    对于 xrange(10) 中的 i：
         结果.append(add_stuff(i, i+1))

在上面的代码中，add_lots_of_numbers函数被转换为
这个：

def add_lots_of_numbers():
    结果=[]
    对于 xrange(10) 中的 i：
         结果.append(i + i + 1)

此外，任何对这个问题以及在 CPython 中实现此类优化器所涉及的复杂性感兴趣的人，也可能想看看：

• bpo-10399：AST 优化：函数调用内联
• PEP 511 -- 代码转换器的 API（已拒绝）

Answer 3

我同意其他人的观点，即此类优化只会让您在 CPython 上感到痛苦，如果您关心性能，则应该考虑 PyPy（尽管我们的 NumPy 可能太不完整而无用）。然而，我不同意，并说你可以关心 PyPy 上的此类优化，而不是像所说的 PyPy 自动执行的那样，但如果你很了解 PyPy，你真的可以调整你的代码以使 PyPy 发出你想要的程序集，并不是说你几乎永远都需要这样做。

Answer 4

不。

最接近 C 宏的是一个脚本（awk 或其他），您可以将其包含在 makefile 中，并用长形式替换 python 脚本中的某种模式，例如 abs(x)**2 。

Answer 5

实际上，计算速度可能会更快，例如：

x.real** 2+ x.imag** 2

因此，函数调用的额外成本可能会减少。让我们看看：

In []: n= 1e4
In []: x= randn(n, 1)+ 1j* rand(n, 1)
In []: %timeit x.real* x.real+ x.imag* x.imag
10000 loops, best of 3: 100 us per loop
In []: %timeit x.real** 2+ x.imag** 2
10000 loops, best of 3: 77.9 us per loop

并将计算封装在函数中：

In []: def abs2(x):
   ..:     return x.real** 2+ x.imag** 2
   ..: 
In []: %timeit abs2(x)
10000 loops, best of 3: 80.1 us per loop

无论如何（正如其他人指出的那样）这种微优化（为了避免函数调用）并不是编写 Python 代码的真正有效的方法。

Answer 6

您可以尝试使用 lambda：

abs2 = lambda x : x.real*x.real+x.imag*x.imag

然后通过以下方式调用它：

y = abs2(x)

Answer 7

Python 是一种动态编程语言。幸运的是，Python 在执行之前会编译为字节码。所以你可以内联代码。对于不需要胖外部包的简单解决方案，您可以在内部函数中使用 Python：

from inspect import getsource

abs2 = lambda z : z.real * z.real + z.imag * z.imag

def loop (zz, zs):
  for z in zs:
    zz += abs2 (z)

print ( f"loop code:\n{getsource (loop)}" )

inlined = getsource (loop).replace ("abs2 (z)", getsource (abs2).split(":")[1] )

print ( f"inlined loop code:\n{inlined}" )

compiled = compile (inlined, '<string>', 'exec').co_code

def loop2 (zz, zs):
  for z in zs:
    zz += z.real * z.real + z.imag * z.imag

compiled2 = compile (getsource (loop2), '<string>', 'exec').co_code

print ( f"compiled loop  code: {compiled}" )
print ( f"compiled loop2 code: {compiled2}")

注意：这仅支持一行 lambda，其参数与传递的变量具有相同的名称。这是一个简单且非常 hackish 的解决方案，但 Python 并不是一种不支持实时代码编辑的解释器语言。