Python原生complex与numpy.complex128共轭运算速度差异原因探究

测试结果总结 #

测试显示：

• 共轭运算：Python原生complex比numpy.complex128快约30倍
• 绝对值运算：两者耗时相近
• 实部/虚部提取：原生complex仅快约3倍

测试代码及结果：

import numpy as np

np.random.seed(100)

a = (np.random.rand(1) + 1j*np.random.rand(1))[0]
b = complex(a)

%timeit a.conjugate() # 2.95 µs ± 24 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
%timeit a.conj()      # 2.86 µs ± 14.2 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
%timeit b.conjugate() # 82.8 ns ± 1.28 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
%timeit abs(a)        # 112 ns ± 1.7 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
%timeit abs(b)        # 99.6 ns ± 0.623 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
%timeit a.real        # 145 ns ± 0.259 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
%timeit b.real        # 54.8 ns ± 0.121 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
%timeit a.imag        # 144 ns ± 0.771 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
%timeit b.imag        # 55.4 ns ± 0.297 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

共轭运算速度差距悬殊的原因 #

• 设计定位差异：numpy的complex128是为数组批量操作优化的，单个元素调用方法时，会触发额外的C层包装开销——比如维度检查、类型验证、数组上下文初始化，这些都是针对批量操作设计的，单个元素调用时完全冗余。而Python原生complex是内置标量类型，conjugate()操作仅需简单翻转虚部符号，无额外上下文检查，执行路径极短。
• 方法实现层级：numpy的conjugate()/conj()是数组方法，即使调用单个元素，也会走数组方法的完整调用流程，涉及Python对象与numpy内部结构的多次转换；而原生complex的方法直接在Python解释器底层实现，调用开销极低。

超10^6次迭代时是否应转换为原生complex？ #

分两种情况判断：

• 如果是逐个元素处理：转换是划算的。假设每次共轭运算原生比numpy快约2.7µs，1e6次可节省约2.7秒；单个元素转换为complex的开销仅几十纳秒，1e6次总转换开销约0.1秒，净收益明显。
• 优先选择向量化操作：numpy的核心优势是批量处理，若你是对大型复数数组做共轭运算，不要逐个元素提取再处理，直接调用数组的arr.conj()方法——批量操作会把整个数组的计算压到C层完成，完全避免Python循环的开销，速度远快于逐个转换原生complex再运算。

内容的提问来源于stack exchange，提问作者silence_of_the_lambdas