
先说一个很多人都遇到过的场景:导出的大 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 处截断残尾)。所有数字都是真实跑出来的,脚本可复现。

A 档(朴素 json.load)丢掉 178,966 条记录,8 个文件整体失败,归因下来是五类:
失败方式 | 受害文件 | 丢失记录 |
|---|---|---|
单行 23.41 MB 大数组中部 1 处损坏,整文件报废 | arr_big_corrupt.json | 117,439 |
NDJSON 不是合法整 JSON, | 6 个 .ndjson | 55,362 |
尾部截断少一个右括号,全盘放弃 | pretty_c_trunc.json | 6,165 |
GBK 文件按 UTF-8 读, | 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×) |
三个值得说的数字:
C 档全部用标准库实现,零第三方依赖。整体思路是六道关口:

核心是三件事:编码探测、NDJSON 逐行流式(带 NaN 拒收)、顶层数组的增量 raw_decode 流式(带 resync 抢救)。
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 续扫:
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 处坏数据全部有名字、有坐标,事后可回溯可修复。
json.load 是原子的:1 字节坏 = 100% 丢弃,23.41 MB 文件里的 117,439 条完好记录说没就没。json.load 必炸;但逐行 try/except 只是半治理——静默跳过等于数据黑洞。json.loads 失败:编码探测返回 utf-8-sig 让解码器自动剥 BOM。UnicodeDecodeError:首 8 KB 试解码就能识别,别赌。json.loads 默认放行 NaN/Infinity:实验里垃圾行被当成合法记录计入结果。要拦必须传 parse_constant。chunk.decode('utf-8') 在块边界必炸,用 codecs.getincrementaldecoder。{"cpu": 让 find('{"') 命中假起点,必须逐候选试解析验证。以后遇到大 JSON 文件要解析,可以直接这样下指令:
请帮我解析 <绝对路径> 下的大 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 删除。