Python NumPy - 统计函数 计算数组的求和与累积和

👋 大家好，欢迎来到我的技术博客！ 📚 在这里，我会分享学习笔记、实战经验与技术思考，力求用简单的方式讲清楚复杂的问题。 🎯 本文将围绕NumPy这个话题展开，希望能为你带来一些启发或实用的参考。 🌱 无论你是刚入门的新手，还是正在进阶的开发者，希望你都能有所收获！

文章目录

• 📊 Python NumPy统计函数：计算数组的求和与累积和详解
• • 🔍 什么是求和与累积和？
  • 🚀 NumPy中的基本求和函数
  • • `np.sum()` 函数详解
    • 性能对比：NumPy vs 原生Python
  • 📈 累积和函数详解
  • • `np.cumsum()` 函数
    • 实际应用场景
    • • 股票价格分析
      • 销售数据分析
  • 🔧 高级求和技巧
  • • 条件求和
    • 加权求和
  • 🎯 特殊求和函数
  • • `np.nansum()` – 忽略NaN的求和
    • `np.count_nonzero()` – 非零元素计数
  • 📊 实际案例分析
  • • 学生成绩统计系统
    • 财务数据分析
  • ⚡ 性能优化技巧
  • • 内存效率考虑
    • 并行计算优化
  • 🛠️ 错误处理和最佳实践
  • • 数值稳定性问题
    • 内存管理最佳实践
  • 🌟 高级应用实例
  • • 时间序列累积分析
    • 多维数据分析
  • 📚 总结与展望

📊 Python NumPy统计函数：计算数组的求和与累积和详解

在数据科学和数值计算的世界中，求和与累积和是最基础也是最重要的统计操作之一。无论是分析销售数据、计算财务报表，还是处理科学实验结果，我们都需要对数据进行求和运算。NumPy作为Python生态系统中最核心的科学计算库，提供了丰富而高效的求和与累积和函数，让这些操作变得简单而强大。

🔍 什么是求和与累积和？

在深入NumPy的具体实现之前，让我们先理解这两个概念的基本含义：

求和（Sum）：将数组中的所有元素相加得到一个单一的结果值。这是最直接的聚合操作。

累积和（Cumulative Sum）：沿着指定轴逐步累加元素，返回一个与原数组形状相同的数组，每个位置存储的是到当前位置为止所有元素的累加和。

举个简单的例子：

import numpy as np

# 简单数组 [1, 2, 3, 4]
# 求和 = 1 + 2 + 3 + 4 = 10
# 累积和 = [1, 1+2, 1+2+3, 1+2+3+4] = [1, 3, 6, 10]

🚀 NumPy中的基本求和函数

np.sum() 函数详解

np.sum() 是NumPy中最常用的求和函数，它具有强大的灵活性和高效性。

import numpy as np

# 创建测试数组
arr_1d = np.array([1, 2, 3, 4, 5])
arr_2d = np.array([[1, 2, 3], [4, 5, 6]])
arr_3d = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])

print("一维数组求和:", np.sum(arr_1d)) # 输出: 15
print("二维数组求和:", np.sum(arr_2d)) # 输出: 21
print("三维数组求和:", np.sum(arr_3d)) # 输出: 36

np.sum() 函数的关键参数包括：

• axis: 指定沿哪个轴进行求和
• dtype: 指定输出数据类型
• keepdims: 是否保持维度
• initial: 初始值

让我们通过具体例子来演示这些参数的使用：

import numpy as np

# 创建二维数组用于演示
data = np.array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])

print("原始数组:")
print(data)
print()

# 不指定axis，对整个数组求和
print("整体求和:", np.sum(data)) # 45

# 沿axis=0（行方向）求和
print("按列求和 (axis=0):", np.sum(data, axis=0)) # [12 15 18]

# 沿axis=1（列方向）求和
print("按行求和 (axis=1):", np.sum(data, axis=1)) # [6 15 24]

# 使用keepdims保持维度
print("保持维度的按行求和:", np.sum(data, axis=1, keepdims=True))
# [[ 6]
# [15]
# [24]]

