JSON Toolkit

Rychlé čtení velkých JSON v Pythonu: měření stdlib, orjson a msgspec

Shrnutí: Tentýž skript počítající Stars z NDJSON trvá se standardní knihovnou json 754 ms, ale s deklarativním dekódováním msgspec jen 146 ms — a vícejádrová paralelizace přidá další řád. Článek krok za krokem testuje stdlib, orjson a msgspec na vzorku 61,4 MB a 300 000 řádků a vysvětluje, odkud každé zrychlení pochází a kdy se vyčerpá.

Pokročilý~6 min čteníPublikováno 2026-11-15Aktualizováno 2026-11-15
Srovnání cest zrychlení parsování velkých JSON v Pythonu: stdlib, orjson, msgspec a vícejádrová paralelizace

Parsování v Pythonu nezpomaluje nikdy samotný text JSON, ale náklad na přeměnu každého pole na objekt Pythonu. Vyměňte výchozí parser, vytvářejte méně objektů, využijte všechna jádra — a tatáž počítací úloha vzroste z 0,08 GB/s na desítky GB/s.

Pozorování: tentýž kód, rozdíl o řád

Úloha je klasická: v logu NDJSON ve stylu GitHub Events spočítat, které repozitáře dostávají nejvíc hvězdiček mezi záznamy, kde type rovná se WatchEvent. Na svém stroji (Ubuntu 22.04, Python 3.12, orjson 3.13, msgspec 0.22) jsem vygeneroval vzorový soubor o velikosti 61,4 MB a 300 000 řádků a spustil čtyři implementace třikrát, přičemž počítal se nejlepší výsledek:

Implementace Nejlepší čas Přepočtená propustnost Relativně
json.loads po řádku 754 ms 0,08 GB/s 1× (základ)
orjson.loads po řádku 248 ms 0,24 GB/s 3,0×
msgspec dekódování do dict 201 ms 0,30 GB/s 3,8×
msgspec deklarativní Struct 146 ms 0,41 GB/s 5,2×

Všechny čtyři implementace vydaly přesně stejné počty hvězdiček (60 108 záznamů), takže celý rozdíl pochází ze samotného parsování. Data třetích stran potvrzují stejný řád: v testu publikovaném World Programming 2026-11-14 běžela tatáž statistika nad 7,6 GB a 2,2 miliony událostí GitHub Archive se standardní knihovnou rychlostí 0,28 GB/s (asi 27 sekund), s msgspec zhruba 8× rychleji, zatímco fastsimdjson založený na SIMD zpracoval celou sadu za 55 ms na 192 vláknech (138 GB/s) a na jednom souboru dosáhl 277 GB/s. Pozor: jejich stroj je AWS c8a.metal-48xl se 192 jádry, takže čísla se přímo nepřenášejí na notebook — ale forma žebříku je stejná.

Kde standardní knihovna ztrácí čas

Přístup json.loads po řádku dělá v každém kroku „úplný překlad“: parser projde {"id": 1, "type": "WatchEvent", ...}, vytvoří pro ten jeden záznam nový dict, nejméně sedm objektů str a několik int, a pak předá odkazy vašemu kódu. Tři sta tisíc řádků znamená miliony malých alokací objektů, z nichž většinu nikdy nedotknete — počítací úloha čte jen dvě pole, type a repo.name.

Druhým limitem je GIL. V CPythonu v každém okamžiku vykonává bajtkód Pythonu jen jedno vlákno, a i když C kód parseru GIL uvolní, vaše logika filtrování a sčítání uvnitř smyčky zůstává sériová. Osm vláken na výchozím interpretu tedy nevyřeší nic; je potřeba jiná strategie.

První stupeň zrychlení: vyměňte parser

Je to krok s nejlepším poměrem výsledku k námaze — jediná změna je import:

import json
import orjson
import msgspec

dec = msgspec.json.Decoder()

