Python 的 sum 与 NumPy 的 numpy.sum

2025-04-17 09:02:00
admin
原创
17
摘要：问题描述：sum使用 Python 的本机函数和 NumPy 的函数在性能和行为上有什么区别numpy.sum？sum适用于 NumPy 的数组，也numpy.sum适用于 Python 列表，它们都返回相同的有效结果（尚未测试溢出等边缘情况），但类型不同。>>> import numpy ...

问题描述：

sum使用 Python 的本机函数和 NumPy 的函数在性能和行为上有什么区别numpy.sum？sum适用于 NumPy 的数组，也numpy.sum适用于 Python 列表，它们都返回相同的有效结果（尚未测试溢出等边缘情况），但类型不同。

>>> import numpy as np
>>> np_a = np.array(range(5))
>>> np_a
array([0, 1, 2, 3, 4])
>>> type(np_a)
<class 'numpy.ndarray')

>>> py_a = list(range(5))
>>> py_a
[0, 1, 2, 3, 4]
>>> type(py_a)
<class 'list'>

# The numerical answer (10) is the same for the following sums:
>>> type(np.sum(np_a))
<class 'numpy.int32'>
>>> type(sum(np_a))
<class 'numpy.int32'>
>>> type(np.sum(py_a))
<class 'numpy.int32'>
>>> type(sum(py_a))
<class 'int'>

编辑：我认为我这里的实际问题是使用numpy.sumPython 整数列表会比使用 Python 自己的更快吗sum？

此外，使用 Python 整数和标量分别意味着什么（包括性能）numpy.int32？例如，对于a += 1，如果 的类型a是 Python 整数还是 ，在行为或性能上是否存在差异？我很好奇，对于在 Python 代码中经常被加减的值，numpy.int32使用 NumPy 标量数据类型是否更快。numpy.int32

为了澄清起见，我正在研究一个生物信息学模拟，其中部分内容是将多维numpy.ndarray数据折叠成单个标量和，然后再进行其他处理。我使用的是 Python 3.2 和 NumPy 1.6。

解决方案 1：

我很好奇并计算了时间。numpy.sum对于 numpy 数组来说似乎要快得多，但对于列表来说要慢得多。

import numpy as np
import timeit

x = range(1000)
# or 
#x = np.random.standard_normal(1000)

def pure_sum():
    return sum(x)

def numpy_sum():
    return np.sum(x)

n = 10000

t1 = timeit.timeit(pure_sum, number = n)
print 'Pure Python Sum:', t1
t2 = timeit.timeit(numpy_sum, number = n)
print 'Numpy Sum:', t2

结果如下x = range(1000)：

Pure Python Sum: 0.445913167735
Numpy Sum: 8.54926219673

结果如下x = np.random.standard_normal(1000)：

Pure Python Sum: 12.1442425643
Numpy Sum: 0.303303771848

我正在使用 Python 2.7.2 和 Numpy 1.6.1

解决方案 2：

[...] 我的 [...] 问题是，使用numpy.sumPython 整数列表会比使用 Python 自己的更快吗sum？

这个问题的答案是：不。

Python 的 sum 函数在列表上计算速度更快，而 NumPy 的 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 列表。请注意，这是对数-对数图，因为基准测试涵盖的值范围很广。但对于定性结果而言：值越低越好。

这表明，对于列表，Pythonsum总是更快np.sum，而sum数组上的方法会更快（除了非常短的数组，Pythonsum更快）。

为了方便您比较这些内容，我还制作了一个包含所有内容的图表：

f, ax = plt.subplots(1)
b_array.plot(ax=ax)
b_list.plot(ax=ax)
ax.grid(which='both')

在此处输入图片描述

有趣的是，数组与 Python 和列表竞争的点numpy大约在 200 个元素左右！请注意，这个数字可能取决于很多因素，例如 Python/NumPy 版本……不要太过于字面化。

尚未提及的是造成这种差异的原因（我指的是大规模差异，而不是短列表/数组的差异，因为短列表/数组的函数只是具有不同的常量开销）。假设在 CPython 中，一个 Python 列表是对指向 Python 对象（在本例中为 Python 整数）的 C（即 C 语言）指针数组的包装。这些整数可以看作是对 C 整数的包装（实际上并不正确，因为 Python 整数可以任意大，所以不能简单地使用一个C 整数，但这个数字已经足够接近了）。