性能对比：NumPy vs 原生Python

为了展示NumPy的强大性能，让我们做一个简单的基准测试：

import numpy as np
import time

# 创建大型数组
size = 1000000
python_list = list(range(size))
numpy_array = np.arange(size)

# 测试Python内置sum函数
start_time = time.time()
python_sum = sum(python_list)
python_time = time.time() – start_time

# 测试NumPy sum函数
start_time = time.time()
numpy_sum = np.sum(numpy_array)
numpy_time = time.time() – start_time

print(f"Python内置sum耗时: {python_time:.6f}秒")
print(f"NumPy sum耗时: {numpy_time:.6f}秒")
print(f"性能提升倍数: {python_time/numpy_time:.2f}倍")

根据NumPy官方文档显示，NumPy的向量化操作通常比纯Python循环快10-100倍。

📈 累积和函数详解

np.cumsum() 函数

累积和是数据分析中非常重要的概念，特别是在时间序列分析、金融计算等领域。np.cumsum() 函数提供了计算累积和的功能。

import numpy as np

# 一维数组累积和
arr_1d = np.array([1, 2, 3, 4, 5])
cumsum_1d = np.cumsum(arr_1d)
print("一维数组:", arr_1d)
print("累积和:", cumsum_1d) # [1 3 6 10 15]

# 二维数组累积和
arr_2d = np.array([[1, 2, 3],
[4, 5, 6]])
print("\\n二维数组:")
print(arr_2d)

# 默认情况下的累积和（展平后计算）
print("默认累积和:", np.cumsum(arr_2d)) # [1 3 6 10 15 21]

# 按行累积和 (axis=1)
print("按行累积和:", np.cumsum(arr_2d, axis=1))
# [[ 1 3 6]
# [ 4 9 15]]

# 按列累积和 (axis=0)
print("按列累积和:", np.cumsum(arr_2d, axis=0))
# [[1 2 3]
# [5 7 9]]

下面是一个更直观的图表来展示累积和的概念：

渲染错误: Mermaid 渲染失败: Parse error on line 2: …raph TD A[原始数据: [1, 2, 3, 4, 5]] –> ———————-^ Expecting 'SQE', 'DOUBLECIRCLEEND', 'PE', '-)', 'STADIUMEND', 'SUBROUTINEEND', 'PIPE', 'CYLINDEREND', 'DIAMOND_STOP', 'TAGEND', 'TRAPEND', 'INVTRAPEND', 'UNICODE_TEXT', 'TEXT', 'TAGSTART', got 'SQS'

实际应用场景

让我们通过几个实际的例子来展示累积和的应用：

股票价格分析

import numpy as np

# 模拟股票每日涨跌幅
daily_changes = np.array([0.02, –0.01, 0.03, –0.02, 0.01, 0.02, –0.01])
print("每日涨跌幅:", daily_changes)

# 计算累计收益率
cumulative_returns = np.cumsum(daily_changes)
print("累计收益率:", cumulative_returns)

# 如果初始价格为100元
initial_price = 100
prices = initial_price * (1 + np.concatenate([[0], cumulative_returns]))
print("每日价格:", prices[1:]) # 跳过初始0值

销售数据分析

import numpy as np

# 每月销售额
monthly_sales = np.array([120000, 150000, 130000, 180000, 200000, 170000])
print("每月销售额:", monthly_sales)

# 计算累计销售额
cumulative_sales = np.cumsum(monthly_sales)
print("累计销售额:", cumulative_sales)

# 计算累计增长率
growth_rate = (cumulative_sales[–1] – cumulative_sales[0]) / cumulative_sales[0] * 100
print(f"累计增长率: {growth_rate:.2f}%")

🔧 高级求和技巧

条件求和

有时候我们需要对满足特定条件的元素进行求和，这可以通过布尔索引结合求和函数来实现：

import numpy as np

# 创建测试数据
data = np.array([1, 5, 3, 8, 2, 9, 4, 7, 6])

