Json और simplejson पायथन मॉड्यूल के बीच अंतर क्या हैं?

381

मैंने स्टैंडर्ड लाइब्रेरी से simplejsonमॉड्यूल के बजाय मॉड्यूल का उपयोग करते हुए कई प्रोजेक्ट देखे हैं json। इसके अलावा, कई अलग-अलग simplejsonमॉड्यूल हैं। मानक पुस्तकालय में एक के बजाय, इन विकल्पों का उपयोग क्यों किया जाएगा?

python json simplejson

— लक्ष्मण प्रसाद
स्रोत

391

json है simplejson , stdlib में जोड़ा जाता है। लेकिन चूंकि json2.6 में जोड़ा गया था, इसलिए simplejsonअधिक पायथन संस्करणों (2.4+) पर काम करने का फायदा है।

simplejsonपायथन की तुलना में अधिक बार अपडेट किया जाता है, इसलिए यदि आपको नवीनतम संस्करण की आवश्यकता है (या चाहते हैं), तो इसका उपयोग करना सबसे अच्छा simplejsonहै, यदि संभव हो तो।

एक अच्छा अभ्यास, मेरी राय में, एक या दूसरे को कमबैक के रूप में उपयोग करना है।

try:
    import simplejson as json
except ImportError:
    import json

— डेविन जीनपिएरे
स्रोत

2

अब अगर मैं केवल शिकायतें करना बंद कर सकता हूंredefinition of unused 'json'

— जेम्स मैकमोहन

5

वे समान और न ही संगत नहीं हैं, सिंपलसन के पास JSONDecodeError है और json के पास एक ValueError है

— Bjorn

3

@ ब्योर्नटिप्लिंग JSONDecodeErrorएक उपवर्ग हैValueError

— इलाही

30

मैं उपर्युक्त उत्तर से असहमत हूं, आप पायथन को डेट कर रहे हैं। बिल्ट-इन (महान प्लस !!!) पायसन 2.7 में जोसन लाइब्रेरी सिंपलसन की तरह तेज है और इसमें यूनिकोड बग्स से कम इनकार किया गया है। उत्तर देखें stackoverflow.com/a/16131316/78234

— ताल वीस

1

ऐसा लगता है कि Python2.7 json ने simplejson v2.0.9 को अपनाया है, जो लेखन के रूप में वर्तमान simplejson v3.6.5 से बहुत पीछे है। इम्पोर्ट सिंपलसन के लायक बहुत सारे सुधार हैं

— नोगुची

82

मुझे अन्य उत्तरों से असहमत होना होगा: jsonलाइब्रेरी में बनाया गया (पायथन 2.7 में) जरूरी से ज्यादा धीमा नहीं है simplejson। यह भी इस कष्टप्रद यूनिकोड बग नहीं है ।

यहाँ एक सरल बेंचमार्क है:

import json
import simplejson
from timeit import repeat

NUMBER = 100000
REPEAT = 10

def compare_json_and_simplejson(data):
    """Compare json and simplejson - dumps and loads"""
    compare_json_and_simplejson.data = data
    compare_json_and_simplejson.dump = json.dumps(data)
    assert json.dumps(data) == simplejson.dumps(data)
    result = min(repeat("json.dumps(compare_json_and_simplejson.data)", "from __main__ import json, compare_json_and_simplejson", 
                 repeat = REPEAT, number = NUMBER))
    print "      json dumps {} seconds".format(result)
    result = min(repeat("simplejson.dumps(compare_json_and_simplejson.data)", "from __main__ import simplejson, compare_json_and_simplejson", 
                 repeat = REPEAT, number = NUMBER))
    print "simplejson dumps {} seconds".format(result)
    assert json.loads(compare_json_and_simplejson.dump) == data
    result = min(repeat("json.loads(compare_json_and_simplejson.dump)", "from __main__ import json, compare_json_and_simplejson", 
                 repeat = REPEAT, number = NUMBER))
    print "      json loads {} seconds".format(result)
    result = min(repeat("simplejson.loads(compare_json_and_simplejson.dump)", "from __main__ import simplejson, compare_json_and_simplejson", 
                 repeat = REPEAT, number = NUMBER))
    print "simplejson loads {} seconds".format(result)


