JSON Toolkit

קריאת JSON גדולים במהירות בפייתון: בדיקה מעשית של stdlib, orjson ו־msgspec

שורה תחתונה: אותו סקריפט שסופר Stars מתוך NDJSON לוקח 754 מילישניות עם ספריית ה־json הרגילה, אך רק 146 מילישניות עם פענוח הצהרתי ב־msgspec — ומקבילות מרובת ליבות מוסיפה עוד סדר גודל. המאמר בודק צעד אחר צעד את stdlib, orjson ו־msgspec על דגימה של 61.4MB ו־300,000 שורות, ומסביר מאין מגיעה כל זריזות ומתי היא אוזלת.

מתקדםכ-6 דקות קריאהפורסם 2026-11-15עודכן 2026-11-15
השוואת דרכי האצת פענוח JSON גדולים בפייתון: stdlib, orjson, msgspec ומקבילות מרובת ליבות

מה שמאט פענוח בפייתון אינו לעולם טקסט ה־JSON עצמו, אלא העלות של הפיכת כל שדה לאובייקט פייתון. החליפו את המפענח ברירת המחדל, בנו פחות אובייקטים, נצלו את כל הליבות — ואותה משימת ספירה תזנק מ־0.08 GB/s לעשרות GB/s.

תצפית אחת: אותו קוד, הפרש של סדר גודל

המשימה קלאסית: ביומן NDJSON בסגנון GitHub Events לספור אילו מאגרים מקבלים הכי הרבה כוכבים בקרב הרשומות שבהן type שווה ל־WatchEvent. במחשב שלי (Ubuntu 22.04, Python 3.12, orjson 3.13, msgspec 0.22) יצרתי קובץ דגימה של 61.4MB עם 300,000 שורות והרצתי ארבעה מימושים שלוש פעמים כל אחד, תוך שמירת התוצאה הטובה ביותר:

מימוש הזמן הטוב ביותר תפוקה מותאמת יחסי
json.loads שורה אחר שורה 754 ms 0.08 GB/s 1× (בסיס)
orjson.loads שורה אחר שורה 248 ms 0.24 GB/s 3.0×
msgspec פענוח ל־dict 201 ms 0.30 GB/s 3.8×
msgspec Struct הצהרתי 146 ms 0.41 GB/s 5.2×

ארבעת המימושים הניבו בדיוק אותם מוני כוכבים (60,108 רשומות), ולכן כל ההפרש מגיע מהפענוח עצמו. נתוני צד־שלישי תומכים באותו סדר גודל: במבחן שפרסם World Programming ב־2026-11-14, אותה סטטיסטיקה על 7.6GB ו־2.2 מיליון אירועי GitHub Archive רצה ב־0.28 GB/s עם הספרייה הרגילה (כ־27 שניות), כ־8 פעמים מהר יותר עם msgspec, ואילו fastsimdjson מבוסס ה־SIMD סיים את כל מערך הנתונים ב־55 מילישניות על 192 תהליכונים (138 GB/s), והגיע עד 277 GB/s על קובץ יחיד. שימו לב: המחשב שלהם הוא AWS c8a.metal-48xl עם 192 ליבות, ולכן המספרים אינם עוברים ישירות למחשב נייד — אך צורת הסולם זהה.

היכן הספרייה הרגילה מאבדת זמן

הגישה של json.loads שורה אחר שורה מבצעת "תרגום מלא" בכל שלב: המפענח סורק את {"id": 1, "type": "WatchEvent", ...}, בונה לאותה רשומה dict חדש, לפחות שבעה אובייקטי str ומספר int, ואז מוסר את ההפניות לקוד שלכם. שלוש מאות אלף שורות פירושן מיליוני הקצאות קטנות של אובייקטים, ואת רובן לעולם לא תיגעו — משימת הספירה קוראת רק שני שדות, type ו־repo.name.

המגבלה השנייה היא ה־GIL. ב־CPython רק תהליכון אחד מריץ בייטקוד פייתון בכל רגע, וגם אם קוד ה־C של המפענח משחרר את ה־GIL, הלוגיקה שלכם לסינון ולצבירה בתוך הלולאה נותרת סדרתית. שמונה תהליכונים על המפענח הרגיל לא פותרים דבר; צריך לשנות גישה.

מדרגת האצה ראשונה: החליפו מפענח

זו המדרגה עם היחס הטוב ביותר בין תוצאה למאמץ — השינוי היחיד הוא הייבוא:

import json
import orjson
import msgspec

dec = msgspec.json.Decoder()

