Pandas高效处理：我用这7个技巧，把处理速度提升了10倍

2026-03-01

大家好，我是正在实战各种AI项目的程序员晚枫。

今天学习Pandas性能优化技巧。

当数据量达到百万甚至千万级别时，普通的Pandas操作会变得很慢。掌握这些优化技巧，你能用更少的内存、更快的速度处理大数据。

技巧1：使用合适的数据类型

数值类型优化

import pandas as pd
import numpy as np

# 创建示例数据
df = pd.DataFrame({
    'int_col': np.random.randint(0, 100, 1000000),
    'float_col': np.random.randn(1000000),
    'bool_col': np.random.choice([True, False], 1000000)
})

print("原始内存占用:")
print(df.memory_usage(deep=True).sum() / 1024**2, "MB")

# 优化整数类型
df['int_col'] = df['int_col'].astype('int8')  # 如果范围是0-255
# 或 int16, int32 根据实际范围选择

# 优化浮点数
df['float_col'] = df['float_col'].astype('float32')

print("\n优化后内存占用:")
print(df.memory_usage(deep=True).sum() / 1024**2, "MB")

类别类型（Category）

# 字符串列占用大量内存
df['category'] = np.random.choice(['A', 'B', 'C', 'D'], 1000000)

# 转为category类型
df['category'] = df['category'].astype('category')

# 内存减少90%以上！

技巧2：避免循环，使用向量化

❌ 慢：Python循环

# 计算两列的欧氏距离（慢）
def calc_distance(row):
    return (row['x']**2 + row['y']**2)**0.5

df['distance'] = df.apply(calc_distance, axis=1)  # 超慢！

✅ 快：向量化运算

1 2	# 使用向量化（快100倍） df['distance'] = (df['x']2 + df['y']2)**0.5

其他向量化替代方案

# 条件赋值
# 慢
for i in range(len(df)):
    if df.loc[i, 'score'] > 80:
        df.loc[i, 'grade'] = 'A'

# 快
df.loc[df['score'] > 80, 'grade'] = 'A'
df['grade'] = np.where(df['score'] > 80, 'A', 'B')

技巧3：使用eval和query

# 复杂表达式加速
import numexpr

# 普通方式（慢）
df['result'] = df['a'] + df['b'] * df['c'] - df['d'] / df['e']

# 使用eval（快2-3倍）
df['result'] = pd.eval('df.a + df.b * df.c - df.d / df.e')

# query加速筛选
# 慢
df[(df['a'] > 0) & (df['b'] < 100)]

# 快
df.query('a > 0 and b < 100')

技巧4：分块读取大文件

# 内存不足时，分块处理
chunk_size = 100000
results = []

for chunk in pd.read_csv('huge_file.csv', chunksize=chunk_size):
    # 处理每个块
    processed = chunk.groupby('category')['value'].sum()
    results.append(processed)

# 合并结果
final_result = pd.concat(results).groupby(level=0).sum()

技巧5：使用迭代器

# 遍历DataFrame（不要用iterrows）

# ❌ 慢：iterrows
for index, row in df.iterrows():
    print(row['column'])

# ✅ 快：itertuples
for row in df.itertuples():
    print(row.column)

# ✅ 更快：直接遍历列
for value in df['column']:
    print(value)

技巧6：及时释放内存

# 删除不需要的变量
del large_df

# 强制垃圾回收
import gc
gc.collect()

# 只选择需要的列
df = df[['col1', 'col2', 'col3']]  # 而不是加载所有列

技巧7：使用更高效的数据格式

# CSV vs Parquet
# Parquet是列式存储，读取更快、压缩率更高

# 保存为Parquet
df.to_parquet('data.parquet', compression='snappy')

# 读取Parquet（比CSV快5-10倍）
df = pd.read_parquet('data.parquet')

# 其他高效格式
# Feather：读写极快
# HDF5：适合大数组数据

实战：完整优化流程

import pandas as pd
import numpy as np

def optimize_dataframe(df):
    """自动优化DataFrame"""
    
    # 1. 优化数值类型
    for col in df.select_dtypes(include=['int']).columns:
        c_min = df[col].min()
        c_max = df[col].max()
        if c_min > np.iinfo(np.int8).min and c_max < np.iinfo(np.int8).max:
            df[col] = df[col].astype(np.int8)
        elif c_min > np.iinfo(np.int16).min and c_max < np.iinfo(np.int16).max:
            df[col] = df[col].astype(np.int16)
        elif c_min > np.iinfo(np.int32).min and c_max < np.iinfo(np.int32).max:
            df[col] = df[col].astype(np.int32)
    
    # 2. 优化浮点数
    for col in df.select_dtypes(include=['float']).columns:
        df[col] = df[col].astype(np.float32)
    
    # 3. 优化对象类型
    for col in df.select_dtypes(include=['object']).columns:
        num_unique = df[col].nunique()
        num_total = len(df[col])
        if num_unique / num_total < 0.5:  # 重复值多
            df[col] = df[col].astype('category')
    
    return df

# 使用
print("优化前内存:", df.memory_usage(deep=True).sum() / 1024**2, "MB")
df = optimize_dataframe(df)
print("优化后内存:", df.memory_usage(deep=True).sum() / 1024**2, "MB")