Pandas 在处理百万级（甚至千万级）数据时，性能瓶颈非常明显，主要体现在：
- 内存爆炸（object 类型列特别吃内存）
- 单线程执行（groupby、join、apply 等慢）
- 拷贝开销大（很多操作隐式拷贝）
- 字符串/类别操作低效
2026 年，纯 Pandas 优化 仍然有很大提升空间（可提速 2–10x），但超过 500 万～1000 万行后，Polars / DuckDB 通常是更现实的选择（往往快 5–50x + 内存减半）。
下面按优先级给你一份实用优化清单，从最有效到次要，附带代码示例与真实提速幅度（基于 2025–2026 年常见 benchmark，百万～千万行级别）。
1. 最有效的前三招（通常能提速 3–10x）
| 排名 | 技巧 | 典型提速 | 内存节省 | 代码示例 | 适用场景 |
|---|---|---|---|---|---|
| 1 | 读数据时选列 + 指定 dtype | 2–5x | 50–80% | pd.read_csv(..., usecols=['A','B'], dtype={'A':'category', 'B':'int32'}) | CSV/Parquet 导入阶段 |
| 2 | 转为 category 类型（字符串列） | 5–20x | 70–90% | df['city'] = df['city'].astype('category') | 高重复字符串列（如省份、用户ID） |
| 3 | 用 chunking + 迭代处理 | 内存无限 | — | for chunk in pd.read_csv(..., chunksize=100_000): process(chunk) | 内存不够，文件 > RAM 时 |
2. 核心性能优化技巧全景（代码 + 说明）
import pandas as pd
import numpy as np
import timeit
# ----------------------- 基准数据准备（模拟百万级） -----------------------
n = 5_000_000
df = pd.DataFrame({
'id': np.arange(n),
'category': np.random.choice(['A','B','C','D','E'], n),
'value': np.random.randn(n) * 100,
'name': np.random.choice(['Alice','Bob','Charlie','David','Eve'], n),
'date': pd.date_range('2020-01-01', periods=n, freq='min')[:n],
'group': np.random.randint(1, 1000, n)
})
# 原始内存占用
print("原始内存:", df.memory_usage(deep=True).sum() / 1024**2, "MB")A. 数据类型优化（Downcasting & category）
# 优化前：~800–1200 MB（object 列主导）
# 优化后：通常降到 200–400 MB
df_opt = df.copy()
# 数值 downcast
for col in df_opt.select_dtypes(include=['int64','float64']).columns:
df_opt[col] = pd.to_numeric(df_opt[col], downcast='integer' if 'int' in df_opt[col].dtype.name else 'float')
# 字符串 → category（重复率高的列）
df_opt['category'] = df_opt['category'].astype('category')
df_opt['name'] = df_opt['name'].astype('category')
# datetime → datetime64[ns]（通常已最优，但可转低精度）
df_opt['date'] = df_opt['date'].dt.as_unit('s') # 2025+ 支持 as_unit 降精度
print("优化后内存:", df_opt.memory_usage(deep=True).sum() / 1024**2, "MB")常见提速：groupby / value_counts 快 5–15x，内存减 60–85%。
B. 向量化 vs apply / iterrows（最大杀手）
# 慢：apply / for 循环
%timeit df['double'] = df['value'].apply(lambda x: x*2) # 几秒～十几秒
# 快：直接向量运算
%timeit df['double'] = df['value'] * 2 # 毫秒级
# 复杂逻辑也尽量向量化
df['flag'] = np.where((df['value'] > 0) & (df['group'] % 2 == 0), 'good', 'bad')提速：10–100x（百万行级别差异最明显）。
C. groupby 优化
# 普通 groupby
df.groupby('group')['value'].sum() # 慢
# 优化组合
(
df_opt.groupby('group', observed=True)['value'] # observed=True 加速 category
.agg(['sum','mean','count'])
.round(2)
)
# 超大 groupby → 先 filter 再 group
df_opt.query("value > 50").groupby('category').size()D. merge / join 优化
# 慢：默认 merge
pd.merge(df1, df2, on='id')
# 快：先 set_index + join
df1.set_index('id').join(df2.set_index('id'), how='left')
# 更快：category + merge_asof（时间序列）
# 或直接用 Polars / DuckDB 做 join（见下文）E. chunking + 并行处理（内存受限终极解）
def process_chunk(chunk):
# 你的清洗 / 聚合逻辑
return chunk.groupby('category')['value'].sum()
chunks = pd.read_csv('big.csv', chunksize=200_000, dtype={'category':'category'})
result = pd.concat([process_chunk(c) for c in chunks]) # 或用 multiprocessing.Pool3. 2026 年现实选择对比（百万～亿级数据）
| 数据规模 | 推荐方案 | 为什么（2026视角） | 大致速度对比（vs 原生 Pandas） |
|---|---|---|---|
| < 500 万行 | 优化后 Pandas | 内存够 + 生态最全 | 1x（优化后 3–10x） |
| 500 万～5000 万行 | Polars（首选）或 DuckDB | 多核 + 懒执行 + Arrow 内存零拷贝 | 5–30x |
| > 5000 万行 | DuckDB（SQL 风格）或 Polars streaming | DuckDB 内存极省 + 可直接查 Parquet/CSV 不加载 | 10–100x |
| 亿级 + 集群需求 | PySpark / Dask on Ray | 分布式 | 视集群规模 |
快速迁移建议（Polars 语法与 Pandas 高度相似）：
import polars as pl
# Pandas → Polars 几乎 1:1
df_pl = pl.from_pandas(df_opt)
(
df_pl.lazy()
.group_by('group')
.agg(pl.col('value').sum().alias('total'))
.collect(streaming=True) # 内存不够时自动流式
)一句话总结（2026 年务实答案）：
- 先把 dtype + category + 向量化 三板斧用好 → 百万级数据基本够用，提速 3–10x，内存减半。
- 一旦卡住（>5–10 秒或 OOM） → 直接转 Polars（语法迁移成本最低，提速最暴力）。
- 爱写 SQL 或数据在 Parquet/CSV 不想全读内存 → DuckDB 是当前最强单机 OLAP 引擎。
你现在处理的典型数据规模是多少行？最卡的操作为哪一步（groupby？merge？apply？读文件？）？
告诉我具体痛点，我可以给你针对性的优化代码或 Polars/DuckDB 迁移示例～
