JSON Toolkit

Große JSON-Dateien in Python schnell lesen: Benchmark von stdlib, orjson und msgspec

Fazit: Dasselbe Skript zum Zählen von Stars aus NDJSON braucht mit der Standardbibliothek json 754 ms, mit msgspecs deklarativem Decoding nur 146 ms – und Multi-Core-Parallelität hebt es um eine weitere Größenordnung. Dieser Artikel benchmarket stdlib, orjson und msgspec Schritt für Schritt auf einer 61,4-MB-Stichprobe mit 300.000 Zeilen und erklärt, woher jede Beschleunigung kommt und wann sie endet.

Fortgeschritten~6 Min. LesezeitVeröffentlicht 2026-11-15Aktualisiert 2026-11-15
Vergleich der Beschleunigungswege für großes JSON-Parsing in Python: stdlib, orjson, msgspec und Multi-Core-Parallelität

Was das Parsen in Python verlangsamt, ist nie der JSON-Text selbst, sondern die Kosten, jedes Feld in ein Python-Objekt zu verwandeln. Tauschen Sie den Standard-Parser, bauen Sie weniger Objekte, nutzen Sie alle Kerne – und dieselbe Zählaufgabe steigt von 0,08 GB/s auf Dutzende GB/s.

Eine Beobachtung: derselbe Code, eine Größenordnung Unterschied

Die Aufgabe ist klassisch: In einem NDJSON-Protokoll im GitHub-Events-Stil zählen, welche Repositories unter den Datensätzen mit type gleich WatchEvent die meisten Sterne bekommen. Auf meiner Maschine (Ubuntu 22.04, Python 3.12, orjson 3.13, msgspec 0.22) habe ich eine Stichprobendatei mit 61,4 MB und 300.000 Zeilen erzeugt und vier Implementierungen je dreimal laufen lassen, wobei das beste Ergebnis zählte:

Implementierung Beste Zeit Umgerechneter Durchsatz Relativ
json.loads Zeile für Zeile 754 ms 0,08 GB/s 1× (Basis)
orjson.loads Zeile für Zeile 248 ms 0,24 GB/s 3,0×
msgspec Dekodierung in dict 201 ms 0,30 GB/s 3,8×
msgspec deklarativer Struct 146 ms 0,41 GB/s 5,2×

Alle vier Implementierungen lieferten exakt dieselben Sternzahlen (60.108 Datensätze) – der gesamte Unterschied stammt also aus dem Parsen selbst. Daten Dritter bestätigen dieselbe Größenordnung: In einem am 2026-11-14 veröffentlichten Test von World Programming lief dieselbe Statistik über 7,6 GB und 2,2 Millionen GitHub-Archive-Ereignisse mit der Standardbibliothek mit 0,28 GB/s (rund 27 Sekunden), mit msgspec etwa 8-mal schneller, während das SIMD-basierte fastsimdjson den gesamten Datensatz in 55 ms auf 192 Threads verarbeitete (138 GB/s) und auf einer einzelnen Datei bis zu 277 GB/s erreichte. Beachten Sie: Ihre Maschine ist eine AWS c8a.metal-48xl mit 192 Kernen, diese Zahlen lassen sich nicht direkt auf einen Laptop übertragen – aber die Form der Leiter bleibt gleich.

Wo die Standardbibliothek Zeit verliert

Der Ansatz json.loads Zeile für Zeile macht in jedem Schritt eine „vollständige Übersetzung“: Der Parser scannt {"id": 1, "type": "WatchEvent", ...}, erzeugt für diesen einen Datensatz ein neues dict, mindestens sieben str-Objekte und einige int-Objekte und übergibt die Referenzen an Ihren Code. Dreihunderttausend Zeilen bedeuten Millionen kleiner Objektallokationen, von denen Sie die meisten nie anfassen – die Zählaufgabe liest nur zwei Felder, type und repo.name.

Die zweite Grenze ist die GIL. In CPython führt zu jedem Zeitpunkt nur ein Thread Python-Bytecode aus, und selbst wenn der C-Code des Parsers die GIL freigibt, bleibt Ihre Filter- und Akkumulationslogik in der Schleife serial. Acht Threads auf dem Standardinterpreter lösen also nichts; Sie brauchen eine andere Strategie.

Erste Beschleunigungsstufe: Parser austauschen

Das ist der Schritt mit dem besten Aufwand-Nutzen-Verhältnis – die einzige Änderung ist der Import:

import json
import orjson
import msgspec

dec = msgspec.json.Decoder()

