首页
学习
活动
专区
圈层
工具
发布
社区首页 >专栏 >#WorkBuddy# 88.57 MB、42.7 万条 JSON 记录:json.load 只救回 58%,我把流式解析做到 100% 还省了 5/6 内存

#WorkBuddy# 88.57 MB、42.7 万条 JSON 记录:json.load 只救回 58%,我把流式解析做到 100% 还省了 5/6 内存

原创
作者头像
用户12784192
发布于 2026-11-04 11:05:54
发布于 2026-11-04 11:05:54
1420
举报

#WorkBuddy# 88.57 MB、42.7 万条 JSON 记录:json.load 只救回 58%,我把流式解析做到 100% 还省了 5/6 内存

三档方案核心指标对比
三档方案核心指标对比

痛点开场:一个 23 MB 的 JSON 文件,坏 1 个字节就全丢

先说一个很多人都遇到过的场景:导出的大 JSON 文件解析到一半报 JSONDecodeError,json.load 直接把整个文件拒之门外——里面几十万条完好的记录,跟着那一个坏字节一起蒸发。

更隐蔽的是 NDJSON(每行一个 JSON 对象)的场景:它整体根本不是合法 JSON,json.load 必炸;换成逐行 try/except 又会静默跳过坏行,你甚至不知道丢了什么。再加上 BOM、GBK 编码、截断文件,json.load 这把"瑞士军刀"在大文件面前处处是坑。

为了把坑摸清楚,我搭了一套合成语料做对照实验:20 个文件、88.57 MB、426,845 条记录,覆盖 6 种形态(单行巨型数组、NDJSON、wrapped 嵌套、缩进 pretty 数组),3 种编码(UTF-8、带 BOM 的 UTF-8、GBK),并故意注入 44 处坏数据(42 行 NDJSON 坏行、1 处大数组元素损坏、1 处截断残尾)。所有数字都是真实跑出来的,脚本可复现。

根因分析:丢的 178,966 条记录,都是"一损俱损"

A 档八个文件整体失败的构成
A 档八个文件整体失败的构成

A 档(朴素 json.load)丢掉 178,966 条记录,8 个文件整体失败,归因下来是五类:

失败方式

受害文件

丢失记录

单行 23.41 MB 大数组中部 1 处损坏,整文件报废

arr_big_corrupt.json

117,439

NDJSON 不是合法整 JSON,json.load 直接抛错

6 个 .ndjson

55,362

尾部截断少一个右括号,全盘放弃

pretty_c_trunc.json

6,165

GBK 文件按 UTF-8 读,UnicodeDecodeError

nd_f_gbk.ndjson

9,227(含在上行)

BOM 让第一行解码失败

带 BOM 的 NDJSON

首行静默丢失

这五类问题的共同根因只有一个:json.load 是"整文档原子解析"——要么全对,要么全丢。它没有"抢救"的概念。

还有一个更阴险的坑:json.loads('{"cpu":NaN}') 在 Python 里是合法的!标准库默认放行 NaN/Infinity,实验里这几行垃圾被 B 档当成正常记录算进了结果——数据被污染了都不知道。要拦住它必须显式传 parse_constant。

真实数据对比:三档方案差出一个数量级

指标

A 朴素 json.load

B 半治理(逐行 try)

C 治理式流式

记录恢复率(真值 426,845)

58.07%(247,879)

68.88%(294,016)

100.00%(426,845)

整文件失败数

8 / 20

3 / 20

0

坏数据检出(注入 44 处)

0

0(静默跳过)

44/44,带文件名+字节偏移

编码自动识别

0 种(全按 UTF-8)

0 种

3 种

峰值内存(RSS 采样)

302.5 MB(3.4×语料)

377.7 MB

50.8 MB(0.57×语料)

耗时

1.42 s

1.66 s

2.30 s(1.61×)