print "Complex real world data:" 
COMPLEX_DATA = {'status': 1, 'timestamp': 1362323499.23, 'site_code': 'testing123', 'remote_address': '212.179.220.18', 'input_text': u'ny monday for less than \u20aa123', 'locale_value': 'UK', 'eva_version': 'v1.0.3286', 'message': 'Successful Parse', 'muuid1': '11e2-8414-a5e9e0fd-95a6-12313913cc26', 'api_reply': {"api_reply": {"Money": {"Currency": "ILS", "Amount": "123", "Restriction": "Less"}, "ProcessedText": "ny monday for less than \\u20aa123", "Locations": [{"Index": 0, "Derived From": "Default", "Home": "Default", "Departure": {"Date": "2013-03-04"}, "Next": 10}, {"Arrival": {"Date": "2013-03-04", "Calculated": True}, "Index": 10, "All Airports Code": "NYC", "Airports": "EWR,JFK,LGA,PHL", "Name": "New York City, New York, United States (GID=5128581)", "Latitude": 40.71427, "Country": "US", "Type": "City", "Geoid": 5128581, "Longitude": -74.00597}]}}}
compare_json_and_simplejson(COMPLEX_DATA)
print "\nSimple data:"
SIMPLE_DATA = [1, 2, 3, "asasd", {'a':'b'}]
compare_json_and_simplejson(SIMPLE_DATA)

और मेरे सिस्टम पर परिणाम (पायथन 2.7.4, लिनक्स 64-बिट):

जटिल वास्तविक विश्व डेटा:
जसन 1.56666707993 सेकंड का
सिंपलसन डंप 2.25638604164 सेकंड्स का
जोंस लोड 2.71256899834 सेकंड
सिंपलसन का लोड 1.29233884811 सेकंड

सरल डेटा:
json dumps 0.370109081268 सेकंड्स
simplejson dumps 0.574181079865 सेकंड्स
json लोड 0.422876119614 सेकंड
simplejson लोड 0.270955085754 सेकंड

डंपिंग के लिए, jsonकी तुलना में तेज है simplejson। लोडिंग के लिए, simplejsonतेज है।

चूंकि मैं वर्तमान में एक वेब सेवा का निर्माण कर रहा हूं, dumps()यह अधिक महत्वपूर्ण है- और एक मानक पुस्तकालय का उपयोग करना हमेशा पसंद किया जाता है।

इसके अलावा, cjsonपिछले 4 वर्षों में अपडेट नहीं किया गया था, इसलिए मैं इसे नहीं छूऊंगा।

— ताल वीस
स्रोत

यह भ्रामक है। नीचे मेरा उत्तर बताता है कि क्यों।

— notbad.jpeg

2

मेरे Win7 PC (i7 CPU) पर, json(CPython 3.5.0) 68% है। सरल पर 45% तेज | जटिल डंप और 35% | सरल पर 17% | जटिल भार wr3 simplejsonv3.8.0 के साथ C स्पीडअप अपने बेंचमार्क कोड का उपयोग करते हुए। इसलिए, मैं इस सेटअप के साथ अब सिंपलसन का उपयोग नहीं करूंगा।

— mab

1

मैंने इसे केवल पायथन 3.6.1 पर चलाया और jsonजीत या सभी परीक्षणों के लिए समान है। वास्तव jsonमें जटिल वास्तविक दुनिया डेटा डंप परीक्षण के रूप में तेजी से दो बार के तहत एक छोटा सा है!

— CpILL

27

ये सभी उत्तर बहुत उपयोगी नहीं हैं क्योंकि वे समय के प्रति संवेदनशील हैं ।

अपने खुद के कुछ शोध करने के बाद मैंने पाया कि simplejsonवास्तव में बिलिन से तेज है, अगर आप इसे नवीनतम संस्करण में अपडेट करते हैं।

pip/easy_installubuntu 12.04 पर 2.3.2 स्थापित करना चाहता था, लेकिन नवीनतम simplejsonसंस्करण का पता लगाने के बाद वास्तव में 3.3.0 है, इसलिए मैंने इसे अपडेट किया और समय परीक्षण फिर से शुरू किया।

simplejsonjsonभार पर बिलिन की तुलना में लगभग 3x तेज है
simplejsonjsonडंप पर बिलिन की तुलना में लगभग 30% तेज है

अस्वीकरण:

उपरोक्त कथन अजगर -२. statements.३ और सिंपलिसन ३.३.० (सी स्पीडअप के साथ) में हैं और यह सुनिश्चित करने के लिए कि मेरा उत्तर भी समय के प्रति संवेदनशील नहीं है, आपको यह जाँचने के लिए अपने परीक्षण चलाने चाहिए क्योंकि यह संस्करणों के बीच बहुत भिन्न होता है; कोई आसान जवाब नहीं है जो समय के प्रति संवेदनशील नहीं है।

