Python में बड़ी JSON फ़ाइलों को तेज़ी से पढ़ना: stdlib, orjson और msgspec का व्यावहारिक परीक्षण
मुख्य बात: NDJSON से Stars गिनने वाला वही स्क्रिप्ट मानक json लाइब्रेरी के साथ 754 ms लेता है, पर msgspec के घोषणात्मक डिकोडिंग से सिर्फ़ 146 ms — और मल्टीकोर समानांतरण एक और गुणा जोड़ देता है। यह लेख 61.4 MB और 300,000 पंक्तियों के नमूने पर stdlib, orjson और msgspec को क़दम-दर-क़दम परखता है, और समझाता है कि हर गति-वृद्धि कहाँ से आती है और कब उसकी सीमा आ जाती है।

Python में पार्सिंग को धीमा करने वाला चीज़ कभी JSON टेक्स्ट खुद नहीं होता, बल्कि हर फ़ील्ड को Python ऑब्जेक्ट में बदलने की क़ीमत होती है। डिफ़ॉल्ट पार्सर बदलें, कम ऑब्जेक्ट बनाएँ, सारे कोर इस्तेमाल करें — और वही गिनती का काम 0.08 GB/s से कूदकर दर्जनों GB/s पर पहुँच जाएगा।
एक अवलोकन: वही कोड, एक गुणा का अंतर
काम परिचित है: GitHub Events शैली के NDJSON लॉग में, उन रिकॉर्ड्स में से गिनें कि कौन से रिपॉज़िटरी सबसे ज़्यादा स्टार पाते हैं जिनका type WatchEvent है। अपनी मशीन पर (Ubuntu 22.04, Python 3.12, orjson 3.13, msgspec 0.22) मैंने 61.4 MB और 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.6 GB और 2.2 मिलियन GitHub Archive घटनाओं पर वही सांख्यिकी मानक लाइब्रेरी के साथ 0.28 GB/s पर चली (लगभग 27 सेकंड), msgspec के साथ क़रीब 8 गुना तेज़, और SIMD-आधारित fastsimdjson ने पूरा डेटासेट 192 थ्रेड्स पर 55 ms में निपटाया (138 GB/s), जिसकी एक फ़ाइल पर चरम 277 GB/s तक ऊँचाई थी। ध्यान रहे: उनकी मशीन 192 कोर वाली AWS c8a.metal-48xl है, इसलिए ये संख्याएँ सीधे लैपटॉप पर लागू नहीं होतीं — पर सीढ़ी की आकृति वही है।
मानक लाइब्रेरी समय कहाँ गँवाती है
json.loads पंक्ति-दर-पंक्ति का तरीक़ा हर क़दम पर "पूरा अनुवाद" करता है: पार्सर {"id": 1, "type": "WatchEvent", ...} को सरकता है, उसी एक रिकॉर्ड के लिए नया dict, कम से कम सात str ऑब्जेक्ट और कुछ int बनाता है, और फिर संदर्भ आपके कोड को सौंप देता है। तीन लाख पंक्तियाँ मिलियनों छोटे ऑब्जेक्ट आवंटन बनाती हैं, जिनका अधिकांश आप कभी छूते ही नहीं — गिनती का काम सिर्फ़ दो फ़ील्ड पढ़ता है, type और repo.name।
दूसरी सीमा है GIL। CPython में किसी एक क्षण में केवल एक थ्रेड Python बाइटकोड चलाता है, और पार्सर का C कोड GIL छोड़ भी दे तो लूप के भीतर आपकी छँटाई और जोड़ की तर्क-श्रृंखला क्रमबद्ध ही रहती है। डिफ़ॉल्ट इंटरप्रेटर पर आठ थ्रेड खोलने से कुछ हल नहीं होता; सोच बदलनी पड़ती है।
तेज़ी का पहला सोपान: पार्सर बदलें
यह वह क़दम है जिसमें परिश्रम के मुक़ाबले लाभ सबसे ऊँचा है — बदलाव सिर्फ़ import है:
import json
import orjson
import msgspec
dec = msgspec.json.Decoder()
# तीनों पार्सर का इंटरफ़ेस लगभग एक जैसा है, dumps छोड़कर:
# orjson.dumps(...) str नहीं, bytes लौटाता है
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() str नहीं बल्कि bytes लौटाता है — फ़ाइल लिखते या स्ट्रिंग जोड़ते समय इसका ध्यान रखें।
msgspec का डिफ़ॉल्ट डिकोड orjson की परिसर में ही है (3.8×), पर उसका असली हथियार घोषणात्मक डिकोडिंग है — वह सिर्फ़ घोषित फ़ील्ड्स के लिए Python ऑब्जेक्ट बनाता है:
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 घोषित कर दिया जाता है, WatchEvent न होने वाली 240,000 पंक्तियाँ repo ऑब्जेक्ट बनाने का काम पूरी तरह छोड़ देती हैं और सिर्फ़ टोकन स्कैन करती हैं — 3.8× से 5.2× का उछाल ठीक यहीं से आता है। रिकॉर्ड में फ़ील्ड जितने ज़्यादा और फेंके जाने का हिस्सा जितना बड़ा, यह सोपान उतना ही ज़्यादा देता है।
तेज़ी का दूसरा सोपान: प्रक्रियाओं में बाँटना, पर घटती बचत
एक कोर भर जाने पर रूढ़िवादी उत्तर है प्रोसेस पूल: फ़ाइल को N बाइट-रेंज में बाँटें (पंक्ति-सीमाओं पर मेल खाते हुए), हर टुकड़ा एक वर्कर प्रोसेस को सौंपें, और अंत में Counter जोड़ दें। हर प्रोसेस बस एक छोटी परिणाम-तालिका लौटाती है, इसलिए संवाद की लागत न्यूनतम है — map-reduce का आदर्श रूप।
World Programming के परीक्षण ने इस रास्ते का आकार भी दिखाया: msgspec के प्रोसेस पूल ने 96 प्रोसेस पर 116 GB/s की चोटी पकड़ी, और उससे ज़्यादा प्रोसेस जोड़ने पर बल्कि धीमा हो गया — शेड्यूलिंग और मिलान की लागत ने फ़ायदा निगल लिया। दो व्यावहारिक बाधाएँ लागू होती हैं: टुकड़ों को नई-पंक्ति वर्णों से मिलाना होगा वरना हर टुकड़े की अंतिम पंक्ति पार्स में फेल हो जाएगी; और गिनती के काम (जो छोटा नतीजा लौटाते हैं) प्रोसेस पूल का सबसे अनुकूल मामला हैं। अगर आपको हर रिकॉर्ड निकालकर इस्तेमाल करना है, तो प्रोसेसों के बीच स्थानांतरण खुद नया अवरोध बन जाता है।
तेज़ी का तीसरा सोपान: SIMD और GIL-रहित Python
fastsimdjson दूसरी राह चलता है: एक कोर पर 8 GB/s (msgspec का लगभग 3.5 गुना), क्योंकि यह simdjson की संरचनात्मक अनुक्रमणिका पर टिका है — यह पहले से विराम-चिह्न सरकाकर हर टोकन की जगह तय करता है, पूरा ऑब्जेक्ट-वृक्ष नहीं बनाता; fields=["/type", "/repo/name"] के साथ मिलकर यह केवल घोषित JSON Pointer रास्ते पढ़ता है, और कॉलबैक को बस वही दो मान मिलते हैं।
यह बहु-थ्रेडेड भी है: Python 3.14 के free-threaded बिल्ड के साथ जोड़ने पर (python3.14t, GIL हटाने की PEP 703 की आधिकारिक कोशिश), 192 थ्रेड्स ने 7.6 GB को 55 ms में निपटाया। छह सार्वजनिक बेंचमार्क फ़ाइलों पर, हर एक लगभग 1 GB, चार 100 GB/s पार कर गए और सबसे तेज़, twitter डेटासेट, 277 GB/s तक पहुँचा। याद रखें कि ये विक्रेता के दावों से आगे स्वतंत्र पुनर्मापन हैं, और नमूना सबसे अनुकूल परिदृश्य है — "हर रिकॉर्ड पर एक-दो फ़ील्ड पढ़ना"। गहरे नेस्ट वाले दस्तावेज़ इन संख्याओं तक नहीं पहुँचते; एक फ़ाइल 20 GB/s के आसपास ही रही।
चुनाव की सारणी और अपनाने का क्रम
| रास्ता | तंत्र | थ्रूपुट (स्थानीय/संदर्भ) | किसके लिए सर्वोत्तम |
|---|---|---|---|
json (stdlib) |
पूर्ण ऑब्जेक्ट निर्माण, एक कोर | 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 पर आएँ; देखें jq से बड़ी JSON का स्ट्रीम प्रसंस्करण और बड़ी JSON का पार्सिंग, रेंडरिंग और स्ट्रीमिंग। NDJSON के पंक्ति-आधारित नियमों के लिए देखें JSONL फ़ाइल व्यावहारिक पुस्तिका।
माप की अनुशासन और तीन जाल
पहला, समय-माप की पद्धति तय रखें: इस लेख में हर इम्प्लीमेंटेशन तीन बार चलता है और सबसे अच्छा नतीजा गिना जाता है (शेड्यूलर की कंपन छँटने के लिए), और फ़ाइल माप शुरू होने से पहले पूरी बन चुकी होती है। तीसरे पक्ष की संख्याएँ उद्धृत करते समय मशीन की स्पेसिफ़िकेशन बताएँ — 192 कोर पर 138 GB/s को कभी अपने लैपटॉप के एक कोर से न तुलना करें।
दूसरा, शुद्धता का आड़ा-तिरछा सत्यापन करें: चारों इम्प्लीमेंटेशन की स्टार-गिनती 60,108 ही थी। कोई भी "तेज़ी" जो गिनती बदल दे, उसने पार्सिंग की अर्थ-पद्धति बदली है (डुप्लिकेट कुँजियों का व्यवहार, बड़े पूर्णांकों की शुद्धता), चीज़ें तेज़ नहीं कीं। पहले परिणाम मिलाएँ, फिर गति।
तीसरा, तीन सामान्य जाल: orjson.dumps() bytes लौटाता है, और str से मिलाने पर चुपचाप b'...' उपसर्ग वाला गँदला डेटा बनता है; प्रोसेस पूल के टुकड़े पंक्ति-सीमाओं पर मेल खाएँ — f.seek(offset) के बाद पहले आधी पंक्ति फेंकें; 2^53 से ऊँचे बड़े पूर्णांक हर Python पार्सर में सुरक्षित हैं, पर अगर नतीजा JavaScript पक्ष में जाए, वहाँ शुद्धता की समस्या इंतज़ार कर रही है।
आम सवाल
orjson या msgspec, कौन चुनें?
अगर बस तेज़ loads चाहिए, दोनों 3× या उससे ऊपर देते हैं — रखरखाव की सक्रियता और टीम की परिचिति से चुनें। msgspec चुनें जब आपको आंशिक डिकोडिंग (msgspec.Struct + Raw), प्रकार-जाँच या TypedDict/dataclass आउटपुट चाहिए; उसकी घोषणात्मक डिकोडिंग बड़े ऐरे पर एक और स्वतंत्र लाभ जोड़ती है।
क्या मल्टीप्रोसेस हमेशा एक कोर से तेज़ होता है?
नहीं। बाँटना, प्रोसेस खोलना और जोड़ना — तीनों की निश्चित लागत है, और कुछ दर्जन MB की फ़ाइल पर यह अक्सर घाटा है। बड़े नतीजे लौटाने वाले काम (हर रिकॉर्ड चाहिए) स्थानांतरण में फ़ायदा खो देते हैं। व्यावहारिक नियम: पहले एक कोर पर लाइब्रेरी बदलें, और केवल GB पैमाने पर, शुद्ध गिनती के कामों में समानांतर करें।
मेरे orjson बेंचमार्क में 3× क्यों नहीं दिखता?
तीन आम कारण: नमूना बहुत छोटा है (पार्सिंग का समय फ़ाइल पढ़ने और लूप की लागत में डूब जाता है); असली अवरोध नेटवर्क या डिस्क है, पार्सिंग नहीं; या डेटा लगभग पूरा लंबी स्ट्रिंग्स का है, इसलिए ऑब्जेक्ट बनाने का हिस्सा छोटा है। बड़ा नमूना लें, सिर्फ़ पार्सिंग लूप को time.perf_counter में लपेटें, और तभी निष्कर्ष निकालें।
ijson का इन लाइब्रेरीज़ से क्या संबंध है?
ijson स्ट्रीमिंग इटरेटर है: यह थ्रूपुट का त्याग कर स्थिर मेमोरी पाता है और RAM से बहुत बड़ी फ़ाइलों के लिए उपयुक्त है; orjson/msgspec थ्रूपुट पीछा करते हैं पर हर रिकॉर्ड को ऑब्जेक्ट में बदलते हैं। दोनों में टकराव नहीं: GB पैमाने का NDJSON पंक्ति-दर-पंक्ति पढ़ने और msgspec की तेज़ डिकोडिंग से सुलझ जाता है; ijson या jq --stream केवल एक अकेले विशाल JSON दस्तावेज़ के लिए चाहिए।