例如，像这样的列表[1, 2, 3]将（在示意图中，我省略了一些细节）存储如下：

在此处输入图片描述

然而，NumPy 数组是包含 C 值的 C 数组的包装器（在这种情况下int取long​​决于 32 位或 64 位，并取决于操作系统）。

因此 NumPy 数组np.array([1, 2, 3])看起来像这样：

在此处输入图片描述

接下来要了解的是这些函数是如何工作的：

  • Pythonssum迭代可迭代对象（在本例中为列表或数组）并添加所有元素。

  • NumPyssum 方法遍历存储的 C 数组并添加这些 C 值，最后将该值包装在 Python 类型中（在本例中为numpy.int32（或numpy.int64））并返回它。

  • NumPyssum 函数将输入转换为array（至少如果它还不是数组），然后使用 NumPysum 方法。

显然，从 C 数组添加 C 值比添加 Python 对象要快得多，这就是 NumPy 函数可以更快的原因（参见上面的第二张图，对于大型数组，数组上的 NumPy 函数远远胜过 Python 的总和）。

但是将 Python 列表转换为 NumPy 数组相对较慢，而且还需要添加 C 值。这就是为什么对于列表来说， Pythonsum会更快。

唯一悬而未决的问题是，为什么 Python 的 sum 函数如此之sum慢array（它是所有比较函数中最慢的）。这实际上与 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速度更快，因此每次循环的开销更少。因为我只关心加减运算的时间，所以实际上最好不要让循环开销影响时间（至少不要影响太多）。

解决方案 3：

请注意，Python 对多维 numpy 数组的求和将仅沿第一个轴执行求和：

sum(np.array([[[2,3,4],[4,5,6]],[[7,8,9],[10,11,12]]]))
Out[47]: 
array([[ 9, 11, 13],
       [14, 16, 18]])

np.sum(np.array([[[2,3,4],[4,5,6]],[[7,8,9],[10,11,12]]]), axis=0)
Out[48]: 
array([[ 9, 11, 13],
       [14, 16, 18]])

np.sum(np.array([[[2,3,4],[4,5,6]],[[7,8,9],[10,11,12]]]))
Out[49]: 81

解决方案 4：

Numpy 应该更快，特别是当你的数据已经是一个 numpy 数组时。

Numpy 数组是标准 C 数组上的一层薄层。当 Numpy sum 迭代它时，它不会进行类型检查，而且速度非常快。其速度应该与使用标准 C 进行操作相当。

相比之下，使用 Python 的 sum 函数，它必须先将 NumPy 数组转换为 Python 数组，然后再迭代该数组。它必须进行一些类型检查，因此速度通常会更慢。

python sum 比 numpy sum 慢的具体量尚不明确，因为与在 python 中编写自己的 sum 函数相比，python sum 将是一个经过某种程度优化的函数。

解决方案 5：

这是Akavall 上述回答的扩展。从该回答中，您可以看到np.sum对于np.array对象，执行速度更快，而sum对于list对象，执行速度更快。进一步说明：

np.sum在为某个np.array目标奔跑与 sum为某个list目标奔跑时，他们的表现似乎不相上下。

# I'm running IPython

In [1]: x = range(1000) # list object

In [2]: y = np.array(x) # np.array object

In [3]: %timeit sum(x)
100000 loops, best of 3: 14.1 µs per loop

In [4]: %timeit np.sum(y)
100000 loops, best of 3: 14.3 µs per loop

上面的速度比稍微sum快一点，虽然有时我也看到 的时间。但大多数情况下，它是。np.array`np.sum14.1 µs14.3 µs`

解决方案 6：

如果你使用 sum()，那么它会给出

a = np.arange(6).reshape(2, 3)
print(a)
print(sum(a))
print(sum(sum(a)))
print(np.sum(a))


>>>
[[0 1 2]
 [3 4 5]]
