Skip to content

4120 万行数据,DuckDB 用 1.2 秒,pandas 为什么连 4.8GB 内存都装不下 ​

我拿到一份纽约市官方公开数据:2024 年全年黄色出租车行程记录,12 个 parquet 文件,4120 万行、19 列、硬盘上 661MB。

这份数据有个好处——它足够大,大到能让一台 4.8GB 内存的机器把不同跑法的差距暴露出来;又足够公开,任何人都能下载复现。

我想做的实验很简单:同一份数据、同一个聚合口径,换不同的读法,看时间和内存差多少。

口径统一成一句话:算出行数、平均载客里程、以及刷卡支付(payment_type=1)的占比。三个数字,四个跑法都要算出来。

先说结论:四个跑法给出同一个答案 ​

这是做对照实验的前提,所以我把它放在第一步——如果四个跑法算出的数不一样,后面的性能比较就没有意义。

结果是:

(41169720, 4.9761, 73.9674)

四个能跑完的跑法,输出一字不差。4120 万行、平均 4.9761 英里、刷卡占 73.9674%。数据没错、口径没错,接下来比时间才有意义。

四个跑法,四条代码 ​

我把每条跑法的核心代码原样贴出来,你可以直接对照。

A 跑法:DuckDB 直接对 parquet 聚合 ​

python
import duckdb

duckdb.sql("""
    select count(*) n,
           round(avg(trip_distance), 4) avg_dist,
           round(100.0 * sum(case when payment_type = 1 then 1 else 0 end)
                 / count(*), 4) card_pct
    from read_parquet('/data/nyc-taxi/yellow_tripdata_2024-*.parquet')
""").fetchall()[0]

注意这里没有"读进来"这个动作。read_parquet 是个表函数,DuckDB 在扫描文件的同时做聚合,只在内存里保留聚合中间状态。

B 跑法:pandas 只读 2 列 ​

python
import pandas as pd, glob

df = pd.read_parquet(
    glob.glob('/data/nyc-taxi/yellow_tripdata_2024-*.parquet'),
    columns=['trip_distance', 'payment_type'])

n = len(df)
print((n, round(df.trip_distance.mean(), 4),
       round(100.0 * (df.payment_type == 1).sum() / n, 4)))

columns= 这个参数是关键——它只取需要的两列,其余 17 列不读。这也是最常见的"我只要两列"写法。

C 跑法:pandas 一次读全表 ​

python
import pandas as pd, glob

df = pd.read_parquet(glob.glob('/data/nyc-taxi/yellow_tripdata_2024-*.parquet'))
print(df.shape)

不传 columns,19 列全要。这是最省事的写法,也是我这台机器跑不完的那个。

D 跑法:pandas 一次读一个月,循环 12 次 ​

python
import pandas as pd, glob

tot, s, card = 0, 0.0, 0
for f in sorted(glob.glob('/data/nyc-taxi/yellow_tripdata_2024-*.parquet')):
    df = pd.read_parquet(f)          # 注意:这里没有 columns=
    tot  += len(df)
    s    += df.trip_distance.sum()
    card += int((df.payment_type == 1).sum())
    del df                            # 关键:这一批用完就放掉
print((tot, round(s / tot, 4), round(100.0 * card / tot, 4)))

D 跑法和 C 跑法唯一的区别是:D 每次只拿一个月,算完就 del 掉。列数一样(都是全 19 列)、数据一样、总量一样。

实测数字 ​

每跑法重复 3 次取中位数,内存取 /usr/bin/time -v 的 Maximum resident set size:

跑法耗时峰值内存结果
A · DuckDB 直接聚合1.20 s71 MB✅ 一致
B · pandas 只读 2 列2.83 s1678 MB✅ 一致
C · pandas 一次读全表跑不完—❌ 被内核杀掉
D · pandas 分 12 批读14.83 s1496 MB✅ 一致

:::num 1.20s|DuckDB 扫描 4120 万行并聚合,峰值内存仅 71MB

:::num 3次|C 跑法连续三次都被系统杀掉,从未产出结果

C 跑法:它根本没跑完 ​

这一栏我没填数字,因为它没有数字可填。三次尝试全部被系统杀掉,rc=-15(SIGTERM)。

内核日志是这么写的:

oom-kill:constraint=CONSTRAINT_MEMCG
Memory cgroup out of memory: Killed process 191955 (python)

CONSTRAINT_MEMCG 这个标记值得留意——它区别于"内存不够用导致交换",指向的是进程所属的内存组撞到了硬上限,内核按规则把它清理掉。python 进程被杀时,匿名内存已经用到 1.46GB,还在往上涨。

这里有个容易搞混的地方:"我的机器有 4.8GB,19 列数据总共 661MB,怎么会装不下?"

因为 parquet 是压缩列式存储,661MB 只是磁盘上的样子。读进内存要变成未压缩的列对象——字符串列要变成 Python 对象、时间戳要变成 64 位整数。膨胀倍数通常在 10 倍以上。

内存到底被什么决定 ​