# 对大于5的元素求和
result = np.sum(data[data > 5])
print("大于5的元素之和:", result) # 8 + 9 + 7 + 6 = 30

# 多条件求和
result2 = np.sum(data[(data > 3) & (data < 8)])
print("3到8之间的元素之和:", result2) # 5 + 4 + 7 + 6 = 22

# 使用where参数进行条件求和
result3 = np.sum(data, where=data % 2 == 0) # 偶数求和
print("偶数元素之和:", result3) # 8 + 2 + 4 + 6 = 20

加权求和

在很多实际应用中，不同元素的重要性可能不同，这时就需要使用加权求和：

import numpy as np

# 数据和权重
values = np.array([10, 20, 30, 40])
weights = np.array([0.1, 0.2, 0.3, 0.4])

# 方法1: 直接相乘后求和
weighted_sum1 = np.sum(values * weights)
print("方法1加权和:", weighted_sum1) # 30.0

# 方法2: 使用np.average的weights参数
weighted_sum2 = np.average(values, weights=weights) * np.sum(weights)
print("方法2加权和:", weighted_sum2) # 30.0

# 标准化权重后的加权平均
normalized_weighted_avg = np.average(values, weights=weights)
print("标准化加权平均:", normalized_weighted_avg) # 30.0

🎯 特殊求和函数

np.nansum() – 忽略NaN的求和

在处理真实世界的数据时，经常会遇到缺失值（NaN），np.nansum() 可以忽略这些缺失值进行求和：

import numpy as np

# 包含NaN的数组
data_with_nan = np.array([1, 2, np.nan, 4, 5, np.nan, 7])

# 普通求和会返回NaN
regular_sum = np.sum(data_with_nan)
print("普通求和:", regular_sum) # nan

# nansum忽略NaN
nan_sum = np.nansum(data_with_nan)
print("忽略NaN求和:", nan_sum) # 19.0

# 统计NaN数量
nan_count = np.sum(np.isnan(data_with_nan))
print("NaN数量:", nan_count) # 2.0

np.count_nonzero() – 非零元素计数

虽然不是直接的求和函数，但这个函数在统计分析中经常用到：

import numpy as np

# 测试数组
test_array = np.array([0, 1, 0, 3, 0, 5, 0, 7])

# 统计非零元素数量
nonzero_count = np.count_nonzero(test_array)
print("非零元素数量:", nonzero_count) # 4

# 结合条件使用
positive_count = np.count_nonzero(test_array > 3)
print("大于3的元素数量:", positive_count) # 2

# 在二维数组中的应用
matrix = np.array([[1, 0, 3], [0, 5, 0], [7, 0, 9]])
print("矩阵非零元素总数:", np.count_nonzero(matrix)) # 5
print("每行非零元素数:", np.count_nonzero(matrix, axis=1)) # [2 1 2]

📊 实际案例分析

学生成绩统计系统

让我们构建一个完整的学生成绩统计系统来展示求和和累积和的实际应用：

import numpy as np

class StudentGradeAnalyzer:
def __init__(self, grades):
"""
初始化成绩分析器
grades: 二维数组，行表示学生，列表示科目
"""
self.grades = np.array(grades)
self.students, self.subjects = self.grades.shape

def total_scores(self):
"""计算每个学生的总分"""
return np.sum(self.grades, axis=1)

def subject_totals(self):
"""计算每个科目的总分"""
return np.sum(self.grades, axis=0)

def average_scores(self):
"""计算每个学生的平均分"""
return np.mean(self.grades, axis=1)

def cumulative_performance(self):
"""计算每个学生的累积表现（各科目累计得分）"""
return np.cumsum(self.grades, axis=1)

def ranking(self):
"""基于总分对学生进行排名"""
total_scores = self.total_scores()
rankings = len(total_scores) – np.argsort(np.argsort(total_scores))
return rankings

def performance_trend(self):
"""分析班级整体成绩趋势"""
subject_averages = np.mean(self.grades, axis=0)
return np.cumsum(subject_averages)