三个值得说的数字:

  1. 单点损坏的 23.41 MB 大数组:A、B 全丢(117,439 条),C 打捞回 117,438 条,只隔离真正损坏的那 1 个元素。
  2. 内存差 6 倍:A 要把全部记录驻留内存(302.5 MB),C 边读边丢(50.8 MB),语料越大差距越大——这是线性的,1 GB 语料下 A 档足以打爆一台 8 GB 内存的机器。
  3. 代价只有 0.88 秒:C 档比 A 档慢 61%,换来 41.9 个百分点的恢复率和每一处坏数据的精确定位。

可复制代码:六道关口的核心实现

C 档全部用标准库实现,零第三方依赖。整体思路是六道关口:

六道关口流水线
六道关口流水线

核心是三件事:编码探测、NDJSON 逐行流式(带 NaN 拒收)、顶层数组的增量 raw_decode 流式(带 resync 抢救)。

代码语言:python
复制
import codecs, json
from json import JSONDecodeError

DECODER = json.JSONDecoder()

def _reject_constant(name):          # 关口 06:拒收 NaN / Infinity
    raise ValueError("non-standard constant: " + name)

def detect_encoding(path):           # 关口 01:首 8KB 试解码
    with open(path, "rb") as f:
        head = f.read(8192)
    if head.startswith(b"\xef\xbb\xbf"):
        return "utf-8-sig"
    try:
        head.decode("utf-8"); return "utf-8"
    except UnicodeDecodeError:
        return "gbk"

def stream_ndjson(path, enc, quarantine):   # 关口 02:NDJSON 逐行
    n = 0
    with open(path, "rb") as f:
        for raw in f:
            s = raw.decode(enc).strip()
            if not s:
                continue
            try:
                o = json.loads(s, parse_constant=_reject_constant)
                if isinstance(o, dict):
                    n += 1
            except Exception:
                quarantine(path, raw, "line_corrupt")   # 隔离并记字节偏移
    return n

顶层数组的流式解析是重头戏:用 raw_decode 在一个滑动缓冲窗口里逐元素吐记录,缓冲用增量解码器喂(避免把多字节 UTF-8 字符劈成两半),坏元素隔离后从下一个可解析位置 resync 续扫:

代码语言:python
复制
def stream_array(path, enc, quarantine, on_record):
    fh = open(path, "rb")
    inc = codecs.getincrementaldecoder(enc)("strict")   # 关口 03:增量解码,不劈多字节
    buf, pos, eof = "", 0, False
    def fill():
        nonlocal buf, eof
        chunk = fh.read(1 << 20)
        buf += inc.decode(chunk)
        if not chunk:
            buf += inc.decode(b"", final=True); eof = True
    def ensure(need=256):
        nonlocal buf
        while not eof and len(buf) - pos < need:
            fill()
    fill()
    while buf[pos] != "[":                    # 跳到数组起点
        pos += 1
    pos += 1
    while True:
        while pos < len(buf) and buf[pos] in " \t\r\n,":
            pos += 1
        if pos >= len(buf):
            if eof: return
            fill(); continue
        if buf[pos] == "]":
            return
        try:                                  # 关口 04:逐元素解析,用完即弃
            obj, end = DECODER.raw_decode(buf, pos)
            on_record(obj); pos = end
        except JSONDecodeError:
            if not eof and len(buf) - pos < 256:
                fill(); continue              # 可能只是数据没到齐
            quarantine(path, pos, "element_corrupt")
            scan = pos                        # 关口 05:resync 抢救
            while True:
                nxt = buf.find('{"', scan + 1)
                if nxt == -1:
                    if eof: return
                    fill(); continue
                try:                          # 逐候选试解析,跳过坏元素内部的诱饵
                    obj, end = DECODER.raw_decode(buf, nxt)
                    on_record(obj); pos = end
                    break
                except JSONDecodeError:
                    scan = nxt
        if pos > (1 << 20):                   # 缓冲裁剪,防内存膨胀
            buf, pos = buf[pos:], 0

