Pythoncumsum函数详解与使用方法

目前golang学习网上已经有很多关于文章的文章了，自己在初次阅读这些文章中，也见识到了很多学习思路；那么本文《Python中cumsum函数使用教程》，也希望能帮助到大家，如果阅读完后真的对你学习文章有帮助，欢迎动动手指，评论留言并分享~

在Python中计算数据累积和，最常用的方法是使用NumPy的cumsum函数或Pandas的cumsum方法。1. NumPy的cumsum支持多维数组操作，默认展平数组进行累加，也可通过axis参数指定轴向，如axis=0按列累加、axis=1按行累加；2. Pandas的cumsum适用于Series和DataFrame，保留索引与列名，便于表格数据分析，并支持skipna参数处理缺失值及groupby结合实现分组累积求和；3. 性能方面，NumPy和Pandas的cumsum基于C语言实现，高效稳定，是首选方案，仅在特定简单场景下可考虑itertools.accumulate等替代方式。

Python中计算数据累积和，最常用也最便捷的方式就是利用NumPy库的cumsum函数，或者在处理表格数据时，使用Pandas库的DataFrame或Series对象自带的cumsum方法。它们能高效地对数组或序列中的元素进行逐个累加，并返回一个新数组或序列，其中每个元素是原数组从开头到当前位置所有元素的总和。

解决方案

在Python中，要实现数据的累积和计算，NumPy和Pandas库提供了极其方便且高效的cumsum函数。这几乎是我在数据分析工作中处理序列累加时，不假思索就会选择的方法。

使用NumPy的cumsum：

NumPy的ndarray对象本身就支持cumsum方法，或者你可以直接调用numpy.cumsum()函数。它会沿着指定的轴（默认为展平后的数组）计算累积和。

import numpy as np

# 1D数组的累积和
data_1d = np.array([1, 2, 3, 4, 5])
cumulative_sum_1d = np.cumsum(data_1d)
print("1D数组累积和:", cumulative_sum_1d)
# 输出: 1D数组累积和: [ 1  3  6 10 15]

# 2D数组的累积和（默认展平）
data_2d = np.array([[1, 2], [3, 4]])
cumulative_sum_2d_flat = np.cumsum(data_2d)
print("2D数组展平后累积和:", cumulative_sum_2d_flat)
# 输出: 2D数组展平后累积和: [ 1  3  6 10]

使用Pandas的cumsum：

Pandas的Series和DataFrame对象也内置了cumsum方法，这在处理表格数据时尤为方便。它能自动保留索引和列名，让结果更具可读性。

import pandas as pd

# Series的累积和
s = pd.Series([10, 20, 30, 40, 50])
cumulative_sum_s = s.cumsum()
print("\nSeries累积和:\n", cumulative_sum_s)
# 输出:
# Series累积和:
# 0     10
# 1     30
# 2     60
# 3    100
# 4    150
# dtype: int64

# DataFrame的累积和（默认按列，即axis=0）
df = pd.DataFrame({
    'A': [1, 2, 3],
    'B': [10, 20, 30],
    'C': [100, 200, 300]
})
cumulative_sum_df_col = df.cumsum()
print("\nDataFrame按列累积和:\n", cumulative_sum_df_col)
# 输出:
# DataFrame按列累积和:
#      A   B    C
# 0    1  10  100
# 1    3  30  300
# 2    6  60  600

这两种方法，无论是面对简单的数字序列，还是复杂的多维数据表，都能提供高效且直观的累积和计算能力。

NumPy cumsum函数在多维数组中的应用与轴向理解

我刚开始接触NumPy的axis参数时，确实有点绕，感觉它总是在玩“反直觉”的游戏。但一旦你理解了，axis其实就是指操作发生时，哪个维度会被“压缩”或者说“遍历”掉。对于多维数组，numpy.cumsum()的axis参数决定了累积和是按行计算还是按列计算，这在处理表格数据或图像数据时尤为关键。

• axis=0：沿着第一个轴（行）进行计算，结果的每一列是原数组对应列的累积和。可以理解为“向下”累加。
• axis=1：沿着第二个轴（列）进行计算，结果的每一行是原数组对应行的累积和。可以理解为“向右”累加。

import numpy as np

data_2d = np.array([
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
])

print("原始2D数组:\n", data_2d)

# 沿着axis=0（列方向）累积求和
cumsum_axis_0 = np.cumsum(data_2d, axis=0)
print("\n沿着axis=0累积和（按列累加）:\n", cumsum_axis_0)
# 解释：
# 第1列: [1, 1+4, 1+4+7] = [1, 5, 12]
# 第2列: [2, 2+5, 2+5+8] = [2, 7, 15]
# 第3列: [3, 3+6, 3+6+9] = [3, 9, 18]

# 沿着axis=1（行方向）累积求和
cumsum_axis_1 = np.cumsum(data_2d, axis=1)
print("\n沿着axis=1累积和（按行累加）:\n", cumsum_axis_1)
# 解释：
# 第1行: [1, 1+2, 1+2+3] = [1, 3, 6]
# 第2行: [4, 4+5, 4+5+6] = [4, 9, 15]
# 第3行: [7, 7+8, 7+8+9] = [7, 15, 24]

在实际应用中，比如你有一个记录了每天不同产品销售额的表格，如果想看每天每种产品的累计销售额，可能就需要axis=0。而如果你想看每天所有产品销售额的累计总和，那可能就需要先对行求和，再进行累积，或者考虑更复杂的聚合方式。理解这个轴向，是掌握NumPy多维操作的关键一步。

Pandas cumsum处理缺失值与分组累积求和的策略

