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. 核心性能优化技巧全景（代码 + 说明）
importpandasaspdimportnumpyasnpimporttimeit# ----------------------- 基准数据准备（模拟百万级） -----------------------n=5_000_000df=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 MBdf_opt=df.copy()# 数值 downcastforcolindf_opt.select_dtypes(include=['int64','float64']).columns:df_opt[col]=pd.to_numeric(df_opt[col],downcast='integer'if'int'indf_opt[col].dtype.nameelse'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(lambdax: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 优化
# 普通 groupbydf.groupby('group')['value'].sum()# 慢# 优化组合(df_opt.groupby('group',observed=True)['value']# observed=True 加速 category.agg(['sum','mean','count']).round(2))# 超大 groupby → 先 filter 再 groupdf_opt.query("value > 50").groupby('category').size()D. merge / join 优化
# 慢：默认 mergepd.merge(df1,df2,on='id')# 快：先 set_index + joindf1.set_index('id').join(df2.set_index('id'),how='left')# 更快：category + merge_asof（时间序列）# 或直接用 Polars / DuckDB 做 join（见下文）E. chunking + 并行处理（内存受限终极解）
defprocess_chunk(chunk):# 你的清洗 / 聚合逻辑returnchunk.groupby('category')['value'].sum()chunks=pd.read_csv('big.csv',chunksize=200_000,dtype={'category':'category'})result=pd.concat([process_chunk(c)forcinchunks])# 或用 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 高度相似）：
importpolarsaspl# Pandas → Polars 几乎 1:1df_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 迁移示例～