# Tři parsery mají téměř stejné rozhraní, kromě dumps:
# orjson.dumps(...) vrací bytes, nikoli 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 je psán v Rustu, při parsování přímo vytváří bajty UTF-8 a hojně používá SIMD instrukce; na mém stroji byl třikrát rychlejší. Jedna past API stojí za zapamatování: orjson.dumps() vrací bytes, nikoli str — počítejte s tím při zápisu souborů nebo skládání řetězců.

Výchozí dekódování msgspec je na úrovni orjson (3,8×), ale jeho pravou zbraní je deklarativní dekódování — objekty Pythonu vytváří jen pro deklarovaná pole:

import msgspec

class Event(msgspec.Struct):
    type: str
    repo: msgspec.Raw          # zatím nedekódováno, uchovávají se surové bajty

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

Jakmile je repo deklarováno jako msgspec.Raw, 240 000 řádků bez WatchEvent zcela vynechá výstavbu objektu repo a jen prohledává tokeny — přesně odsud pochází skok z 3,8× na 5,2×. Čím více má záznam polí a čím vyšší je podpora vyhozených, tím víc tento stupeň vynese.

Druhý stupeň: dělení mezi procesy s klesajícím výnosem

Když je jedno jádro vyčerpáno, klasická odpověď je pool procesů: soubor rozdělte na N rozsahů bajtů (zarovnaných na hranice řádků), každý kus svěřte pracovnímu procesu a na konci spojte Counters. Každý proces vrací jen malou tabulku výsledků, takže náklady na komunikaci jsou minimální — ideální podoba map-reduce.

Test World Programming ukazuje, jak tato cesta vypadá: pool procesů msgspec dosáhl s 96 procesy vrcholu 116 GB/s a další procesy ho naopak zpomalovaly — náklady na plánování a slučování spolkl zisk. Platí dvě praktická omezení: kusy musí být zarovnané na znaky nového řádku, jinak poslední řádek každého kusu selže při parsování; a počítací úlohy (vracející malé výsledky) jsou nejlepší případ pro pool procesů. Pokud potřebujete vytáhnout a použít každý záznam, samotný přenos mezi procesy se stane novou úzkou hrdlou.

Třetí stupeň: SIMD a Python bez GIL

fastsimdjson jde jinou cestou: 8 GB/s na jednom jádru (asi 3,5× msgspec), protože staví na strukturovaném indexování simdjson — předem proskenuje interpunkci a určí pozici každého tokenu, aniž by stavěl celý strom objektů; v kombinaci s fields=["/type", "/repo/name"] čte jen deklarované cesty JSON Pointer a zpětné volání dostane jen tyto dvě hodnoty.

Je i vícevláknový: ve spojení s free-threaded buildem Pythonu 3.14 (python3.14t, oficiální pokus PEP 703 odstranit GIL) zpracovalo 192 vláken 7,6 GB za 55 ms. Na šesti veřejných testovacích souborech zhruba po 1 GB čtyři překročily 100 GB/s a nejrychlejší, datová sada twitter, dosáhla 277 GB/s. Mějte na paměti, že jde o nezávislá přeměření nad rámec tvrzení výrobce a vzorek je nejpříznivější scénář „číst jedno až dvě pole na záznam“. Hluboko vnořené dokumenty až na taková čísla nedosáhnou; jeden z nich se držel kolem 20 GB/s.

Přehled volby a pořadí nasazení

Cesta Mechanismus Propustnost (lokální/referenční) Nejlepší pro
json (stdlib) plná výstavba objektů, jedno jádro 0,08 GB/s malé soubory, bez závislostí
orjson Rust + SIMD, plná výstavba objektů 0,24 GB/s výměna za pár řádků
msgspec dict Rust, plná výstavba objektů 0,30 GB/s buď orjson, nebo msgspec
msgspec Struct dekóduje jen deklarovaná pole 0,41 GB/s velká pole, vysoký podíl odpadu
msgspec multiproces paralelní kusy referenčně 116 GB/s agregace, malé výsledky
fastsimdjson strukturální index + vlákna referenčně 138-277 GB/s tahání polí z NDJSON, 3.14t