隔离文件每行一条:{"file": "...", "byte_offset": 12345, "kind": "line_corrupt"},44 处坏数据全部有名字、有坐标,事后可回溯可修复。

踩坑清单(全部实测踩过)

  1. json.load 是原子的:1 字节坏 = 100% 丢弃,23.41 MB 文件里的 117,439 条完好记录说没就没。
  2. NDJSON 整体不是合法 JSON:json.load 必炸;但逐行 try/except 只是半治理——静默跳过等于数据黑洞。
  3. BOM 会让第一行 json.loads 失败:编码探测返回 utf-8-sig 让解码器自动剥 BOM。
  4. GBK 按 UTF-8 读直接抛 UnicodeDecodeError:首 8 KB 试解码就能识别,别赌。
  5. json.loads 默认放行 NaN/Infinity:实验里垃圾行被当成合法记录计入结果。要拦必须传 parse_constant。
  6. 分块解码会劈开多字节字符:chunk.decode('utf-8') 在块边界必炸,用 codecs.getincrementaldecoder。
  7. resync 会被"诱饵"骗:坏元素内部的 {"cpu": 让 find('{"') 命中假起点,必须逐候选试解析验证。
  8. 不做缓冲裁剪,窗口会吃掉整文件:消费位置超过 1 MB 就把已消费部分截掉。
  9. 实验设计的坑:真值口径必须数"物理完好"的记录——截断文件里被截掉的部分不能算真值,否则召回率永远到不了 100%。

给 WorkBuddy 的提示词模板

以后遇到大 JSON 文件要解析,可以直接这样下指令:

代码语言:bash
复制
请帮我解析 <绝对路径> 下的大 JSON 文件集(含 .json 和 .ndjson),要求:
1. 逐文件先探测编码(BOM/GBK/UTF-8),输出每个文件的形态与编码;
2. NDJSON 逐行流式解析,顶层大数组用 raw_decode 增量流式,不整文件加载;
3. 用 parse_constant 拒收 NaN/Infinity,坏行/坏元素写入隔离文件(带文件名+字节偏移);
4. 输出:总记录数、每文件记录数、隔离清单、峰值内存(RSS 采样)与耗时;
5. 与 json.load 全量基线对比恢复率,给出抢救对比报告。

收尾

json.load 是好工具,但它的适用边界是"小而完好"的文件。真实世界的导出文件往往又大又脏:几十 MB 的单行数组、混着 NDJSON、带着 BOM 和 GBK、尾部还被截过。把"整文档原子解析"换成"逐元素可恢复解析",坏数据从"灾难"降级成"一条隔离日志"——同样的 88.57 MB,恢复率从 58.07% 到 100.00%,峰值内存从 302.5 MB 到 50.8 MB,代价只是 1.61 倍的解析时间。

这套六道关口(编码探测、形态分派、增量缓冲、raw_decode、resync、NaN 拒收)全部基于标准库,拿去就能用。数据来源:本机实测(Python 3.13 / 20 个合成文件 / 426,845 条记录 / 44 处注入坏数据),脚本可复现。

原创声明:本文系作者授权腾讯云开发者社区发表,未经许可,不得转载。

如有侵权,请联系 cloudcommunity@tencent.com 删除。

目录
  • #WorkBuddy# 88.57 MB、42.7 万条 JSON 记录:json.load 只救回 58%,我把流式解析做到 100% 还省了 5/6 内存
    • 痛点开场:一个 23 MB 的 JSON 文件,坏 1 个字节就全丢
    • 根因分析:丢的 178,966 条记录,都是"一损俱损"
    • 真实数据对比:三档方案差出一个数量级
    • 可复制代码:六道关口的核心实现
    • 踩坑清单(全部实测踩过)
    • 给 WorkBuddy 的提示词模板
    • 收尾
问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档