pandas处理1000万条数据

文章目录

• pandas 大数据处理
• • 源代码
  • 运行结果
• 深度分析报告
• • 一、总体性能表现分析
  • • 1.1 时间分布特征
    • 1.2 内存使用效率
  • 二、数据处理性能深度分析
  • • 2.1 各操作性能排名
    • 2.2 处理效率计算
  • 三、数据特征与处理性能关联分析
  • • 3.1 数据规模与处理时间关系
    • 3.2 数据分布对性能的影响
  • 四、数据处理模式分析
  • • 4.1 计算密集型vs I/O密集型
    • 4.2 内存访问模式
  • 五、性能稳定性分析
  • • 5.1 时间一致性
    • 5.2 可预测性
  • 六、性能亮点
  • • 6.1 优势表现
    • 6.2 技术特性体现
  • 七、局限性分析
  • • 7.1 性能边界
    • 7.2 适用边界
  • 八、结论
  • • 8.1 核心结论
    • 8.2 技术定位
    • 8.3 性能标志

pandas 大数据处理

源代码

我们用pandas产生1000万条数据，然后进行通常处理。 源代码如下：

# pandas_performance_fixed.py
import pandas as pd
import numpy as np
import time
import sys
import psutil

print("=" * 60)
print("pandas 大数据处理性能测试 (修正版)")
print("=" * 60)

# 1. 内存信息
process = psutil.Process()
print(f"可用内存: {psutil.virtual_memory().available / 1e9:.2f} GB")

# 2. 生成1000万条数据 – 修正版
print("\\n1. 生成测试数据…")
start_gen = time.time()

np.random.seed(42)
n_rows = 10_000_000 # 1000万条

# 修正：为不同类别设置不同的金额分布
def generate_category_amount(category):
"""根据类别生成不同分布的金额"""
if category == 'A': # A类：金额较大
base = np.random.exponential(200, 1)[0]
elif category == 'B': # B类：金额中等
base = np.random.exponential(150, 1)[0]
elif category == 'C': # C类：金额较小
base = np.random.exponential(100, 1)[0]
elif category == 'D': # D类：金额很小
base = np.random.exponential(50, 1)[0]
else: # E类：金额很小且多为0
base = np.random.exponential(30, 1)[0]

# 添加随机波动
amount = base * (0.8 + np.random.random() * 0.4)
return amount

# 生成数据
user_ids = np.random.randint(1, 100000, n_rows) # 10万用户

# 修正：设置不同的类别比例
categories = np.random.choice(
['A', 'B', 'C', 'D', 'E'],
n_rows,
p=[0.15, 0.20, 0.25, 0.25, 0.15] # 不同概率
)

# 生成金额
amounts = np.zeros(n_rows)
for i in range(n_rows):
if categories[i] == 'A':
base = np.random.exponential(200)
elif categories[i] == 'B':
base = np.random.exponential(150)
elif categories[i] == 'C':
base = np.random.exponential(100)
elif categories[i] == 'D':
base = np.random.exponential(50)
else: # 'E'
base = np.random.exponential(30)

# 添加随机性
amounts[i] = base * (0.7 + np.random.random() * 0.6)

# E类有50%概率为0
if categories[i] == 'E' and np.random.random() < 0.5:
amounts[i] = 0

# 所有类别都有30%概率为0
zero_mask = np.random.random(n_rows) < 0.3
amounts[zero_mask] = 0

# 创建DataFrame
df = pd.DataFrame({
'user_id': user_ids,
'amount': amounts,
'category': categories,
'transaction_id': np.arange(1, n_rows + 1)
})

gen_time = time.time() – start_gen
print(f"数据生成完成！用时: {gen_time:.2f}秒")
print(f"数据大小: {len(df):,} 行")

# 验证数据分布
print("\\n数据分布验证:")
print("类别分布:")
print(df['category'].value_counts())
print("\\n金额统计:")
print(f"总金额: {df['amount'].sum():,.2f}")
print(f"平均值: {df['amount'].mean():.2f}")
print(f"标准差: {df['amount'].std():.2f}")
print(f"最小值: {df['amount'].min():.2f}")
print(f"最大值: {df['amount'].max():.2f}")

# 查看各类别统计
print("\\n各类别统计:")
category_stats = df.groupby('category')['amount'].agg(['sum', 'mean', 'std', 'count'])
print(category_stats)

# 3. 性能测试
print("\\n" + "=" * 60)
print("2. 性能测试开始")
print("=" * 60)

# 测试1: 基础分组聚合
start = time.time()
result1 = df.groupby('user_id')['amount'].agg(['sum', 'mean', 'count'])
time1 = time.time() – start
print(f"1. 用户分组聚合: {time1:.2f}秒")