Rozumné pořadí nasazení: nejprve přejděte na msgspec nebo orjson (pár minut práce za 3-5× zadarmo); nestačí-li to, převeďte pole horké cesty na Struct; pro počítací úlohy přidejte pool procesů; fastsimdjson zvažujte jen tehdy, když taháte pole řádek po řádku z NDJSON a vaše prostředí to dovolí. Je-li úzkým hrdlem paměť, nikoli rychlost — soubor je příliš velký na celé přečtení — mění se směr: přejděte na streamování s ijson nebo na jq --stream v příkazové řádce; viz Streamované zpracování velkých JSON pomocí jq a Parsování, vykreslování a streamování velkých JSON. O řádkových pravidlech NDJSON pojednává Praktický průvodce soubory JSONL.

Měřicí disciplína a tři pasti

Za prvé, upevněte metodiku měření času: v tomto článku běží každá implementace třikrát a počítá se nejlepší výsledek (kvůli odstranění zakopnutí plánovače) a soubor je před začátkem měření hotový. Když citujete cizí čísla, uvádějte specifikaci stroje — nikdy neporovnávejte 138 GB/s na 192 jádrech s jedním jádrem svého notebooku.

Za druhé, kontrolujte správnost křížem: všechny čtyři implementace spočítaly 60 108 hvězdiček. Jakékoli „zrychlení“, které změní počet, změnilo sémantiku parsování (zacházení s duplicitními klíči, přesnost velkých celých čísel), nikoli věci zrychlilo. Nejdřív srovnejte výsledky, pak rychlosti.

Za třetí, tři obvyklé pasti: orjson.dumps() vrací bytes a smíchání se str tiše vytváří špinavá data s předponou b'...'; kusy poolu procesů musí být zarovnány na hranice řádků — po f.seek(offset) nejdřív odložte neúplný řádek; velká celá čísla nad 2^53 jsou v každém parseru Pythonu v bezpečí, ale pokud jde výsledek k JavaScriptu, problém s přesností tam už čeká.

FAQ

Vybrat orjson nebo msgspec?

Chcete-li jen rychlejší loads, oba dávají 3× a víc — vybírejte podle aktivity údržby a znalostí týmu. Vezměte msgspec, když potřebujete částečné dekódování (msgspec.Struct + Raw), validaci typů nebo výstup TypedDict/dataclass; jeho deklarativní dekódování přináší na velkých polích další samostatný zisk.

Je multiproces vždy rychlejší než jedno jádro?

Ne. Dělení, spouštění procesů a slučování mají fixní náklady a u souboru pár desítek MB to bývá ztráta. Úlohy vracející velké výsledky (potřebujete každý záznam) ztrácejí zisk přenosem. Z pravidla: nejdřív vyměňte knihovnu na jednom jádře a paralelizujte až v měřítku GB u čistě počítacích úloh.

Proč můj benchmark orjson neukazuje 3×?

Tři obvyklé důvody: vzorek je příliš malý (čas parsování se utopí ve čtení souboru a nákladech smyčky); skutečnou úzkou hrdlou je síť nebo disk, ne parsování; nebo data tvoří hlavně dlouhé řetězce, takže podíl výstavby objektů je malý. Vezměte větší vzorek, obalte jen parsovací smyčku do time.perf_counter a teprve pak uzavírejte.

Jak souvisí ijson s těmito knihovnami?

ijson je streamovací iterátor: obětuje propustnost za stálou paměť a hodí se na soubory výrazně větší než RAM; orjson/msgspec honí propustnost, ale každý záznam mění na objekty. Nekonfliktují: NDJSON v měřítku GB vyřešíte čtením po řádku a rychlým dekódováním msgspec; ijson nebo jq --stream potřebujete jen u jednoho obřího JSON dokumentu.