कैसे बताएं कि क्या सी स्पीडअप सरलता में सक्षम हैं:

import simplejson
# If this is True, then c speedups are enabled.
print bool(getattr(simplejson, '_speedups', False))

अद्यतन: मैं हाल ही में ujson नामक एक पुस्तकालय में आया था जो simplejsonकुछ बुनियादी परीक्षणों की तुलना में ~ 3x तेज प्रदर्शन कर रहा है ।

— notbad.jpeg
स्रोत

Ujson का उल्लेख करने के लिए धन्यवाद। यह मुझे एक और लाइब्रेरी रैपिडजन्स की ओर ले जाता है जो बेहतर बनाए रखता है

— MCMZL

"simplejson 3.3.0 (सी स्पीडअप के साथ)" ओह सच में? एक और अधिक ईमानदार बनें और बिना सी स्पीडअप के इसका परीक्षण करें।

— रीशिन

ujson का उपयोग न करें, यह बग्स और मेमोरी लीक और क्रैशर्स से अटे पड़े हैं और काफी समय में अपडेट नहीं किए गए हैं। हमने इसे खाई है और सिंपलसन पर स्विच कर दिया है क्योंकि इसमें जसन की तुलना में अधिक कार्यक्षमता है और इसे अपडेट किया गया है

— amohr

21

मैं json, simplejson और cjson बेंचमार्किंग कर रहा हूं।

cjson सबसे तेज है
simplejson लगभग cjson के बराबर है
json सिम्पसन की तुलना में लगभग 10x धीमा है

http://pastie.org/1507411 :

$ python test_serialization_speed.py 
--------------------
   Encoding Tests
--------------------
Encoding: 100000 x {'m': 'asdsasdqwqw', 't': 3}
[      json] 1.12385 seconds for 100000 runs. avg: 0.011239ms
[simplejson] 0.44356 seconds for 100000 runs. avg: 0.004436ms
[     cjson] 0.09593 seconds for 100000 runs. avg: 0.000959ms

Encoding: 10000 x {'m': [['0', 1, '2', 3, '4', 5, '6', 7, '8', 9, '10', 11, '12', 13, '14', 15, '16', 17, '18', 19], ['0', 1, '2', 3, '4', 5, '6', 7, '8', 9, '10', 11, '12', 13, '14', 15, '16', 17, '18', 19], ['0', 1, '2', 3, '4', 5, '6', 7, '8', 9, '10', 11, '12', 13, '14', 15, '16', 17, '18', 19], ['0', 1, '2', 3, '4', 5, '6', 7, '8', 9, '10', 11, '12', 13, '14', 15, '16', 17, '18', 19], ['0', 1, '2', 3, '4', 5, '6', 7, '8', 9, '10', 11, '12', 13, '14', 15, '16', 17, '18', 19], ['0', 1, '2', 3, '4', 5, '6', 7, '8', 9, '10', 11, '12', 13, '14', 15, '16', 17, '18', 19], ['0', 1, '2', 3, '4', 5, '6', 7, '8', 9, '10', 11, '12', 13, '14', 15, '16', 17, '18', 19], ['0', 1, '2', 3, '4', 5, '6', 7, '8', 9, '10', 11, '12', 13, '14', 15, '16', 17, '18', 19], ['0', 1, '2', 3, '4', 5, '6', 7, '8', 9, '10', 11, '12', 13, '14', 15, '16', 17, '18', 19], ['0', 1, '2', 3, '4', 5, '6', 7, '8', 9, '10', 11, '12', 13, '14', 15, '16', 17, '18', 19], ['0', 1, '2', 3, '4', 5, '6', 7, '8', 9, '10', 11, '12', 13, '14', 15, '16', 17, '18', 19], ['0', 1, '2', 3, '4', 5, '6', 7, '8', 9, '10', 11, '12', 13, '14', 15, '16', 17, '18', 19], ['0', 1, '2', 3, '4', 5, '6', 7, '8', 9, '10', 11, '12', 13, '14', 15, '16', 17, '18', 19], ['0', 1, '2', 3, '4', 5, '6', 7, '8', 9, '10', 11, '12', 13, '14', 15, '16', 17, '18', 19], ['0', 1, '2', 3, '4', 5, '6', 7, '8', 9, '10', 11, '12', 13, '14', 15, '16', 17, '18', 19], ['0', 1, '2', 3, '4', 5, '6', 7, '8', 9, '10', 11, '12', 13, '14', 15, '16', 17, '18', 19], ['0', 1, '2', 3, '4', 5, '6', 7, '8', 9, '10', 11, '12', 13, '14', 15, '16', 17, '18', 19], ['0', 1, '2', 3, '4', 5, '6', 7, '8', 9, '10', 11, '12', 13, '14', 15, '16', 17, '18', 19], ['0', 1, '2', 3, '4', 5, '6', 7, '8', 9, '10', 11, '12', 13, '14', 15, '16', 17, '18', 19], ['0', 1, '2', 3, '4', 5, '6', 7, '8', 9, '10', 11, '12', 13, '14', 15, '16', 17, '18', 19]], 't': 3}
[      json] 7.76628 seconds for 10000 runs. avg: 0.776628ms
[simplejson] 0.51179 seconds for 10000 runs. avg: 0.051179ms
[     cjson] 0.44362 seconds for 10000 runs. avg: 0.044362ms