# Die drei Parser haben fast dieselbe Schnittstelle, außer dumps:
# orjson.dumps(...) gibt bytes zurück, nicht 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 ist in Rust geschrieben, erzeugt beim Parsen direkt UTF-8-Bytes und nutzt intensiv SIMD-Instruktionen; auf meiner Maschine war er dreimal schneller. Ein API-Stolperstein ist merkwürdig: orjson.dumps() gibt bytes statt str zurück – beim Schreiben von Dateien oder beim Verketten beachten.

msgspecs Standard-Dekodierung liegt auf dem Niveau von orjson (3,8×), aber seine eigentliche Waffe ist das deklarative Dekodieren: Es baut Python-Objekte nur für die deklarierten Felder:

import msgspec

class Event(msgspec.Struct):
    type: str
    repo: msgspec.Raw          # noch nicht dekodiert, rohe Bytes bleiben erhalten

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

Sobald repo als msgspec.Raw deklariert ist, überspringen die 240.000 Zeilen ohne WatchEvent den Aufbau des repo-Objekts vollständig und scannen nur Tokens – genau daraus entsteht der Sprung von 3,8× auf 5,2×. Je mehr Felder ein Datensatz hat und je höher der verworfene Anteil, desto mehr bringt diese Stufe.

Zweite Stufe: Multiprozess-Aufteilung mit abnehmendem Ertrag

Sobald ein Kern ausgelastet ist, lautet die klassische Antwort ein Prozesspool: Teilen Sie die Datei in N Bytebereiche (an Zeilengrenzen ausgerichtet), geben Sie jeden Abschnitt einem Worker-Prozess und führen Sie am Ende die Counters zusammen. Jeder Prozess liefert nur eine kleine Ergebnistabelle zurück, der Kommunikationsaufwand ist minimal – die ideale Form von Map-Reduce.

Der Benchmark von World Programming zeigt, wie dieser Weg aussieht: Der msgspec-Prozesspool erreichte mit 96 Prozessen Spitzenwerte von 116 GB/s, und weitere Prozesse machten ihn langsamer – Planungs- und Zusammenführungsaufwand fraßen den Gewinn. Zwei praktische Einschränkungen gelten: Abschnitte müssen an Zeilenumbrüchen ausgerichtet sein, sonst scheitert die letzte Zeile jedes Abschnitts beim Parsen; und Zählaufgaben (die kleine Ergebnisse zurückgeben) sind der beste Fall für einen Prozesspool. Wenn Sie jeden Datensatz herausziehen und verwenden müssen, wird die Übertragung zwischen Prozessen selbst zum neuen Flaschenhals.

Dritte Stufe: SIMD und freethreaded Python

fastsimdjson geht einen anderen Weg: 8 GB/s auf einem Kern (etwa 3,5-mal msgspec), weil es auf der strukturierten Indizierung von simdjson aufbaut – es scannt vorab Zeichensetzung, um die Position jedes Tokens zu bestimmen, ohne einen vollständigen Objektbaum zu bauen; zusammen mit fields=["/type", "/repo/name"] liest es nur die deklarierten JSON-Pointer-Pfade, und der Callback erhält genau diese zwei Werte.

Es ist zudem multithreaded: Zusammen mit dem freethreaded-Build von Python 3.14 (python3.14t, der offizielle PEP-703-Versuch, die GIL zu entfernen) verarbeiteten 192 Threads 7,6 GB in 55 ms. Auf sechs öffentlichen Benchmark-Dateien von rund 1 GB übertrafen vier 100 GB/s, und der schnellste, der Twitter-Datensatz, erreichte 277 GB/s. Denken Sie daran: Das sind unabhängige Nachmessungen jenseits der Herstellerangaben, und die Stichprobe ist das günstigste Szenario – „ein bis zwei Felder pro Datensatz lesen“. Tief verschachtelte Dokumente erreichen diese Zahlen nicht; eines davon blieb bei etwa 20 GB/s.

Auswahlübersicht und Einführungsreihenfolge

Weg Mechanismus Durchsatz (lokal/Referenz) Am besten für
json (stdlib) voller Objektaufbau, ein Kern 0,08 GB/s kleine Dateien, keine Abhängigkeiten
orjson Rust + SIMD, voller Objektaufbau 0,24 GB/s Austausch in wenigen Zeilen
msgspec dict Rust, voller Objektaufbau 0,30 GB/s entweder orjson oder msgspec
msgspec Struct dekodiert nur deklarierte Felder 0,41 GB/s große Arrays, hohe Verwerfungsquote
msgspec Multiprozess parallele Abschnitte Referenz 116 GB/s Aggregationen, kleine Ergebnismengen
fastsimdjson Strukturindex + Threads Referenz 138-277 GB/s Felder aus NDJSON ziehen, 3.14t