# 示例数据：5个学生，4个科目
student_grades = [
[85, 90, 78, 92], # 学生1
[78, 85, 88, 85], # 学生2
[92, 88, 95, 90], # 学生3
[70, 75, 80, 78], # 学生4
[88, 92, 85, 88] # 学生5
]

analyzer = StudentGradeAnalyzer(student_grades)

print("=== 学生成绩分析报告 ===")
print("原始成绩矩阵:")
print(analyzer.grades)
print()

print("每个学生总分:")
total_scores = analyzer.total_scores()
for i, score in enumerate(total_scores, 1):
print(f"学生{i}: {score}")
print()

print("每个科目总分:")
subject_names = ['数学', '语文', '英语', '物理']
subject_totals = analyzer.subject_totals()
for name, total in zip(subject_names, subject_totals):
print(f"{name}: {total}")
print()

print("学生排名:")
rankings = analyzer.ranking()
for i, rank in enumerate(rankings, 1):
print(f"学生{i}: 第{rank}名")
print()

print("学生累积表现:")
cumulative_perf = analyzer.cumulative_performance()
for i, perf in enumerate(cumulative_perf, 1):
print(f"学生{i}: {perf}")

财务数据分析

另一个常见的应用场景是财务数据分析，让我们看看如何使用NumPy的求和功能来分析公司的财务状况：

import numpy as np

class FinancialAnalyzer:
def __init__(self, monthly_data):
"""
初始化财务分析器
monthly_data: 字典，包含各种财务指标的月度数据
"""
self.data = {key: np.array(value) for key, value in monthly_data.items()}
self.months = len(list(self.data.values())[0])

def revenue_analysis(self):
"""收入分析"""
revenue = self.data['revenue']
print("=== 收入分析 ===")
print(f"总收入: {np.sum(revenue):,.2f}")
print(f"平均月收入: {np.mean(revenue):,.2f}")
print(f"最高月收入: {np.max(revenue):,.2f}")
print(f"最低月收入: {np.min(revenue):,.2f}")
print(f"累计收入趋势: {np.cumsum(revenue)}")
print()

def profit_analysis(self):
"""利润分析"""
revenue = self.data['revenue']
expenses = self.data['expenses']
profit = revenue – expenses

print("=== 利润分析 ===")
print(f"总利润: {np.sum(profit):,.2f}")
print(f"平均月利润: {np.mean(profit):,.2f}")
print(f"利润率: {(np.sum(profit) / np.sum(revenue) * 100):.2f}%")
print(f"累计利润趋势: {np.cumsum(profit)}")
print()

def expense_analysis(self):
"""支出分析"""
expenses = self.data['expenses']
categories = self.data.get('expense_categories', None)

print("=== 支出分析 ===")
if categories is not None:
# 分类支出分析
category_expenses = np.sum(categories, axis=0)
category_names = ['人工成本', '材料成本', '运营费用', '其他费用']

for name, amount in zip(category_names, category_expenses):
print(f"{name}: {amount:,.2f}")
print(f"分类支出总计: {np.sum(category_expenses):,.2f}")
else:
print(f"总支出: {np.sum(expenses):,.2f}")
print(f"平均月支出: {np.mean(expenses):,.2f}")
print()

def cash_flow_analysis(self):
"""现金流分析"""
revenue = self.data['revenue']
expenses = self.data['expenses']
investments = self.data.get('investments', np.zeros_like(revenue))

net_cash_flow = revenue – expenses + investments
cumulative_cash_flow = np.cumsum(net_cash_flow)

print("=== 现金流分析 ===")
print(f"净现金流: {np.sum(net_cash_flow):,.2f}")
print(f"累计现金流: {cumulative_cash_flow}")
print(f"最终现金余额: {cumulative_cash_flow[–1]:,.2f}")
print()

# 模拟12个月的财务数据
months = 12
financial_data = {
'revenue': np.random.normal(100000, 20000, months), # 月收入
'expenses': np.random.normal(70000, 15000, months), # 月支出
'investments': np.random.normal(5000, 2000, months) # 投资收益
}