--------------------
   Decoding Tests
--------------------
Decoding: 100000 x {"m": "asdsasdqwqw", "t": 3}
[      json] 3.32861 seconds for 100000 runs. avg: 0.033286ms
[simplejson] 0.37164 seconds for 100000 runs. avg: 0.003716ms
[     cjson] 0.03893 seconds for 100000 runs. avg: 0.000389ms

Decoding: 10000 x {"m": [["0", 1, "2", 3, "4", 5, "6", 7, "8", 9, "10", 11, "12", 13, "14", 15, "16", 17, "18", 19], ["0", 1, "2", 3, "4", 5, "6", 7, "8", 9, "10", 11, "12", 13, "14", 15, "16", 17, "18", 19], ["0", 1, "2", 3, "4", 5, "6", 7, "8", 9, "10", 11, "12", 13, "14", 15, "16", 17, "18", 19], ["0", 1, "2", 3, "4", 5, "6", 7, "8", 9, "10", 11, "12", 13, "14", 15, "16", 17, "18", 19], ["0", 1, "2", 3, "4", 5, "6", 7, "8", 9, "10", 11, "12", 13, "14", 15, "16", 17, "18", 19], ["0", 1, "2", 3, "4", 5, "6", 7, "8", 9, "10", 11, "12", 13, "14", 15, "16", 17, "18", 19], ["0", 1, "2", 3, "4", 5, "6", 7, "8", 9, "10", 11, "12", 13, "14", 15, "16", 17, "18", 19], ["0", 1, "2", 3, "4", 5, "6", 7, "8", 9, "10", 11, "12", 13, "14", 15, "16", 17, "18", 19], ["0", 1, "2", 3, "4", 5, "6", 7, "8", 9, "10", 11, "12", 13, "14", 15, "16", 17, "18", 19], ["0", 1, "2", 3, "4", 5, "6", 7, "8", 9, "10", 11, "12", 13, "14", 15, "16", 17, "18", 19], ["0", 1, "2", 3, "4", 5, "6", 7, "8", 9, "10", 11, "12", 13, "14", 15, "16", 17, "18", 19], ["0", 1, "2", 3, "4", 5, "6", 7, "8", 9, "10", 11, "12", 13, "14", 15, "16", 17, "18", 19], ["0", 1, "2", 3, "4", 5, "6", 7, "8", 9, "10", 11, "12", 13, "14", 15, "16", 17, "18", 19], ["0", 1, "2", 3, "4", 5, "6", 7, "8", 9, "10", 11, "12", 13, "14", 15, "16", 17, "18", 19], ["0", 1, "2", 3, "4", 5, "6", 7, "8", 9, "10", 11, "12", 13, "14", 15, "16", 17, "18", 19], ["0", 1, "2", 3, "4", 5, "6", 7, "8", 9, "10", 11, "12", 13, "14", 15, "16", 17, "18", 19], ["0", 1, "2", 3, "4", 5, "6", 7, "8", 9, "10", 11, "12", 13, "14", 15, "16", 17, "18", 19], ["0", 1, "2", 3, "4", 5, "6", 7, "8", 9, "10", 11, "12", 13, "14", 15, "16", 17, "18", 19], ["0", 1, "2", 3, "4", 5, "6", 7, "8", 9, "10", 11, "12", 13, "14", 15, "16", 17, "18", 19], ["0", 1, "2", 3, "4", 5, "6", 7, "8", 9, "10", 11, "12", 13, "14", 15, "16", 17, "18", 19]], "t": 3}
[      json] 37.26270 seconds for 10000 runs. avg: 3.726270ms
[simplejson] 0.56643 seconds for 10000 runs. avg: 0.056643ms
[     cjson] 0.33007 seconds for 10000 runs. avg: 0.033007ms