# לשלושת המפענחים ממשק זהה כמעט, חוץ מdumps:
# orjson.dumps(...) מחזיר bytes, לא 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 כתוב ב־Rust, מייצר בייטים של UTF-8 ישירות בזמן הפענוח ועושה שימוש נרחב בהוראות SIMD; במחשב שלי הוא היה מהיר פי שלושה. יש מוקש API שכדאי לזכור: orjson.dumps() מחזיר bytes ולא str — טפלו בזה בכתיבת קבצים או בחיבור מחרוזות.

הפענוח ברירת המחדל של msgspec באותה מחלקה כמו orjson (3.8×), אך הנשק האמיתי שלו הוא פענוח הצהרתי — הוא בונה אובייקטי פייתון רק לשדות המוצהרים:

import msgspec

class Event(msgspec.Struct):
    type: str
    repo: msgspec.Raw          # טרם פוענח, הבייטים הגולמיים נשמרים

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

ברגע ש־repo מוצהר כ־msgspec.Raw, 240,000 השורות שאינן WatchEvent מדלגות לגמרי על בניית אובייקט ה־repo ורק סורקות אסימונים — משם בדיוק מגיע הקפיצה מ־3.8× ל־5.2×. ככל שלרשומה יותר שדות וככל ששיעור ההשלכה גבוה יותר, כך גדל הרווח של המדרגה הזו.

מדרגה שנייה: פיצול בין תהליכים, עם תשואה פוחתת

כשליבה אחת נגמרת, התשובה הקלאסית היא מאגר תהליכים: חלקו את הקובץ ל־N טווחי בייטים (מיושרים לגבולות שורות), מסרו כל חתיכה לתהליך עובד, ובסוף אחדו את ה־Counters. כל תהליך מחזיר רק טבלת תוצאות קטנה, ולכן עלות התקשורת מזערית — הצורה האידיאלית של map-reduce.

המבחן של World Programming מראה כיצד נראית הדרך הזאת: מאגר התהליכים של msgspec הגיע לשיא של 116 GB/s עם 96 תהליכים, והוספת תהליכים נוספים דווקא האטה אותו — עלויות התזמון והאיחוד בלעו את הרווח. ישנן שתי מגבלות מעשיות: החתיכות חייבות להיות מיושרות לתווי שורה חדשה, אחרת השורה האחרונה בכל חתיכה נכשלת בפענוח; ומשימות ספירה (המחזירות תוצאות קטנות) הן המקרה הטוב ביותר למאגר תהליכים. אם עליכם לחלץ ולהשתמש בכל רשומה, ההעברה בין התהליכים עצמה הופכת לצוואר הבקבוק החדש.

מדרגה שלישית: SIMD ופייתון נטול GIL

fastsimdjson נוסע בדרך אחרת: 8 GB/s על ליבה אחת (כ־3.5 פעמים msgspec), כי הוא נשען על מיפוי מובנה של simdjson — סורק מראש סימני פיסוק כדי לאתר את מקומו של כל אסימון בלי לבנות עץ אובייקטים מלא; בשילוב עם fields=["/type", "/repo/name"] הוא קורא רק את הנתיבים המוצהרים ב־JSON Pointer, והקריאה החוזרת מקבלת אך ורק את שני הערכים האלה.

הוא גם רב־תהליכוני: בשילוב עם בניית free-threaded של פייתון 3.14 (python3.14t, הניסיון הרשמי של PEP 703 להסיר את ה־GIL), 192 תהליכונים עיבדו 7.6GB ב־55 מילישניות. על שישה קובצי מבחן ציבוריים בגודל כ־1GB כל אחד, ארבעה חצו את 100 GB/s, והמהיר שבהם, מערך ה־twitter, הגיע ל־277 GB/s. זכרו שאלה מדידות עצמאיות חוזרות מעבר לטענות היצרן, והדגימה היא התרחיש המיטבי — "לקרוא שדה־שניים לכל רשומה". מסמכים מקוננים עמוק לא מגיעים למספרים האלה; אחד מהם נשאר סביב 20 GB/s.

טבלת בחירה מהירה וסדר אימוץ

דרך מנגנון תפוקה (מקומית/מידע) מתאים במיוחד ל
json (רגילה) בניית אובייקטים מלאה, ליבה אחת 0.08 GB/s קבצים קטנים, בלי תלות
orjson Rust + SIMD, בנייה מלאה 0.24 GB/s החלפה בכמה שורות
msgspec dict Rust, בנייה מלאה 0.30 GB/s לבחור אחד בין orjson ו־msgspec
msgspec Struct מפענח רק את השדות המוצהרים 0.41 GB/s מערכים גדולים, אחוז השלכה גבוה
msgspec רב־תהליכי מקבילות לפי חתיכות מידע 116 GB/s צבירות, קבוצות תוצאות קטנות
fastsimdjson אינדקס מובנה + תהליכונים מידע 138-277 GB/s שליפת שדות מ־NDJSON, 3.14t