# 添加分类支出数据（假设4个类别）
financial_data['expense_categories'] = np.random.normal(
[[30000, 20000, 15000, 5000]] * months,
[[5000, 3000, 2000, 1000]] * months
)

analyzer = FinancialAnalyzer(financial_data)
analyzer.revenue_analysis()
analyzer.profit_analysis()
analyzer.expense_analysis()
analyzer.cash_flow_analysis()

⚡ 性能优化技巧

内存效率考虑

当处理大型数组时，内存使用效率变得非常重要。以下是一些优化技巧：

import numpy as np

# 创建大型数组
large_array = np.random.rand(1000000)

# 方法1: 直接求和（创建临时数组）
def method1(arr):
return np.sum(arr * arr)

# 方法2: 使用out参数避免临时数组
def method2(arr):
temp = np.empty_like(arr)
np.multiply(arr, arr, out=temp)
return np.sum(temp)

# 方法3: 使用einsum（更高效）
def method3(arr):
return np.einsum('i,i->', arr, arr)

# 性能比较（需要timeit模块）
import timeit

# 测试小数组的性能差异
small_array = np.random.rand(10000)

print("小数组性能测试 (10000元素):")
t1 = timeit.timeit(lambda: method1(small_array), number=1000)
t2 = timeit.timeit(lambda: method2(small_array), number=1000)
t3 = timeit.timeit(lambda: method3(small_array), number=1000)

print(f"方法1 (直接): {t1:.6f}秒")
print(f"方法2 (out参数): {t2:.6f}秒")
print(f"方法3 (einsum): {t3:.6f}秒")

并行计算优化

对于超大数据集，可以考虑使用并行计算来提高性能：

import numpy as np
from multiprocessing import Pool
import os

def parallel_sum_chunk(chunk_info):
"""处理数组块的求和"""
array, start, end = chunk_info
return np.sum(array[start:end])

def parallel_sum(array, num_processes=None):
"""并行求和函数"""
if num_processes is None:
num_processes = os.cpu_count()

# 将数组分割成块
chunk_size = len(array) // num_processes
chunks = []

for i in range(num_processes):
start = i * chunk_size
if i == num_processes – 1:
end = len(array) # 最后一块处理剩余元素
else:
end = (i + 1) * chunk_size
chunks.append((array, start, end))

# 使用进程池并行计算
with Pool(num_processes) as pool:
results = pool.map(parallel_sum_chunk, chunks)

return sum(results)

# 测试并行求和
large_data = np.random.rand(10000000) # 1000万个元素

# 比较串行和并行性能
import time

start_time = time.time()
serial_result = np.sum(large_data)
serial_time = time.time() – start_time

start_time = time.time()
parallel_result = parallel_sum(large_data)
parallel_time = time.time() – start_time

print(f"串行求和结果: {serial_result}")
print(f"并行求和结果: {parallel_result}")
print(f"串行耗时: {serial_time:.4f}秒")
print(f"并行耗时: {parallel_time:.4f}秒")
print(f"加速比: {serial_time/parallel_time:.2f}倍")

🛠️ 错误处理和最佳实践

数值稳定性问题

在处理浮点数时，需要注意数值稳定性问题：

import numpy as np

# 展示数值精度问题
large_numbers = np.array([1e10, 1e10, –1e10, –1e10])
small_numbers = np.array([1e-10, 1e-10, –1e-10, –1e-10])

print("大数求和:", np.sum(large_numbers)) # 期望: 0.0
print("小数求和:", np.sum(small_numbers)) # 期望: 0.0

# 更精确的求和方法
from decimal import Decimal
precise_sum = sum(Decimal(str(x)) for x in large_numbers)
print("高精度求和:", float(precise_sum))

# 使用Kahan求和算法减少误差
def kahan_sum(arr):
"""Kahan求和算法"""
sum_val = 0.0
c = 0.0 # 补偿变量
for x in arr:
y = x – c
t = sum_val + y
c = (t – sum_val) – y
sum_val = t
return sum_val

print("Kahan求和:", kahan_sum(large_numbers))