Eine sinnvolle Einführungsreihenfolge: Wechseln Sie zuerst auf msgspec oder orjson (wenige Minuten Arbeit für 3-5× geschenkt); falls das nicht reicht, wandeln Sie die Felder des heißen Pfads in einen Struct um; fügen Sie für Zählaufgaben einen Prozesspool hinzu; fastsimdjson nur erwägen, wenn Sie Felder zeilenweise aus NDJSON ziehen und Ihre Laufzeitumgebung es erlaubt. Ist der Flaschenhals der Speicher und nicht die Geschwindigkeit – die Datei ist zu groß zum kompletten Lesen –, ändert sich die Richtung: Wechseln Sie zu ijson-Streaming oder zu jq --stream auf der Kommandozeile; siehe Große JSON-Dateien mit jq streamen und Parsen, Rendern und Streamen von großem JSON. Zu den zeilenweisen NDJSON-Regeln siehe Das JSONL-Datei-Handbuch.

Messdisziplin und drei Fallstricke

Erstens: Fixieren Sie Ihre Zeitmessung. In diesem Artikel läuft jede Implementierung dreimal und das beste Ergebnis zählt (um Scheduler-Jitter zu filtern), und die Datei ist vor Messbeginn vollständig erzeugt. Wenn Sie Drittzahlen zitieren, geben Sie die Maschinenspezifikation an – vergleichen Sie nie 138 GB/s auf 192 Kernen mit einem Kern Ihres Laptops.

Zweitens: Prüfen Sie die Korrektheit kreuzweise. Alle vier Implementierungen zählten 60.108 Sterne. Jede „Beschleunigung“, die die Zahl ändert, hat die Parsing-Semantik geändert (Duplikatschlüssel, Präzision großer Ganzzahlen) und nichts schneller gemacht. Stimmen Sie erst die Ergebnisse ab, dann die Geschwindigkeiten.

Drittens, drei häufige Fallstricke: orjson.dumps() gibt bytes zurück, und die Mischung mit str erzeugt stillschweigend schmutzige Daten mit dem Präfix b'...'; Abschnitte des Prozesspools müssen an Zeilengrenzen ausgerichtet sein – nach f.seek(offset) zuerst die unvollständige Zeile verwerfen; große Ganzzahlen über 2^53 sind in jedem Python-Parser sicher, aber wenn das Ergebnis zu einer JavaScript-Seite geht, wartet das Präzisionsproblem dort.

FAQ

orjson oder msgspec – was wählen?

Wenn Sie nur ein schnelleres loads wollen, liefern beide 3× und mehr – wählen Sie nach Wartungsaktivität und Teamvertrautheit. Wählen Sie msgspec, wenn Sie partielles Dekodieren (msgspec.Struct + Raw), Typvalidierung oder TypedDict/dataclass-Ausgabe brauchen; sein deklaratives Dekodieren bringt auf großen Arrays einen zusätzlichen unabhängigen Gewinn.

Ist Multiprozess immer schneller als ein Kern?

Nein. Aufteilung, Prozessstart und Zusammenführung haben feste Kosten, und bei einer Datei von ein paar Dutzend MB ist das meist ein Verlust. Aufgaben mit großen Ergebnissen (Sie brauchen jeden Datensatz) verlieren den Gewinn an der Übertragung. Faustregel: Erst die Bibliothek auf einem Kern wechseln, und erst bei GB-Größe in reinen Zählaufgaben parallelisieren.

Warum zeigt mein orjson-Benchmark keine 3×?

Drei übliche Gründe: Die Stichprobe ist zu klein (die Parse-Zeit ertrinkt im Lesen der Datei und im Schleifenaufwand); der echte Flaschenhals ist Netzwerk oder Festplatte, nicht das Parsen; oder die Daten bestehen vor allem aus langen Zeichenketten, sodass der Objektaufbau einen geringen Anteil hat. Nehmen Sie eine größere Stichprobe, wickeln Sie nur die Parsingschleife in time.perf_counter und ziehen Sie erst dann Schlüsse.

Wie hängt ijson mit diesen Bibliotheken zusammen?

ijson ist ein Streaming-Iterator: Er opfert Durchsatz für konstanten Speicher und passt zu Dateien, die weit größer als der RAM sind; orjson/msgspec jagen den Durchsatz, verwandeln aber jeden Datensatz in Objekte. Die beiden widersprechen sich nicht: Bei NDJSON im GB-Maßstab genügt zeilenweises Lesen mit schnellem msgspec-Dekodieren; ijson oder jq --stream braucht nur ein einzelnes riesiges JSON-Dokument.