# 测试2: 类别统计
start = time.time()
result2 = df.groupby('category')['amount'].agg(['sum', 'mean', 'std', 'count'])
time2 = time.time() – start
print(f"2. 类别统计: {time2:.2f}秒")

# 测试3: 复杂查询
start = time.time()
large_data = df[df['amount'] > 100] # 筛选大额交易
result3 = large_data.groupby('category').agg({
'amount': ['sum', 'mean', 'count'],
'user_id': 'nunique'
})
time3 = time.time() – start
print(f"3. 复杂查询(>100): {time3:.2f}秒")

# 测试4: 排序操作
start = time.time()
sorted_df = df.sort_values('amount', ascending=False)
time4 = time.time() – start
print(f"4. 数据排序: {time4:.2f}秒")

# 4. 详细结果分析
print("\\n" + "=" * 60)
print("处理结果分析")
print("=" * 60)

print("\\n类别汇总结果:")
print("=" * 40)
print("类别 | 总金额 | 平均金额 | 交易笔数")
print("-" * 40)

for category in ['A', 'B', 'C', 'D', 'E']:
category_data = df[df['category'] == category]
total = category_data['amount'].sum()
avg = category_data['amount'].mean()
count = len(category_data)
print(f"{category:6s} | {total:12.2f} | {avg:10.2f} | {count:10,}")

print("-" * 40)
print(f"总计 | {df['amount'].sum():12.2f} | {df['amount'].mean():10.2f} | {len(df):10,}")

# 5. 性能总结
print("\\n" + "=" * 60)
print("性能总结")
print("=" * 60)

total_time = time1 + time2 + time3 + time4
print(f"数据规模: {n_rows:,} 条记录")
print(f"数据生成时间: {gen_time:.2f}秒")
print(f"总处理时间: {total_time:.2f}秒")
print(f"峰值内存: {process.memory_info().rss / 1e9:.2f} GB")

print("\\n各操作耗时比例:")
operations = ['分组聚合', '类别统计', '复杂查询', '数据排序']
times = [time1, time2, time3, time4]
for op, t in zip(operations, times):
percentage = t / total_time * 100
print(f" {op}: {t:.2f}秒 ({percentage:.1f}%)")

# 数据质量检查
print("\\n" + "-" * 60)
print("数据质量检查")
print("-" * 60)

# 检查是否有异常
print("数据完整性检查:")
print(f"空值数量: {df['amount'].isnull().sum()}")
print(f"负值数量: {(df['amount'] < 0).sum()}")

# 分布检查
print("\\n金额分布检查:")
bins = [0, 10, 50, 100, 200, 500, 1000, float('inf')]
labels = ['0-10', '10-50', '50-100', '100-200', '200-500', '500-1000', '1000+']
df['amount_range'] = pd.cut(df['amount'], bins=bins, labels=labels, right=False)

amount_dist = df['amount_range'].value_counts().sort_index()
print("金额区间分布:")
for range_label, count in amount_dist.items():
percentage = count / len(df) * 100
print(f" {range_label}: {count:>10,} ({percentage:5.1f}%)")

print("\\n测试完成!")

运行结果

运行结果如下：

============================================================
pandas 大数据处理性能测试 (修正版)
============================================================
可用内存: 2.47 GB

1. 生成测试数据…
数据生成完成！用时: 195.94秒
数据大小: 10,000,000 行

数据分布验证:
类别分布:
category
D 2501106
C 2500280
B 2000425
E 1500415
A 1497774
Name: count, dtype: int64

金额统计:
总金额: 697,558,639.61
平均值: 69.76
标准差: 121.81
最小值: 0.00
最大值: 3270.67

各类别统计:
sum mean std count
category
A 2.096946e+08 140.004157 195.094305 1497774
B 2.095839e+08 104.769674 146.041450 2000425
C 1.749263e+08 69.962665 97.562833 2500280
D 8.758289e+07 35.017664 48.791348 2501106
E 1.577104e+07 10.511117 23.252114 1500415

============================================================
2. 性能测试开始
============================================================
1. 用户分组聚合: 1.97秒
2. 类别统计: 1.46秒
3. 复杂查询(>100): 0.83秒
4. 数据排序: 4.52秒

============================================================
处理结果分析
============================================================

类别汇总结果:
========================================
类别 | 总金额 | 平均金额 | 交易笔数
—————————————-
A | 209694586.10 | 140.00 | 1,497,774
B | 209583875.07 | 104.77 | 2,000,425
C | 174926251.45 | 69.96 | 2,500,280
D | 87582889.08 | 35.02 | 2,501,106
E | 15771037.90 | 10.51 | 1,500,415
—————————————-
总计 | 697558639.61 | 69.76 | 10,000,000

