Membaca JSON besar dengan pantas di Python: ujian stdlib, orjson dan msgspec
Inti pati: Skrip yang sama untuk mengira Stars dari NDJSON mengambil masa 754 ms dengan pustaka json standard tetapi hanya 146 ms dengan penyahkodan deklaratif msgspec — dan selari berbilang teras menambah satu peringkat lagi. Artikel ini menguji stdlib, orjson dan msgspec langkah demi langkah pada sampel 61.4 MB dan 300,000 baris, serta menerangkan setiap peningkatan kelajuan datanya dari mana dan bila ia mencapai hadnya.

Yang memperlahankan penghuraian dalam Python bukanlah teks JSON itu sendiri, tetapi kosong menukarkan setiap medan menjadi objek Python. Tukar penghurai lalai, bina lebih sedikit objek, gunakan semua teras — dan tugas pengiraan yang sama melonjak dari 0.08 GB/s kepada puluhan GB/s.
Satu pemerhatian: kod yang sama, beza satu peringkat
Tugasnya klasik: dalam log NDJSON gaya GitHub Events, kira repositori mana yang paling kerap menerima bintang antara rekod yang type-nya sama dengan WatchEvent. Pada mesin saya (Ubuntu 22.04, Python 3.12, orjson 3.13, msgspec 0.22), saya menjana fail sampel 61.4 MB dengan 300,000 baris dan menjalankan empat pelaksanaan masing-masing tiga kali, mengekalkan hasil terbaik:
| Pelaksanaan | Masa terbaik | Throughput setara | Relatif |
|---|---|---|---|
json.loads baris demi baris |
754 ms | 0.08 GB/s | 1× (asas) |
orjson.loads baris demi baris |
248 ms | 0.24 GB/s | 3.0× |
msgspec nyahkod ke dict |
201 ms | 0.30 GB/s | 3.8× |
msgspec Struct deklaratif |
146 ms | 0.41 GB/s | 5.2× |
Keempat-empat pelaksanaan menghasilkan kiraan bintang yang persis sama (60,108 rekord), jadi seluruh perbezaan datanya daripada penghuraian itu sendiri. Data pihak ketiga turut menyokong peringkat yang sama: dalam penanda aras yang diterbitkan World Programming pada 2026-11-14, statistik yang sama atas 7.6 GB dan 2.2 juta acara GitHub Archive berjalan 0.28 GB/s dengan pustaka standard (sekitar 27 saat), kira-kira 8 kali lebih pantas dengan msgspec, manakala fastsimdjson berasaskan SIMD menyiapkan seluruh set data dalam 55 ms pada 192 urutan benang (138 GB/s), memuncak 277 GB/s pada satu fail sahaja. Perhatikan: mesin mereka ialah AWS c8a.metal-48xl dengan 192 teras, jadi nombor ini tidak berpindah terus ke komputer riba — tetapi bentuk tangganya sama.
Di mana pustaka standard kehilangan masa
Pendekatan json.loads baris demi baris melakukan "terjemahan penuh" pada setiap langkah: penghurai mengimbas {"id": 1, "type": "WatchEvent", ...}, mencipta dict baharu, sekurang-kurangnya tujuh objek str dan beberapa int untuk rekod itu sahaja, kemudian menyerahkan rujukan kepada kod anda. Tiga ratus ribu baris bermakna berjuta-juta peruntukan objek kecil, dan kebanyakannya tidak pernah anda sentuh — tugas pengiraan hanya membaca dua medan, type dan repo.name.
Had kedua ialah GIL. Dalam CPython, hanya satu benang melaksanakan baitkod Python pada satu-satu masa, dan walaupun kod C penghurai melepaskan GIL, logik penapisan dan pengumpulan anda di dalam gelung tetap bersiri. Membuka lapan benang pada pentafsir lalai tidak menyelesaikan apa-apa; perlu strategi lain.
Tahap pecutan pertama: tukar penghurai
Ia langkah dengan pulangan terbaik bagi usaha — satu-satunya perubahan ialah import:
import json
import orjson
import msgspec
dec = msgspec.json.Decoder()
# Ketiga-tiga penghurai berkongsi antara muka yang hampir sama, kecuali dumps:
# orjson.dumps(...) mengembalikan bytes, bukan str
for name, load in [("stdlib", json.loads), ("orjson", orjson.loads), ("msgspec", dec.decode)]:
stars = {}
with open("events.ndjson", "rb") as f:
for line in f:
e = load(line)
if e["type"] == "WatchEvent":
stars[e["repo"]["name"]] = stars.get(e["repo"]["name"], 0) + 1
orjson ditulis dalam Rust, menghasilkan bait UTF-8 secara terus semasa penghuraian dan banyak menggunakan arahan SIMD; pada mesin saya ia tiga kali lebih pantas. Satu perangkap API patut diingat: orjson.dumps() mengembalikan bytes dan bukan str — uruskan ini semasa menulis fail atau menggabungkan rentetan.
Penyahkodan lalai msgspec berada dalam kelas yang sama dengan orjson (3.8×), tetapi senjata sebenarnya ialah penyahkodan deklaratif — ia hanya membina objek Python untuk medan yang diisytiharkan:
import msgspec
class Event(msgspec.Struct):
type: str
repo: msgspec.Raw # belum dinyahkod, bait mentah disimpan
dec = msgspec.json.Decoder(Event)
stars = {}
with open("events.ndjson", "rb") as f:
for line in f:
e = dec.decode(line)
if e.type == "WatchEvent":
name = msgspec.json.decode(e.repo)["name"]
stars[name] = stars.get(name, 0) + 1
Begitu repo diisytiharkan sebagai msgspec.Raw, 240,000 baris tanpa WatchEvent melangkau sepenuhnya pembinaan objek repo dan hanya mengimbas token — lonjakan dari 3.8× kepada 5.2× tepat datanya dari sini. Semakin banyak medan sesuatu rekod dan semakin tinggi kadar yang dibuang, semakin besar untung tahap ini.
Tahap kedua: pembahagian berbilang proses, dengan pulangan menurun
Apabila satu teras tepu, jawapan klasik ialah kolam proses: bahagikan fail kepada N julat bait (sejajar dengan sempadan baris), serahkan setiap keping kepada satu proses pekerja, dan pada akhirnya gabungkan Counter. Setiap proses mengembalikan hanya satu jadual hasil kecil, jadi kosong komunikasi adalah minimum — bentuk ideal map-reduce.
Penanda aras World Programming menunjukkan rupa laluan ini: kolam proses msgspec mencapai puncak 116 GB/s dengan 96 proses, dan menambah lebih banyak proses sebaliknya memperlahankannya — kosong penjadualan dan penggabungan menelan keuntungan. Dua kekangan praktikal terpakai: kepingan mesti sejajar dengan aksara baris baharu, jika tidak baris terakhir setiap keping gagal dihurai; dan tugas pengiraan (yang mengembalikan hasil kecil) ialah kes terbaik untuk kolam proses. Jika anda perlu mengeluarkan dan menggunakan setiap rekod, pemindahan antara proses itu sendiri menjadi hambatan baharu.
Tahap ketiga: SIMD dan Python tanpa GIL
fastsimdjson mengambil jalan lain: 8 GB/s pada satu teras (kira-kira 3.5 kali msgspec), kerana ia bersandar pada pengindeksan berstruktur simdjson — ia mengimbas awalan tanda baca untuk menentukan kedudukan setiap token tanpa membina pepohon objek penuh; digabungkan dengan fields=["/type", "/repo/name"] ia hanya membaca laluan JSON Pointer yang diisytiharkan, dan fungsi panggil balik hanya menerima dua nilai itu.
Ia juga berbilang benang: digandingkan dengan binaan free-threaded Python 3.14 (python3.14t, percubaan rasmi PEP 703 untuk membuang GIL), 192 benang memproses 7.6 GB dalam 55 ms. Pada enam fail penanda aras awam sekitar 1 GB, empat melepasi 100 GB/s dan yang terpantas, set data twitter, mencapai 277 GB/s. Ingatlah bahawa ini ialah ukuran semula bebas melebihi dakwaan pembekal, dan sampelnya ialah senario paling menguntungkan — "membaca satu-dua medan setiap rekord". Dokumen bersarang dalam tidak mencapai nombor sedemikian; salah satunya hanya bertahan sekitar 20 GB/s.
Senarai pantas pilihan dan susunan penggunaan
| Laluan | Mekanisme | Throughput (setempat/rujukan) | Terbaik untuk |
|---|---|---|---|
json (stdlib) |
pembinaan objek penuh, satu teras | 0.08 GB/s | fail kecil, tanpa kebergantungan |
| orjson | Rust + SIMD, pembinaan penuh | 0.24 GB/s | penggantian dalam beberapa baris |
| msgspec dict | Rust, pembinaan penuh | 0.30 GB/s | pilih satu antara orjson dan msgspec |
| msgspec Struct | nyahkod medan diisytiharkan sahaja | 0.41 GB/s | tatasusunan besar, kadar buangan tinggi |
| msgspec berbilang proses | selari mengikut kepingan | rujukan 116 GB/s | pengagregatan, set hasil kecil |
| fastsimdjson | indeks berstruktur + benang | rujukan 138-277 GB/s | tarik medan daripada NDJSON, 3.14t |
Susunan penggunaan yang munasabah: mula-mula beralih kepada msgspec atau orjson (beberapa minit kerja untuk 3-5× percuma); jika tidak cukup, tukarkan medan laluan panas kepada Struct; untuk tugas pengiraan tambahkan kolam proses; fastsimdjson hanya dipertimbangkan apabila anda menarik medan baris demi baris daripada NDJSON dan persekitaran anda membenarkannya. Jika hambatan adalah memori dan bukan kelajuan — fail terlalu besar untuk dibaca sekaligus — arah berubah: beralihlah kepada penstriman dengan ijson, atau jq --stream pada baris arahan; lihat Memproses JSON besar secara strim dengan jq dan Penghuraian, pemaparan dan penstriman JSON besar. Untuk peraturan baris NDJSON, lihat Buku panduan praktikal fail JSONL.
Disiplin pengukuran dan tiga perangkap
Pertama, tetapkan metodologi pengukuran masa: dalam artikel ini setiap pelaksanaan dijalankan tiga kali dan hasil terbaik diambil (untuk menapis getaran penjadual), dan fail dijana sepenuhnya sebelum pengukuran bermula. Apabila memetik nombor pihak ketiga, nyatakan spesifikasi mesin — jangan sesekali membandingkan 138 GB/s pada 192 teras dengan satu teras komputer riba anda.
Kedua, sahkan ketepatan secara bersilang: keempat-empat pelaksanaan mengira 60,108 bintang. Sebarang "pecutan" yang menukar kiraan telah menukar semantik penghuraian (pengendalian kunci pendua, kejituan integer besar), bukan menjadikannya lebih pantas. Selaraskan hasil dahulu, kelajuan kemudian.
Ketiga, tiga perangkap biasa: orjson.dumps() mengembalikan bytes, dan mencampurkannya dengan str secara senyap menghasilkan data kotor dengan awalan b'...'; kepingan kolam proses mesti sejajar dengan sempadan baris — selepas f.seek(offset), buang dahulu baris separuh; integer besar melebihi 2^53 selamat dalam mana-mana penghurai Python, tetapi jika hasilnya menuju ke pihak JavaScript, masalah kejituan menunggu di sana.
Soalan lazim
orjson atau msgspec, pilih yang mana?
Jika anda hanya mahu loads yang lebih pantas, kedua-duanya memberi 3× atau lebih — pilih mengikut aktiviti penyelenggaraan dan kemahiran pasukan. Pilih msgspec jika anda memerlukan penyahkodan separa (msgspec.Struct + Raw), pengesahan jenis atau output TypedDict/dataclass; penyahkodan deklaratifnya menambah lapisan untung bebas pada tatasusunan besar.
Adakah berbilang proses sentiasa lebih pantas daripada satu teras?
Tidak. Pembahagian, pelancaran proses dan penggabungan mempunyai kos tetap, dan dengan fail beberapa puluh MB biasanya rugi. Tugas yang mengembalikan hasil besar (anda perlukan setiap rekord) kehilangan untungnya kepada pemindahan. Secara praktik: tukar pustaka pada satu teras dahulu, dan hanya selaraskan pada skala GB untuk tugas pengiraan tulen.
Mengapa penanda aras orjson saya tidak menunjukkan 3×?
Tiga sebab biasa: sampel terlalu kecil (masa penghuraian tenggelam dalam pembacaan fail dan kosong gelung); hambatan sebenar ialah rangkaian atau cakera, bukan penghuraian; atau data hampir semuanya rentetan panjang, jadi pembinaan objek berpokok kecil. Ambil sampel lebih besar, bungkus gelung penghuraian sahaja dengan time.perf_counter dan barulah buat kesimpulan.
Apa kaitan ijson dengan pustaka-pustaka ini?
ijson ialah iterator penstriman: ia mengorbankan throughput untuk memori malar dan sesuai untuk fail jauh lebih besar daripada RAM; orjson/msgspec mengejar throughput tetapi menukar setiap rekod menjadi objek. Kedua-duanya tidak berlanggar: NDJSON pada skala GB selesai dengan bacaan baris demi baris dan nyahkod pantas msgspec; ijson atau jq --stream hanya diperlukan bagi satu dokumen JSON gergasi.