内存管理最佳实践

import numpy as np

# 内存友好的操作
def memory_efficient_operations():
"""演示内存友好的NumPy操作"""

# 1. 重用数组避免重复分配
data = np.random.rand(1000000)
result = np.empty_like(data) # 预分配结果数组

# 避免: result = np.square(data) # 创建新数组
# 推荐:
np.square(data, out=result) # 就地操作

# 2. 使用视图而不是副本
subset = data[::100] # 视图，不复制数据
# 而不是: subset = data[::100].copy() # 创建副本

# 3. 删除不需要的大数组
del data # 显式删除引用

return result[:10] # 返回部分结果

# 检查内存使用
def check_memory_usage():
"""检查当前内存使用情况"""
import psutil
process = psutil.Process()
memory_info = process.memory_info()
print(f"RSS内存: {memory_info.rss / 1024 / 1024:.2f} MB")
print(f"VMS内存: {memory_info.vms / 1024 / 1024:.2f} MB")

# 示例运行
print("内存友好操作结果:")
result = memory_efficient_operations()
print(result)

🌟 高级应用实例

时间序列累积分析

在时间序列分析中，累积和是非常有用的工具：

import numpy as np
import matplotlib.pyplot as plt

class TimeSeriesAnalyzer:
def __init__(self, data, timestamps=None):
self.data = np.array(data)
self.timestamps = timestamps if timestamps is not None else np.arange(len(data))

def moving_cumsum(self, window_size):
"""计算移动窗口的累积和"""
if window_size > len(self.data):
raise ValueError("窗口大小不能超过数据长度")

result = np.empty(len(self.data) – window_size + 1)
for i in range(len(result)):
result[i] = np.sum(self.data[i:i+window_size])
return result

def expanding_cumsum(self):
"""计算扩展窗口的累积和"""
return np.cumsum(self.data)

def seasonal_decomposition(self, period):
"""季节性分解"""
# 计算趋势成分
trend = np.convolve(self.data, np.ones(period)/period, mode='valid')

# 计算季节性成分
seasonal_indices = np.arange(len(self.data)) % period
seasonal_means = np.array([np.mean(self.data[seasonal_indices == i])
for i in range(period)])
seasonal_component = seasonal_means[seasonal_indices]

# 计算残差成分
residual = self.data – seasonal_component
if len(trend) < len(residual):
residual = residual[:len(trend)]

return trend, seasonal_component, residual

def anomaly_detection(self, threshold_std=2):
"""基于累积和的异常检测"""
cumsum_values = np.cumsum(self.data)
mean_cumsum = np.mean(cumsum_values)
std_cumsum = np.std(cumsum_values)

# 检测偏离阈值的点
anomalies = np.abs(cumsum_values – mean_cumsum) > threshold_std * std_cumsum
return anomalies

# 模拟股票价格数据
np.random.seed(42)
days = 365
base_price = 100
returns = np.random.normal(0.0005, 0.02, days) # 日收益率
prices = base_price * np.cumprod(1 + returns)

# 创建时间序列分析器
analyzer = TimeSeriesAnalyzer(prices)

print("=== 时间序列分析 ===")
print(f"初始价格: ${prices[0]:.2f}")
print(f"最终价格: ${prices[–1]:.2f}")
print(f"总体收益率: {((prices[–1]/prices[0]) – 1)*100:.2f}%")

# 移动窗口累积和（30天窗口）
moving_sums = analyzer.moving_cumsum(30)
print(f"最近30天累计收益: ${moving_sums[–1]:.2f}")

# 扩展累积和
expanding_sums = analyzer.expanding_cumsum()
print(f"累计最大回撤: ${np.min(expanding_sums):.2f}")

# 异常检测
anomalies = analyzer.anomaly_detection()
anomaly_count = np.sum(anomalies)
print(f"检测到的异常点数量: {anomaly_count}")

多维数据分析

在处理多维数据时，合理的轴选择和聚合策略至关重要：

import numpy as np