סדר אימוץ סביר: עברו קודם כל ל־msgspec או orjson (כמה דקות עבודה תמורת 3-5× בחינם); אם אין די, הפכו את שדות הנתיב החם ל־Struct; למשימות ספירה הוסיפו מאגר תהליכים; fastsimdjson שקלו רק כשאתם שולפים שדות שורה אחר שורה מ־NDJSON והסביבה שלכם מתירה זאת. אם צוואר הבקבוק הוא זיכרון ולא מהירות — הקובץ גדול מדי לקריאה מלאה — הכיוון מתהפך: עברו לסטרימינג עם ijson, או ל־jq --stream בשורת הפקודה; ראו עיבוד סטרימינג של JSON גדולים עם jq ופענוח, תצוגה וסטרימינג של JSON גדולים. לכללי השורות של NDJSON ראו המדריך המעשי לקבצי JSONL.

משמעת מדידה ושלוש מלכודות

ראשית, קבעו מתודולוגיית תזמון: במאמר זה כל מימוש רץ שלוש פעמים ונספרת התוצאה הטובה ביותר (לסינון רעידות של המתזמן), והקובץ נוצר עד תום לפני תחילת המדידה. כשאתם ציטוט נתונים של אחרים, ציינו את מפרט המחשב — לעולם אל תשוו 138 GB/s על 192 ליבות לליבה אחת של המחשב הנייד שלכם.

שנית, אמתו נכונות בצורה צולבת: מוני הכוכבים של כל ארבעת המימושים היו 60,108. כל "האצה" שמשנה את המונה שינתה את הסמנטיקה של הפענוח (טיפול במפתחות כפולים, דיוק של מספרים שלמים גדולים), ולא עשתה דברים מהירים יותר. יישרו קודם את התוצאות, ואז את המהירויות.

שלישית, שלוש מלכודות שכיחות: orjson.dumps() מחזיר bytes, וערבוב עם str יוצר בשקט נתונים מלוכלכים עם קידומת b'...'; חתיכות מאגר התהליכים חייבות להיות מיושרות לגבולות שורות — אחרי f.seek(offset), השליכו קודם את השורה החלקית; מספרים שלמים גדולים מעל 2^53 בטוחים בכל מפענח פייתון, אך אם התוצאה עוברת לצד של JavaScript, בעיית הדיוק מחכה לכם שם.

שאלות נפוצות

orjson או msgspec — מה לבחור?

אם אתם רוצים רק loads מהיר יותר, שניהם מספקים 3× ומעלה — בחרו לפי פעילות התחזוקה וההיכרות של הצוות. בחרו ב־msgspec כשאתם צריכים פענוד חלקי (msgspec.Struct + Raw), אימות טיפוסים או פלט TypedDict/dataclass; הפענוד ההצהרתי שלו מוסיף רווח עצמאי נוסף על מערכים גדולים.

האם ריבוי תהליכים תמיד מהיר יותר מליבה אחת?

לא. חלוקה, הפעלת תהליכים ואיחוד נושאים עלויות קבועות, ועם קובץ של כמה עשרות MB זה בדרך כלל הפסד. משימות שמחזירות תוצאות גדולות (אתם צריכים כל רשומה) מאבדות את הרווח בהעברה. לפי כלל אצבע: החליפו ספרייה על ליבה אחת קודם, ומקבילו רק בקנה מידה של GB במשימות ספירה טהורות.

למה הבנצ'מרק של orjson אצלי לא מראה 3×?

שלוש סיבות נפוצות: הדגימה קטנה מדי (זמן הפענוח טובע בקריאת הקובץ ובעלות הלולאה); צוואר הבקבוק האמיתי הוא הרשת או הדיסק ולא הפענוח; או שהנתונים כמעט כולם מחרוזות ארוכות, ולכן בניית האובייקטים שוקלת מעט. קחו דגימה גדולה יותר, עטפו רק את לולאת הפענוח ב־time.perf_counter ורק אז הסיקו מסקנות.

מה הקשר בין ijson לספריות האלה?

ijson הוא איטרטור סטרימינג: הוא מקריב תפוקה תמורת זיכרון קבוע ומתאים לקבצים גדולים בהרבה מה־RAM; orjson/msgspec רודפות אחרי תפוקה אך הופכות כל רשומה לאובייקטים. השתיים אינן מתנגשות: NDJSON בקנה מידה של GB נפתר בקריאה שורה אחר שורה ופענוח מהיר עם msgspec; ijson או jq --stream דרושים רק למסמך JSON אחד עצום.