[3 5 7]
15
15
相关推荐
置顶 政府信创国产化的10大政策解读
政府信创国产化的10大政策解读
  政府信创国产化的10大政策解读一、信创国产化的背景与意义信创国产化，即信息技术应用创新国产化，是当前中国信息技术领域的一个重要发展方向。其核心在于通过自主研发和创新，实现信息技术应用的自主可控，减少对外部技术的依赖，并规避潜在的技术制裁和风险。随着全球信息技术竞争的加剧，以及某些国家对中国在科技领域的打压，信创国产化显...
工程项目管理   2482  
置顶 2025年20款好用的项目管理软件推荐，项目管理提效的20个工具和技巧
2025年20款好用的项目管理软件推荐，项目管理提效的20个工具和技巧
  为什么项目管理通常仍然耗时且低效？您是否还在反复更新电子表格、淹没在便利贴中并参加每周更新会议？这确实是耗费时间和精力。借助软件工具的帮助，您可以一目了然地全面了解您的项目。如今，国内外有足够多优秀的项目管理软件可以帮助您掌控每个项目。什么是项目管理软件？项目管理软件是广泛行业用于项目规划、资源分配和调度的软件。它使项...
项目管理软件   1533  
如何避免PLM项目范围蔓延？3大管控策略
如何避免PLM项目范围蔓延？3大管控策略
  PLM（产品生命周期管理）项目对于企业优化产品研发流程、提升产品质量以及增强市场竞争力具有至关重要的意义。然而，在项目推进过程中，范围蔓延是一个常见且棘手的问题，它可能导致项目进度延迟、成本超支以及质量下降等一系列不良后果。因此，有效避免PLM项目范围蔓延成为项目成功的关键因素之一。以下将详细阐述三大管控策略，助力企业...
plm系统   0  
PLM项目管理如何量化风险优先级？五维评估矩阵应用指南
PLM项目管理如何量化风险优先级？五维评估矩阵应用指南
  PLM（产品生命周期管理）项目管理在企业产品研发与管理过程中扮演着至关重要的角色。随着市场竞争的加剧和产品复杂度的提升，PLM项目面临着诸多风险。准确量化风险优先级并采取有效措施应对，是确保项目成功的关键。五维评估矩阵作为一种有效的风险评估工具，能帮助项目管理者全面、系统地评估风险，为决策提供有力支持。五维评估矩阵概述...
免费plm软件   0  
PLM开发流程优化：2025年缺陷管理工具与六西格玛的7种组合应用
PLM开发流程优化：2025年缺陷管理工具与六西格玛的7种组合应用
  引言PLM（产品生命周期管理）开发流程对于企业产品的全生命周期管控至关重要。它涵盖了从产品概念设计到退役的各个阶段，直接影响着产品质量、开发周期以及企业的市场竞争力。在当今快速发展的科技环境下，客户对产品质量的要求日益提高，市场竞争也愈发激烈，这就使得优化PLM开发流程成为企业的必然选择。缺陷管理工具和六西格玛方法作为...
plm产品全生命周期管理   0  
热门文章
项目管理软件
政府信创国产化的10大政策解读
2025soft
2025年20款好用的项目管理软件推荐，项目管理提效的20个工具和技巧
img020
使用 Python 'Requests' 模块的代理
img044
10个项目管理常见问题解答：包括难点和解决方法
项目管理软件
项目延期的原因有哪些？如何有效预防和管理？
项目管理软件
5个成功案例解析项目进度管理的最佳实践
项目里程碑计划模板
项目里程碑计划模板怎么写?设定项目里程碑的5个方法
项目管理软件有哪些？
热门标签
更多>
IPD流程 项目管理 plm项目管理软件 敏捷开发 项目管理软件 Scrum 敏捷项目管理 IPD流程管理 项目风险管理 项目管理工具 项目经理 极限编程  产品管理  项目经理职责 项目路线图 项目进度管理 团队管理 测试管理工具 项目预算管理 PMP认证 瀑布式管理 项目范围管理 IT科技 项目管理平台 工程项目管理 项目资源管理 pmp证书考试
曾咪二维码

扫码咨询，免费领取项目管理大礼包！

云禅道AD
禅道项目管理软件

云端的项目管理软件

尊享禅道项目软件收费版功能

无需维护，随时随地协同办公

内置subversion和git源码管理

每天备份，随时转为私有部署

免费试用