很多时候，数据里总有那么些“空洞”，NaN就是其中之一。cumsum默认会把它们一路“传染”下去，这在某些场景下是合理的，但有时你可能希望跳过。而分组累积求和，这简直是数据分析的“瑞士之刃”，尤其在处理时间序列或者分类数据时，它能帮你快速看到每个组内部的累积趋势。

处理缺失值（NaN）：

Pandas的cumsum方法有一个skipna参数，默认是True，表示在计算过程中会跳过NaN值，并将NaN视为0进行累加，但结果中仍然保留NaN的位置。如果设置为False，那么遇到NaN后，后续的累积和都将是NaN。

import pandas as pd
import numpy as np

s_with_nan = pd.Series([10, 20, np.nan, 30, 40])

print("原始Series（含NaN）:\n", s_with_nan)

# skipna=True (默认行为): 跳过NaN，但NaN位置仍为NaN
cumsum_skipna_true = s_with_nan.cumsum(skipna=True)
print("\ncumsum(skipna=True):\n", cumsum_skipna_true)
# 解释：NaN位置依然是NaN，但后续的30是基于20累加的，而不是基于NaN。

# skipna=False: 遇到NaN后，后续都变为NaN
cumsum_skipna_false = s_with_nan.cumsum(skipna=False)
print("\ncumsum(skipna=False):\n", cumsum_skipna_false)
# 解释：一旦遇到NaN，累积过程就中断，后续都变成了NaN。

分组累积求和：

这是Pandas中非常强大的一个功能组合，通过groupby()方法结合cumsum()，可以实现对数据按某个或多个类别进行分组后，再在每个组内独立进行累积和计算。

import pandas as pd

data = {
    'Category': ['A', 'A', 'B', 'A', 'B', 'A', 'B'],
    'Value': [10, 5, 15, 8, 12, 3, 20]
}
df = pd.DataFrame(data)

print("原始DataFrame:\n", df)

# 按Category分组后，对Value进行组内累积求和
df['Cumulative_Value_Per_Category'] = df.groupby('Category')['Value'].cumsum()
print("\n按Category分组后的累积和:\n", df)
# 解释：
# Category A: [10, 10+5, (跳过B), 15+8, (跳过B), 23+3] -> [10, 15, NaN, 23, NaN, 26, NaN] (索引对应)
# Category B: [(跳过A), (跳过A), 15, (跳过A), 15+12, (跳过A), 27+20] -> [NaN, NaN, 15, NaN, 27, NaN, 47] (索引对应)

这种分组累积求和在分析销售数据（按产品类别累计）、用户行为（按用户ID累计登录时长）或财务报表（按部门累计支出）等场景中，都表现得极其高效和实用。

Python中累积和计算的性能考量与替代方案（在特定场景下）

我总觉得，当你开始考虑性能的时候，说明你处理的数据量已经不小了。cumsum在Python生态里，尤其是NumPy和Pandas的版本，基本就是最优解了。它们底层都是用C语言实现的，因此对于大型数组或DataFrame，其执行效率非常高，通常不需要我们去手动优化。

为什么cumsum是首选？

• 高度优化： NumPy和Pandas的cumsum函数都是用C语言编写的，这意味着它们执行速度极快，远超纯Python循环。
• 内存效率： 它们能够有效地处理大型数据集，而不会导致不必要的内存开销。
• 功能全面： 支持多维数组、缺失值处理、轴向控制等，功能强大。

一些“替代方案”或“理解性”的实现（在特定场景下）：

虽然cumsum是标准答案，但在某些特殊情况下，或者仅仅是为了理解其工作原理，你可能会遇到或考虑其他方法。

1. 纯Python循环（仅用于理解，不推荐用于性能敏感场景）： 这是最直观的实现方式，但性能极差，尤其是在数据量大时。

   data = [1, 2, 3, 4, 5]
   cumulative_sum_py = []
   current_sum = 0
   for x in data:
       current_sum += x
       cumulative_sum_py.append(current_sum)
   print("纯Python循环累积和:", cumulative_sum_py)

2. itertools.accumulate（适用于迭代器和内存敏感场景）：itertools模块提供了很多用于迭代器的工具，accumulate就是其中之一。它返回一个迭代器，按需生成累积和，这在处理非常大的序列时可能比一次性加载到内存更节省资源，因为它不需要一次性创建整个结果列表。

   from itertools import accumulate
   
   data = [1, 2, 3, 4, 5]
   cumulative_sum_itertools = list(accumulate(data))
   print("itertools.accumulate累积和:", cumulative_sum_itertools)
   
   # 也可以指定一个二元操作函数，例如累积乘积
   import operator
   cumulative_product = list(accumulate(data, operator.mul))
   print("itertools.accumulate累积乘积:", cumulative_product)

   itertools.accumulate的优点在于它的“惰性”计算和内存效率，它更适合处理流式数据或当你不需要一次性获得所有结果，而是逐个处理时。但它不如NumPy/Pandas那样直接支持多维数组的轴向操作或DataFrame的复杂索引结构。

总而言之，在Python中进行数据累积和计算，NumPy和Pandas的cumsum函数几乎总是你的首选。它们在性能、功能和易用性之间找到了完美的平衡。只有在非常特殊、对内存极致敏感且数据结构简单的场景下，itertools.accumulate才可能成为一个有益的补充。

文中关于的知识介绍，希望对你的学习有所帮助！若是受益匪浅，那就动动鼠标收藏这篇《Pythoncumsum函数详解与使用方法》文章吧，也可关注golang学习网公众号了解相关技术文章。