如果单个整数具有 python-native int 类型，则更快地将单个整数添加到 numpy 数组

问：

我将一个整数添加到具有 1000 个元素的整数数组中。当我第一次将单个整数从 python-native 强制转换为 python-native 时，这快了 25%。numpy.int64int

为什么？作为一般经验法则，我是否应该将单个数字转换为本机 python 格式，以便使用大约此大小的数组进行单数字到数组的操作？

注意：可能与我之前的问题有关 如果数字具有 python-native 复数类型，则复数共轭速度要快得多。

import numpy as np

nnu = 10418
nnu_use = 5210
a = np.random.randint(nnu,size=1000)
b = np.random.randint(nnu_use,size=1)[0]

%timeit a + b                            # --> 3.9 µs ± 19.9 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
%timeit a + int(b)                       # --> 2.87 µs ± 8.07 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

请注意，标量到标量运算的加速也可能是巨大的（系数 50），如下所示：

np.random.seed(100)

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

%timeit a * (b - b.conjugate() * c)                # 6.48 µs ± 49.7 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
%timeit a_native * (b - b.conjugate() * c_native)  # 283 ns ± 7.78 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
%timeit a * b                                      # 5.07 µs ± 17.7 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
%timeit a_native * b                               # 94.5 ns ± 0.868 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

更新：难道最新的 numpy 版本修复了速度差异吗？numpy 的发行说明提到标量运算现在快得多，参见 https://numpy.org/devdocs/release/1.23.0-notes.html#performance-improvements-and-changes 和 https://github.com/numpy/numpy/pull/21188。我正在使用 .1.23python 3.7.6, numpy 1.21.2