class MultiDimensionalAnalyzer:
def __init__(self, data):
"""
多维数据分析器
data: 多维NumPy数组
"""
self.data = np.array(data)
self.shape = self.data.shape

def hierarchical_summation(self):
"""层次化求和：从内层到外层逐层求和"""
result = self.data.copy()
operations = []

# 从最后一个轴开始逐层求和
for axis in reversed(range(len(self.shape))):
old_shape = result.shape
result = np.sum(result, axis=axis)
operations.append(f"Axis {axis}: {old_shape} -> {result.shape}")

return result, operations

def selective_aggregation(self, axes_to_keep):
"""选择性聚合：保留指定轴，对其余轴求和"""
all_axes = set(range(len(self.shape)))
axes_to_sum = list(all_axes – set(axes_to_keep))
axes_to_sum.sort(reverse=True) # 从高维到低维求和

result = self.data.copy()
for axis in axes_to_sum:
result = np.sum(result, axis=axis)

return result

def weighted_multidim_sum(self, weights_dict):
"""多维权重求和"""
result = self.data.copy().astype(float)

# 应用权重
for axis, weights in weights_dict.items():
weight_array = np.array(weights)
# 调整权重数组形状以匹配数据
shape = [1] * len(self.shape)
shape[axis] = len(weight_array)
weight_array = weight_array.reshape(shape)

result *= weight_array

return np.sum(result)

def conditional_multidim_sum(self, condition_func):
"""多维条件求和"""
mask = condition_func(self.data)
return np.sum(self.data[mask])

# 创建四维测试数据（例如：年份×季度×产品×地区）
test_data = np.random.rand(3, 4, 5, 6) # 3年×4季度×5产品×6地区

analyzer = MultiDimensionalAnalyzer(test_data)

print("=== 多维数据分析 ===")
print(f"数据形状: {analyzer.shape}")
print()

# 层次化求和
final_sum, operations = analyzer.hierarchical_summation()
print("层次化求和过程:")
for op in operations:
print(f" {op}")
print(f"最终求和结果: {final_sum}")
print()

# 选择性聚合：只保留产品维度
product_totals = analyzer.selective_aggregation([2]) # 保留轴2（产品）
print(f"各产品总销量: {product_totals}")
print(f"产品销量形状: {product_totals.shape}")
print()

# 多维权重求和
weights = {
0: [1.0, 1.1, 1.2], # 年份权重
1: [0.8, 0.9, 1.0, 1.1], # 季度权重
2: [1.0] * 5, # 产品权重（无权重）
3: [1.0] * 6 # 地区权重（无权重）
}
weighted_total = analyzer.weighted_multidim_sum(weights)
print(f"加权总和: {weighted_total}")

📚 总结与展望

NumPy的求和与累积和函数为我们提供了强大而灵活的数据分析工具。从最基本的np.sum()到高级的条件求和、加权求和，再到处理缺失值的np.nansum()，这些函数能够满足各种复杂的业务需求。

通过本文的学习，我们了解到：

在实际工作中，合理运用这些统计函数不仅能提高代码效率，还能让数据分析变得更加准确和可靠。随着数据量的不断增长和业务复杂度的提升，掌握这些NumPy统计技能将变得越来越重要。

如需深入了解NumPy的更多功能，建议查阅SciPy Lecture Notes，那里有更全面的科学计算教程。同时，NumPy官方用户指南也是学习NumPy的绝佳资源。

记住，在数据科学的道路上，扎实的基础知识和丰富的实践经验同样重要。希望本文能帮助你在NumPy统计函数的学习旅程中迈出坚实的一步！🚀

🙌 感谢你读到这里！ 🔍 技术之路没有捷径，但每一次阅读、思考和实践，都在悄悄拉近你与目标的距离。 💡 如果本文对你有帮助，不妨 👍 点赞、📌 收藏、📤 分享 给更多需要的朋友！ 💬 欢迎在评论区留下你的想法、疑问或建议，我会一一回复，我们一起交流、共同成长 🌿 🔔 关注我，不错过下一篇干货！我们下期再见！✨