[...] 我的 [...] 问题是在 Python 整数列表中使用 numpy.sum 会比使用 Python 自己的 sum 更快吗？
这个问题的答案是：没有。
Pythons sum 在列表上会更快，而 NumPys sum 在数组上会更快。我实际上做了一个基准测试来显示时间（Python 3.6，NumPy 1.14）：
import random
import numpy as np
import matplotlib.pyplot as plt
from simple_benchmark import benchmark
%matplotlib notebook
def numpy_sum(it):
return np.sum(it)
def python_sum(it):
return sum(it)
def numpy_sum_method(arr):
return arr.sum()
b_array = benchmark(
[numpy_sum, numpy_sum_method, python_sum],
arguments={2**i: np.random.randint(0, 10, 2**i) for i in range(2, 21)},
argument_name='array size',
function_aliases={numpy_sum: 'numpy.sum(<array>)', numpy_sum_method: '<array>.sum()', python_sum: "sum(<array>)"}
)
b_list = benchmark(
[numpy_sum, python_sum],
arguments={2**i: [random.randint(0, 10) for _ in range(2**i)] for i in range(2, 21)},
argument_name='list size',
function_aliases={numpy_sum: 'numpy.sum(<list>)', python_sum: "sum(<list>)"}
)
有了这些结果：
f, (ax1, ax2) = plt.subplots(1, 2, sharey=True)
b_array.plot(ax=ax1)
b_list.plot(ax=ax2)
左：在 NumPy 数组上；右：在 Python 列表中。
请注意，这是一个对数图，因为基准测试涵盖了非常广泛的值。但是对于定性结果：越低越好。
这表明对于列表，Pythons sum 总是更快，而 np.sum 或数组上的 sum 方法会更快（除了非常短的数组，其中 Pythons sum 更快）。
以防你有兴趣将它们相互比较，我还制作了一个包含所有这些的情节：
f, ax = plt.subplots(1)
b_array.plot(ax=ax)
b_list.plot(ax=ax)
ax.grid(which='both')
有趣的是，numpy 可以在数组上与 Python 和列表竞争的点大约是 200 个元素！请注意，这个数字可能取决于很多因素，例如 Python/NumPy 版本，...不要太字面意思。
没有提到的是这种差异的原因（我的意思是大规模差异，而不是短列表/数组的差异，其中函数只是具有不同的常量开销）。假设 CPython，Python 列表是 C（语言 C）指向 Python 对象（在本例中为 Python 整数）的指针数组的包装器。这些整数可以看作是 C 整数的包装器（实际上并不正确，因为 Python 整数可以任意大，因此它不能简单地使用 one C 整数，但它足够接近）。
例如，像[1, 2, 3] 这样的列表将（在示意图上，我省略了一些细节）这样存储：
然而，NumPy 数组是包含 C 值的 C 数组的包装器（在本例中为 int 或 long，具体取决于 32 位或 64 位并取决于操作系统）。
所以像np.array([1, 2, 3]) 这样的 NumPy 数组看起来像这样：
接下来要了解的是这些函数是如何工作的：
- Pythons
sum 迭代可迭代对象（在本例中为列表或数组）并添加所有元素。
- NumPys
sum method 遍历存储的 C 数组并添加这些 C 值，最后将该值包装在 Python 类型中（在本例中为 numpy.int32（或 numpy.int64）并返回它。
- NumPys
sum 函数 将输入转换为 array（至少如果它不是数组的话），然后使用 NumPy sum 方法.
显然，从 C 数组中添加 C 值比添加 Python 对象要快得多，这就是 NumPy 函数可以快得多的原因（参见上面的第二张图，数组上的 NumPy 函数优于到目前为止，对于大型数组，Python 总和）。
但是将 Python 列表转换为 NumPy 数组相对较慢，然后您仍然需要添加 C 值。这就是为什么对于 lists，Python sum 会更快。
剩下的唯一悬而未决的问题是，为什么 array 上的 Python 的 sum 这么慢（它是所有比较函数中最慢的）。这实际上与 Python 的 sum 简单地迭代您传入的任何内容这一事实有关。如果是列表，它会获取存储的 Python 对象，但如果是一维 NumPy 数组，则没有存储Python 对象，只是 C 值，因此 Python&NumPy 必须为每个元素创建一个 Python 对象（numpy.int32 或 numpy.int64），然后必须添加这些 Python 对象。为 C 值创建包装器使其变得非常慢。
此外，使用 Python 整数与标量 numpy.int32 有何影响（包括性能）？例如，对于 a += 1，如果 a 的类型是 Python 整数或 numpy.int32，是否存在行为或性能差异？
我做了一些测试，对于标量的加减法，你绝对应该坚持使用 Python 整数。尽管可能会进行一些缓存，这意味着以下测试可能并不完全具有代表性：
from itertools import repeat
python_integer = 1000
numpy_integer_32 = np.int32(1000)
numpy_integer_64 = np.int64(1000)
def repeatedly_add_one(val):
for _ in repeat(None, 100000):
_ = val + 1
%timeit repeatedly_add_one(python_integer)
3.7 ms ± 71.2 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
%timeit repeatedly_add_one(numpy_integer_32)
14.3 ms ± 162 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
%timeit repeatedly_add_one(numpy_integer_64)
18.5 ms ± 494 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
def repeatedly_sub_one(val):
for _ in repeat(None, 100000):
_ = val - 1
%timeit repeatedly_sub_one(python_integer)
3.75 ms ± 236 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
%timeit repeatedly_sub_one(numpy_integer_32)
15.7 ms ± 437 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
%timeit repeatedly_sub_one(numpy_integer_64)
19 ms ± 834 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
使用 Python 整数进行标量运算比使用 NumPy 标量快 3-6 倍。我没有检查为什么会这样，但我的猜测是 NumPy 标量很少使用并且可能没有针对性能进行优化。
如果您实际执行两个操作数都是 numpy 标量的算术运算，则差异会变得更小：
def repeatedly_add_one(val):
one = type(val)(1) # create a 1 with the same type as the input
for _ in repeat(None, 100000):
_ = val + one
%timeit repeatedly_add_one(python_integer)
3.88 ms ± 273 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
%timeit repeatedly_add_one(numpy_integer_32)
6.12 ms ± 324 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
%timeit repeatedly_add_one(numpy_integer_64)
6.49 ms ± 265 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
那么它只慢了 2 倍。
如果您想知道为什么我在这里使用itertools.repeat，而我本来可以简单地使用for _ in range(...)。原因是repeat 更快，因此每个循环产生的开销更少。因为我只对加/减时间感兴趣，所以实际上最好不要让循环开销干扰时间（至少不是那么多）。