上面只有四个点,看不出规律。所以我补了一组扫描:固定一个月的数据(296 万行),分别读 1、2、4、8、12、19 列,测峰值内存。

列数耗时峰值内存
11.48 s158 MB
21.52 s226 MB
41.67 s340 MB
82.01 s526 MB
122.10 s714 MB
192.34 s1059 MB

这六个点几乎落在一条直线上。做最小二乘拟合:

RSS = 126.2 MB + 49.27 MB × 列数      (R² = 0.9989)

R² = 0.9989 说明这条线解释得很好。它给出两个可用的结论:

  • 起步价 126MB —— 光启动 pandas、加载 parquet 引擎、建立基础结构的固定开销
  • 每加一列 49.27MB —— 在这个行数级(296 万行)下,每多要一列的边际成本

顺着这条线往下推:单月 19 列已经要 1059MB,而全年是 13.9 倍的行数(4120 ÷ 296)。如果内存随行数近似线性增长,一次装下全年 19 列大约需要 14.4GB。

这解释了 C 跑法为什么必然失败——4.8GB 的机器不可能装下它,差的不是一点半点。

那"分 12 批"为什么就装得下 ​

这是这篇文章真正的重点。

D 跑法和 C 跑法读的是同样多的数据(都是 4120 万行 × 19 列),唯一的差别是内存里同时存在多少:

  • C 要同时装下 12 个月 = 撑爆
  • D 每次只装 1 个月,算完 del 掉再读下一个 = 峰值永远只有 1 个月的量

所以 14.83 秒换来的是内存需求从 14.4GB 降到 1.5GB,降了大约 9.6 倍。

代价是时间——D 比 C 慢(如果能测的话),也比 A 慢得多。但 C 根本跑不完,所以真正的选择是在 A 和 D 之间。

A 是最优解:1.20 秒、71MB,因为 DuckDB 压根不需要把数据装进内存。D 是通用兜底:你手上的工具就是 pandas、换不了,那分批读就是让它在有限内存里跑完全量数据的办法。

最小可用内存:实测出来是多少 ​

上面用的是峰值内存。但更实用的问题是:我得给这台机器留多少内存,它才跑得完?

这就得用内存上限去压。我用 cgroup(MemoryMax=)逐档往下压,记录"还能跑通的最小档"和"第一个失败的档":

跑法最小可用上限该档峰值第一个失败档
A · DuckDB150 MB70.8 MB未失败
B · pandas 2 列1800 MB1671.5 MB1600 MB
D · pandas 分 12 批1500 MB1464.5 MB1200 MB

A 跑法最夸张:150MB 上限就够它扫完 4120 万行(还能再往下压,只是我没继续试)。这是因为它压根不落地。

这里有个反直觉的点值得说清:B 跑法的峰值内存是 1671.5MB,但它需要 1800MB 的上限才跑得通。 差了约 130MB。

原因是 cgroup 统计的 memory.current 包含可以被回收的 page cache(读 parquet 时落在缓存里的文件页),而 /usr/bin/time -v 报的 RSS 不含这部分。所以压内存时,实际要留的安全余量比峰值 RSS 更大——这也是我把最小可用上限单独测一遍、不直接拿峰值当阈值的原因。

回到你自己的数据 ​

这份公开数据可以换成人家的任何表,结论是一致的。但有几个可操作的点:

第一,先看列。 上面的每列 49.27 MB 是这台机器上这个行数级测出来的,你自己的数据不一定一样,但列数是你可以直接控制的变量——columns= 只取需要的列,往往是最大的一笔节省。B 跑法只读 2 列(1678MB)和单月全 19 列(1059MB)看着接近,但换到全年量级就是 14.4GB 和 1.5GB 的差别。

第二,一次别拿太多。 如果必须用 pandas 读全量,按文件、按月份、按 ID 区间分批,算完就 del。这算不上"优化技巧",实质是把"内存需求"从「全量」降到「一批」。

第三,压内存时要留余量。 别拿峰值 RSS 当阈值,按实测经验多留 10%~15%。

第四,能交给数据库就别搬进内存。 A 跑法用 150MB 完成的事,pandas 要 1.8GB —— 差 12 倍。这里的关键不在 pandas 好不好,而在它的设计就是"把数据装进内存",而聚合这件事本身不需要装。

复现方式 ​

数据是纽约市 TLC 官方公开数据,下载页一行命令:

bash
for m in 01 02 03 04 05 06 07 08 09 10 11 12; do
  curl -O "https://d37ci6vzurychx.cloudfront.net/trip-data/yellow_tripdata_2024-$m.parquet"
done

本机是 4.8GB 内存的 WSL 环境,Python 3.11 + duckdb 1.5.5 + pandas 2.3.3。所有数字来自脚本实测、3 次重复取中位数;C 跑法的失败有内核 oom-kill 日志为证。原始测量记录连同脚本一起留档,可复跑。

AI 使用说明:本文由 AI 辅助撰写,实验设计、脚本编写与数据核对由作者完成。文中所有性能数字均为本机实测(脚本留档可复跑),未使用任何模拟数据。

关注公众号:QIAN数据