JSON Toolkit

قراءة ملفات JSON الكبيرة بسرعة في بايثون: قياسات فعلية لـ stdlib وorjson وmsgspec

الخلاصة: السكربت نفسه الذي يحصي Stars من NDJSON يستغرق 754 ميلي ثانية مع مكتبة json القياسية، لكن 146 ميلي ثانية فقط مع فك الترميز التعريفي في msgspec — والتوازي متعدد الأنوية يضيف رتبة أخرى. يختبر هذا المقال stdlib وorjson وmsgspec خطوة بخطوة على عينة حجمها 61.4 ميغابايت و300 ألف سطر، ويشرح من أين تأتي كل تسريعة ومتى تنتهي.

متقدمقراءة نحو 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.4 ميغابايت بثلاثمئة ألف سطر، وشغّلت أربع تطبيقات ثلاث مرات لكل منها واحتفظت بأفضل نتيجة:

التطبيق أفضل زمن إنتاجية مكافئة نسبيًا
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.6 غيغابايت و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 بكثافة؛ على جهازي كان أسرع ثلاث مرات. هناك فخ في الواجهة يستحق الحفظ: 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 نطاق بايت (مضبوطة على حدود الأسطر)، وسلّم كل قطعة إلى عملية عاملة، ثم ادمج العدّادات في النهاية. كل عملية تعيد جدول نتائج صغيرًا فقط، فتكلفة التواصل في حدها الأدنى — الشكل المثالي لخريطة-تقليص.

اختبار 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.6 غيغابايت في 55 ميلي ثانية. وفي ستة ملفات اختبار عامة بحجم غيغابايت تقريبًا لكل منها، تجاوز أربعة منها 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؛ ففك الترميز التعريفي عنده يضيف ربحًا مستقلًا آخر على المصفوفات الكبيرة.

هل تعدد العمليات أسرع دائمًا من نواة واحدة؟

لا. التقسيم وإنشاء العمليات والدمج لها تكاليف ثابتة، ومع ملف ببضع عشرات الميغابايتات يكون ذلك خسارة عادةً. المهام التي تعيد نتائج كبيرة (تحتاج كل سجل) تخسر ربحها في النقل. بالقاعدة العملية: بدّل المكتبة على نواة واحدة أولًا، ولا توازِ إلا في مقياس الغيغابايت في مهام حصاء صرفة.

لماذا لا يُظهر اختباري لـorjson ثلاثة أضعاف؟

ثلاثة أسباب مألوفة: العينة صغيرة جدًا (يغرق زمن التحليل في قراءة الملف وتكلفة الحلقة)؛ العائق الحقيقي هو الشبكة أو القرص لا التحليل؛ أو أن البيانات كلها تقريبًا سلاسل طويلة فبناء الكائنات يزن قليلًا. خذ عينة أكبر، وغلّف حلقة التحليل وحدها بـtime.perf_counter ثم استنتج.

ما علاقة ijson بهذه المكتبات؟

ijson مُكرِّر بثّ: يضحي بالإنتاجية مقابل ذاكرة ثابتة ويناسب ملفات أكبر بكثير من الذاكرة؛ بينما orjson/msgspec تطارد الإنتاجية لكنها تحوّل كل سجل إلى كائنات. لا تتعارض الاثنتان: NDJSON بمقياس الغيغابايت يُحل بالقراءة سطرًا سطرًا وفك الترميز السريع بmsgspec؛ ولا حاجة إلى ijson أو jq --stream إلا لمستند JSON واحد هائل.