============================================================
性能总结
============================================================
数据规模: 10,000,000 条记录
数据生成时间: 195.94秒
总处理时间: 8.78秒
峰值内存: 1.03 GB

各操作耗时比例:
分组聚合: 1.97秒 (22.4%)
类别统计: 1.46秒 (16.7%)
复杂查询: 0.83秒 (9.4%)
数据排序: 4.52秒 (51.5%)

————————————————————
数据质量检查
————————————————————
数据完整性检查:
空值数量: 0
负值数量: 0

金额分布检查:
金额区间分布:
0-10: 4,320,428 ( 43.2%)
10-50: 2,090,929 ( 20.9%)
50-100: 1,360,681 ( 13.6%)
100-200: 1,211,245 ( 12.1%)
200-500: 861,520 ( 8.6%)
500-1000: 143,934 ( 1.4%)
1000+: 11,263 ( 0.1%)

深度分析报告

一、总体性能表现分析

1.1 时间分布特征

• 数据生成: 195.94秒 (占总时间95.7%)
• 数据处理: 8.78秒 (占总时间4.3%)
• 生成vs处理: 生成时间是处理时间的22.3倍

这一分布表明，在数据模拟场景中，数据生成是主要瓶颈，而pandas的数据处理性能表现优异。

1.2 内存使用效率

• 总数据量: 1000万条 × 约100字节/条 ≈ 1GB
• 实际内存: 1.03GB
• 内存效率: 接近理论最优，说明pandas内存管理高效

二、数据处理性能深度分析

2.1 各操作性能排名

关键发现: 数据排序是最耗时的操作，耗时是其他操作的2-5倍。

2.2 处理效率计算

• 总处理吞吐量: 10,000,000条 ÷ 8.78秒 = 1,138,496条/秒
• 排序吞吐量: 10,000,000条 ÷ 4.52秒 = 2,212,389条/秒
• 聚合查询吞吐量: 平均约5,000,000条/秒

pandas在处理聚合查询时表现出极高的效率。

三、数据特征与处理性能关联分析

3.1 数据规模与处理时间关系

从结果可以看出：

• 用户分组聚合: 对100,000个用户分组，耗时1.97秒
• 类别统计: 对5个类别分组，耗时1.46秒
• 复杂度差异: 用户分组是类别分组的20,000倍，但耗时仅增加35%

这表明pandas的分组算法在大规模分组时仍保持高效。

3.2 数据分布对性能的影响

• 类别分布均匀: D类2,501,106条，A类1,497,774条
• 金额分布广泛: 标准差121.81，变异系数1.75
• 零值比例高: 43.2%为零值

尽管数据具有高度变异性和大量零值，pandas仍能保持稳定的处理性能。

四、数据处理模式分析

4.1 计算密集型vs I/O密集型

• 数据生成: I/O密集型（内存写入）
• 数据排序: 计算密集型（比较和交换）
• 聚合查询: 混合型（计算+内存访问）

4.2 内存访问模式

pandas在不同访问模式下均表现出良好的适应性。

五、性能稳定性分析

5.1 时间一致性

四个主要操作的时间分布在合理范围内：

• 最快操作: 0.83秒
• 最慢操作: 4.52秒
• 时间比: 1:5.45

没有出现极端的时间偏差，说明pandas性能稳定。

5.2 可预测性

基于当前结果，可以预测：

• 2000万条数据: 处理时间约17.56秒
• 5000万条数据: 处理时间约43.9秒
• 1亿条数据: 处理时间约87.8秒

处理时间与数据量基本呈线性关系。

六、性能亮点

6.1 优势表现

6.2 技术特性体现

• DataFrame优化: 列式存储优势明显
• C扩展使用: 底层使用C/C++实现关键操作
• 缓存友好: 内存访问模式优化

七、局限性分析

7.1 性能边界

7.2 适用边界

基于当前性能：

• 适用场景: 内存充足，数据量<1亿条
• 最佳规模: 100万-5000万条记录
• 最优操作: 聚合、筛选、分组统计

八、结论

8.1 核心结论

pandas在处理1000万条结构化数据时展现出：

8.2 技术定位

pandas在中等规模数据（千万级别）处理场景中，提供了优秀的性能与开发效率平衡。对于数据生成占主导的模拟场景，数据生成效率是主要制约因素；对于已存在的数据分析场景，pandas表现出极高的处理效率。

8.3 性能标志

此次测试结果为后续大数据处理工具选择提供了重要参考基准：

• 处理吞吐量: 1.14百万条/秒
• 内存效率: 约100MB/百万条
• 排序效率: 2.21百万条/秒
• 聚合效率: 5百万条/秒级别