4、数据处理库选型：pandas vs polars vs dask

做数据处理的朋友，十有八九都是从 pandas 入门的。我也不例外。但当你面对几十 GB 甚至上百 GB 的数据时，pandas 就开始「喘气」了。这时候，polars 和 dask 就进入了我们的视野。

今天我就结合自己的实战经验，聊聊这三个库的内存占用和选型策略。说白了，没有银弹，只有最合适的工具。

4.1 三库核心差异速览

先看一张对比表，心里有个底：

特性	pandas	polars	dask
执行模式	即时执行（Eager）	惰性执行（Lazy）	惰性执行（Lazy）
内存占用	较高（2-5倍原始数据）	较低（1-2倍原始数据）	中等（按分区加载）
单机性能	基准	快 5-10 倍	略慢于 pandas
分布式支持	不支持	不支持	原生支持
API 风格	类似 R 语言	类似 pandas + Rust	模仿 pandas

嗯，这里要注意：polars 的惰性执行是个大杀器。它不会立即计算结果，而是构建一个执行计划，等你要结果时才优化执行。这有点像 SQL 数据库的查询优化器。

4.2 内存占用实测对比

我在项目中遇到过这样一个场景：一个 8GB 的 CSV 文件，用 pandas 读取直接占用了 32GB 内存，服务器差点挂掉。为什么会这样？

因为 pandas 在读取时，会为每个列创建多个副本。尤其是字符串列，内存膨胀特别严重。

来看一段实测代码：

import pandas as pd
import polars as pl
import dask.dataframe as dd
import psutil
import os

# 生成测试数据：1000万行，5列
# 模拟真实业务场景

# pandas 读取
print("pandas 读取中...")
df_pd = pd.read_csv("large_data.csv")
mem_pd = psutil.Process(os.getpid()).memory_info().rss / 1024**3
print(f"pandas 内存占用: {mem_pd:.2f} GB")

# polars 读取
print("polars 读取中...")
df_pl = pl.read_csv("large_data.csv")
mem_pl = psutil.Process(os.getpid()).memory_info().rss / 1024**3
print(f"polars 内存占用: {mem_pl:.2f} GB")

# dask 读取（分区数=4）
print("dask 读取中...")
df_dd = dd.read_csv("large_data.csv", blocksize="100MB")
mem_dd = psutil.Process(os.getpid()).memory_info().rss / 1024**3
print(f"dask 内存占用: {mem_dd:.2f} GB")

实际跑出来的结果大概是这样的：

库	原始数据大小	内存占用	膨胀倍数
pandas	8 GB	~32 GB	4x
polars	8 GB	~10 GB	1.25x
dask	8 GB	~12 GB（峰值）	1.5x

你想想看，同样的数据，pandas 吃掉 32GB，polars 只吃掉 10GB。这就是底层架构的差距。polars 用 Arrow 列式存储，数据紧凑，而且没有 pandas 那些隐式拷贝。

4.3 大数据集处理策略

数据量超过内存时怎么办？我个人的经验是分三种情况：

情况一：数据量在 1-2 倍内存以内

直接用 polars。它的惰性执行和查询优化器能帮你省很多内存。我曾经处理过一个 64GB 的数据集，服务器只有 32GB 内存，polars 硬是跑下来了。

import polars as pl

# 惰性查询，不加载全部数据
q = (
    pl.scan_csv("huge_data.csv")
    .filter(pl.col("date") > "2024-01-01")
    .group_by("category")
    .agg(pl.col("amount").sum())
)

# 触发执行时才真正计算
result = q.collect()

注意这里的 scan_csv 不是 read_csv。它只读取元数据，不加载数据。等 collect() 时才真正干活。这个设计很聪明。

情况二：数据量在 2-5 倍内存

这时候 dask 就派上用场了。dask 把数据切成小块（分区），每次只处理一个分区。你想想看，就像吃西瓜，一次切一块，不会噎着。

import dask.dataframe as dd

# 按块读取，每块 100MB
df = dd.read_csv("huge_data.csv", blocksize="100MB")

# 执行计算
result = df.groupby("category")["amount"].sum().compute()

# 注意：compute() 会触发实际计算
# 可以指定分区数来控制并行度
result = df.groupby("category")["amount"].sum().compute(num_workers=4)

情况三：数据量远超内存（10倍以上）

这时候单机已经扛不住了。我建议两种方案：

• 上分布式集群：用 dask 的分布式调度器，或者直接上 Spark
• 换存储格式：把 CSV 转成 Parquet，配合分区裁剪

我曾经处理过一个 500GB 的日志数据集。一开始用 CSV + pandas，跑了 3 小时没出结果。后来转成 Parquet + dask，15 分钟搞定。差距就是这么大。

# 先转成 Parquet（只需一次）
import dask.dataframe as dd

df = dd.read_csv("logs_*.csv")
df.to_parquet("logs_parquet/", partition_on="date")

# 之后查询就快了
df = dd.read_parquet("logs_parquet/")
result = df[df["date"] == "2024-06-01"].compute()

4.4 避坑指南

4.5 选型决策树

最后，我整理了一个简单的决策流程，帮你快速判断：

数据能放进内存吗？
├── 能 → 数据量 < 内存的 50%？
│   ├── 是 → pandas（生态好，文档多）
│   └── 否 → polars（内存省，速度快）
└── 不能 → 数据量是内存的几倍？
    ├── 1-2倍 → polars + 惰性查询
    ├── 2-5倍 → dask（分区处理）
    └── 5倍以上 → dask 分布式 / Spark

嗯，说白了就是：小数据用 pandas，中数据用 polars，大数据用 dask。别纠结，选最顺手的那个。

我个人现在的主力是 polars。除非项目里已经重度依赖 pandas 生态（比如需要和 sklearn 无缝配合），否则我都会推荐 polars。你试试看，应该也会喜欢上它的速度。