— क्रिस
स्रोत

6

कृपया वास्तविक परीक्षण मॉड्यूल के लिए एक पेस्टी जोड़ें।

— ताल वीस

4

पायथन के कौन से संस्करण और विचाराधीन है?

— एंथ्रोपिक

6

यह अब सच नहीं है। jy in python2.7 प्रदर्शन में सुधार है।

— ज़ेनगर

11

कुछ मूल्यों को सिंपलसन और जोंस के बीच अलग-अलग क्रमबद्ध किया जाता है।

विशेष रूप से, उदाहरणों collections.namedtupleको सरणियों के रूप में jsonलेकिन द्वारा वस्तुओं के रूप में क्रमबद्ध किया जाता है simplejson। आप पारित करके इस व्यवहार को ओवरराइड कर सकते हैं namedtuple_as_object=Falseकरने के लिए simplejson.dumpहै, लेकिन डिफ़ॉल्ट रूप से व्यवहार से मेल नहीं खाते।

>>> import collections, simplejson, json
>>> TupleClass = collections.namedtuple("TupleClass", ("a", "b"))
>>> value = TupleClass(1, 2)
>>> json.dumps(value)
'[1, 2]'
>>> simplejson.dumps(value)
'{"a": 1, "b": 2}'
>>> simplejson.dumps(value, namedtuple_as_object=False)
'[1, 2]'

— pfhayes
स्रोत

7

एक एपीआई असंगति मुझे मिली, पायथन 2.7 बनाम सिंपलजसन 3.3.1 के साथ है कि क्या आउटपुट स्ट्रोड या यूनिकोड ऑब्जेक्ट का उत्पादन करता है। जैसे

>>> from json import JSONDecoder
>>> jd = JSONDecoder()
>>> jd.decode("""{ "a":"b" }""")
{u'a': u'b'}

बनाम

>>> from simplejson import JSONDecoder
>>> jd = JSONDecoder()
>>> jd.decode("""{ "a":"b" }""")
{'a': 'b'}

यदि वरीयता सिंपलजसन का उपयोग करने की है, तो इसे यूनिकोड में तर्क स्ट्रिंग के साथ जोड़कर संबोधित किया जा सकता है, जैसे कि:

>>> from simplejson import JSONDecoder
>>> jd = JSONDecoder()
>>> jd.decode(unicode("""{ "a":"b" }""", "utf-8"))
{u'a': u'b'}

उदाहरण के लिए जबरदस्ती के लिए मूल चरक जानना आवश्यक है:

>>> jd.decode(unicode("""{ "a": "ξηθννββωφρες" }"""))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
UnicodeDecodeError: 'ascii' codec can't decode byte 0xce in position 8: ordinal not in range(128)

यह समस्या 40 को ठीक नहीं करेगा

— JJC
स्रोत

6

एक अन्य कारण परियोजनाओं का उपयोग करना सरल है, यह है कि बिल्ट जोंसन ने मूल रूप से अपने सी स्पीडअप को शामिल नहीं किया था, इसलिए प्रदर्शन अंतर ध्यान देने योग्य था।

— ए। कोदि
स्रोत

5

बिलियन jsonमॉड्यूल को पायथन 2.6 में शामिल किया गया। पायथन <2.6 के संस्करणों का समर्थन करने वाली किसी भी परियोजना को कमबैक की आवश्यकता है। कई मामलों में, यह गिरावट है simplejson।

— thedz
स्रोत

4

यहाँ है (अब एक पुराना) पायथन जसन पुस्तकालयों की तुलना:

पायथन के लिए JSON मॉड्यूल की तुलना ( संग्रह लिंक )

इस तुलना में परिणाम के बावजूद, यदि आप पायथन 2.6 पर हैं, तो आपको मानक लाइब्रेरी जोंस का उपयोग करना चाहिए। और .. के रूप में अच्छी तरह से सिर्फ simplejson अन्यथा का उपयोग कर सकते हैं।

— वन गेल
स्रोत

2

सिंपलसन मॉड्यूल जोंस की तुलना में केवल 1,5 गुना तेज है (मेरे कंप्यूटर पर, सिंपलसन 2.1.1 और पायथन 2.7 x86 के साथ)।

यदि आप चाहते हैं, तो आप बेंचमार्क आज़मा सकते हैं: http://abral.altervista.org/jsonpickle-bench.zip मेरे पीसी पर सिंपलसन cPickle से अधिक तेज़ है। मैं आपके बेंचमार्क भी जानना चाहूंगा!

शायद, जैसा कि कहा जाता है, कोअडी, सिम्पसन और जोंस के बीच का अंतर यह है कि सिंपलसन में _speedups.c शामिल है। तो, अजगर डेवलपर्स simplejson का उपयोग क्यों नहीं करते हैं?

— Jeko
स्रोत

2

Python3 में, यदि आप इसे लोड करने से पहले सामग्री के b'bytes'साथ, jsonआपके पास एक स्ट्रिंग .decode()है। simplejsonइस का ध्यान रखता है ताकि आप बस कर सकें simplejson.loads(byte_string)।

— voidnologo
स्रोत

संस्करण 3.6 में बदला: s अब प्रकार बाइट्स या बायट्रेयर का हो सकता है। इनपुट एन्कोडिंग UTF-8, UTF-16 या UTF-32 होनी चाहिए।

— मैथ्यू लॉन्गटिन

1

jsonsimplejsonनवीनतम संस्करण में लोड और डंप दोनों के मामलों की तुलना में तेज़ी से लगता है

परीक्षण किए गए संस्करण:

अजगर: 3.6.8
json: 2.0.9
simplejson: 3.16.0

परिणाम:

>>> def test(obj, call, data, times):
...   s = datetime.now()
...   print("calling: ", call, " in ", obj, " ", times, " times") 
...   for _ in range(times):
...     r = getattr(obj, call)(data)
...   e = datetime.now()
...   print("total time: ", str(e-s))
...   return r

>>> test(json, "dumps", data, 10000)
calling:  dumps  in  <module 'json' from 'C:\\Users\\jophine.antony\\AppData\\Local\\Programs\\Python\\Python36-32\\lib\\json\\__init__.py'>   10000  times
total time:  0:00:00.054857

>>> test(simplejson, "dumps", data, 10000)
calling:  dumps  in  <module 'simplejson' from 'C:\\Users\\jophine.antony\\AppData\\Local\\Programs\\Python\\Python36-32\\lib\\site-packages\\simplejson\\__init__.py'>   10000  times
total time:  0:00:00.419895
'{"1": 100, "2": "acs", "3.5": 3.5567, "d": [1, "23"], "e": {"a": "A"}}'

>>> test(json, "loads", strdata, 1000)
calling:  loads  in  <module 'json' from 'C:\\Users\\jophine.antony\\AppData\\Local\\Programs\\Python\\Python36-32\\lib\\json\\__init__.py'>   1000  times
total time:  0:00:00.004985
{'1': 100, '2': 'acs', '3.5': 3.5567, 'd': [1, '23'], 'e': {'a': 'A'}}

>>> test(simplejson, "loads", strdata, 1000)
calling:  loads  in  <module 'simplejson' from 'C:\\Users\\jophine.antony\\AppData\\Local\\Programs\\Python\\Python36-32\\lib\\site-packages\\simplejson\\__init__.py'>   1000  times
total time:  0:00:00.040890
{'1': 100, '2': 'acs', '3.5': 3.5567, 'd': [1, '23'], 'e': {'a': 'A'}}

संस्करणों के लिए:

अजगर: 3.7.4
json: 2.0.9
simplejson: 3.17.0

डंप ऑपरेशन के दौरान जसन सिंपलसन की तुलना में तेज था, लेकिन दोनों ने लोड संचालन के दौरान समान गति बनाए रखी

— jophine
स्रोत

0

मुझे इस सवाल का पता चला क्योंकि मैं पाइथन 2.6 के लिए सिंपलसन स्थापित करना चाह रहा था। मुझे json.load () के 'object_pairs_hook' का उपयोग करने की आवश्यकता थी ताकि ऑर्डर की गई डिक्शनरी के रूप में एक json फाइल लोड की जा सके। पायथन के अधिक हाल के संस्करणों से परिचित होने के कारण मुझे यह महसूस नहीं हुआ कि पायथन 2.6 के लिए json मॉड्यूल में 'object_pairs_hook' शामिल नहीं है, इसलिए मुझे इस उद्देश्य के लिए सिम्पसन को स्थापित करना पड़ा। व्यक्तिगत अनुभव से यही कारण है कि मैं मानक जोन मॉड्यूल के विपरीत सिम्पसन का उपयोग करता हूं।

— BeeLabeille
स्रोत