Python Language
JSON मॉड्यूल

टिप्पणियों

# my_json module

import json
from functools import partial

def serialise_object(obj):
    # Do something to produce json-serialisable data
    return dict_obj

dump = partial(json.dump, default=serialise_object)
dumps = partial(json.dumps, default=serialise_object)

# my_json module

import json
from functools import partial

def deserialise_object(dict_obj):
    # Do something custom
    return obj

def deserialise_float(str_obj):
    # Do something custom
    return obj

load = partial(json.load, object_hook=deserialise_object, parse_float=deserialise_float)
loads = partial(json.loads, object_hook=deserialise_object, parse_float=deserialise_float)

# my_json module

import json
from functools import partial

class MyEncoder(json.JSONEncoder):
    # Do something custom

class MyDecoder(json.JSONDecoder):
    # Do something custom

dump = partial(json.dump, cls=MyEncoder)
dumps = partial(json.dumps, cls=MyEncoder)
load = partial(json.load, cls=MyDecoder)
loads = partial(json.loads, cls=MyDecoder)

पाइथन से JSON बनाना तानाशाह

import json
d = {
    'foo': 'bar',
    'alice': 1,
    'wonderland': [1, 2, 3]
}
json.dumps(d)

उपरोक्त स्निपेट निम्नलिखित को वापस करेगा:

'{"wonderland": [1, 2, 3], "foo": "bar", "alice": 1}'

JSON से पाइथन को तानाशाह बनाना

import json
s = '{"wonderland": [1, 2, 3], "foo": "bar", "alice": 1}'
json.loads(s)

उपरोक्त स्निपेट निम्नलिखित को वापस करेगा:

{u'alice': 1, u'foo': u'bar', u'wonderland': [1, 2, 3]}

किसी फ़ाइल में डेटा संग्रहीत करना

निम्न स्निपेट JSON में d में संग्रहीत डेटा को एन्कोड करता है और इसे एक फ़ाइल में संग्रहीत करता है ( filename का वास्तविक नाम के साथ filename बदलें)।

import json

d = {
    'foo': 'bar',
    'alice': 1,
    'wonderland': [1, 2, 3]
}

with open(filename, 'w') as f:
    json.dump(d, f)

किसी फ़ाइल से डेटा पुनर्प्राप्त करना

निम्न स्निपेट एक JSON एन्कोडेड फ़ाइल ( filename का वास्तविक नाम के साथ filename बदलें) को खोलता है और फ़ाइल में संग्रहीत ऑब्जेक्ट को वापस करता है।

import json

with open(filename, 'r') as f:
    d = json.load(f)

`लोड` बनाम` लोड`, `डंप` बनाम` डिप्स`

json मॉड्यूल में यूनिकोड स्ट्रिंग्स से पढ़ने और लिखने और फ़ाइलों से और पढ़ने और लिखने दोनों के लिए फ़ंक्शंस होते हैं। ये फ़ंक्शन नाम में एक अनुगामी s द्वारा विभेदित हैं। इन उदाहरणों में हम एक स्ट्रिंग ऑब्जेक्ट का उपयोग करते हैं, लेकिन वही फ़ंक्शन किसी भी फ़ाइल जैसी ऑब्जेक्ट के लिए लागू होगा।

यहां हम स्ट्रिंग-आधारित कार्यों का उपयोग करते हैं:

import json

data = {u"foo": u"bar", u"baz": []}
json_string = json.dumps(data)
# u'{"foo": "bar", "baz": []}'
json.loads(json_string)
# {u"foo": u"bar", u"baz": []}

और यहां हम फ़ाइल-आधारित फ़ंक्शन का उपयोग करते हैं:

import json

from io import StringIO

json_file = StringIO()
data = {u"foo": u"bar", u"baz": []}
json.dump(data, json_file)
json_file.seek(0)  # Seek back to the start of the file before reading
json_file_content = json_file.read()
# u'{"foo": "bar", "baz": []}'
json_file.seek(0)  # Seek back to the start of the file before reading
json.load(json_file)
# {u"foo": u"bar", u"baz": []}

जैसा कि आप देख सकते हैं कि मुख्य अंतर यह है कि जब जसन डेटा डंप करते हैं तो आपको फंक्शन को फाइल हैंडल को पास करना होगा, जैसा कि रिटर्न वैल्यू पर कब्जा करने के लिए है। यह भी ध्यान देने योग्य है कि डेटा भ्रष्टाचार से बचने के लिए, आपको पढ़ने या लिखने से पहले फ़ाइल की शुरुआत करनी चाहिए। फ़ाइल खोलते समय कर्सर को 0 स्थिति में रखा जाता है, इसलिए नीचे भी काम किया जाएगा:

import json

json_file_path = './data.json'
data = {u"foo": u"bar", u"baz": []}

with open(json_file_path, 'w') as json_file:
    json.dump(data, json_file)

with open(json_file_path) as json_file:
    json_file_content = json_file.read()
    # u'{"foo": "bar", "baz": []}'

with open(json_file_path) as json_file:
    json.load(json_file)
    # {u"foo": u"bar", u"baz": []}

Json डेटा से निपटने के दोनों तरीके होने से आप मुहावरेदार और कुशलता से उन स्वरूपों के साथ काम कर सकते हैं, जो json पर निर्मित होते हैं, जैसे pyspark का json-per-line:

# loading from a file
data = [json.loads(line) for line in open(file_path).splitlines()]

# dumping to a file
with open(file_path, 'w') as json_file:
    for item in data:
        json.dump(item, json_file)
        json_file.write('\n')

JSON आउटपुट को प्रिंट करने के लिए कमांड लाइन से `json.tool` कॉल करना

कुछ JSON फ़ाइल "foo.json" को देखते हुए जैसे:

{"foo": {"bar": {"baz": 1}}}

हम कमांड लाइन से सीधे मॉड्यूल को कॉल कर सकते हैं (फ़ाइलनाम को एक तर्क के रूप में पारित कर सकते हैं) इसे सुंदर प्रिंट करें:

$ python -m json.tool foo.json
{
    "foo": {
        "bar": {
            "baz": 1
        }
    }
}

मॉड्यूल STDOUT से भी इनपुट लेगा, इसलिए (बाश में) हम समान रूप से कर सकते हैं:

$ cat foo.json | python -m json.tool

JSON आउटपुट स्वरूपण

मान लें कि हमारे पास निम्नलिखित डेटा हैं:

>>> data = {"cats": [{"name": "Tubbs", "color": "white"}, {"name": "Pepper", "color": "black"}]}

बस इसे डंपिंग के रूप में JSON यहाँ कुछ विशेष नहीं करता है:

>>> print(json.dumps(data))
{"cats": [{"name": "Tubbs", "color": "white"}, {"name": "Pepper", "color": "black"}]}

Prettier आउटपुट पाने के लिए इंडेंटेशन सेट करना

यदि हम सुंदर मुद्रण चाहते हैं, तो हम एक indent आकार सेट कर सकते हैं:

>>> print(json.dumps(data, indent=2))
{
  "cats": [
    {
      "name": "Tubbs",
      "color": "white"
    },
    {
      "name": "Pepper",
      "color": "black"
    }
  ]
}

लगातार आउटपुट प्राप्त करने के लिए वर्णमाला की तरह छँटाई करना

डिफ़ॉल्ट रूप से आउटपुट में कुंजियों का क्रम अपरिभाषित होता है। हम उन्हें वर्णमाला क्रम में प्राप्त कर सकते हैं यह सुनिश्चित करने के लिए कि हम हमेशा एक ही आउटपुट प्राप्त करें:

>>> print(json.dumps(data, sort_keys=True))
{"cats": [{"color": "white", "name": "Tubbs"}, {"color": "black", "name": "Pepper"}]}

कॉम्पैक्ट आउटपुट पाने के लिए व्हाट्सएप से छुटकारा

हम अनावश्यक रिक्त स्थान से छुटकारा पाना चाहते हैं, जो कि डिफॉल्ट से अलग विभाजक तारों को सेट करके किया जाता है ', ' और ': ' :

>>>print(json.dumps(data, separators=(',', ':')))
{"cats":[{"name":"Tubbs","color":"white"},{"name":"Pepper","color":"black"}]}

JSON कस्टम ऑब्जेक्ट एन्कोडिंग

यदि हम निम्नलिखित प्रयास करें:

import json
from datetime import datetime
data = {'datetime': datetime(2016, 9, 26, 4, 44, 0)}
print(json.dumps(data))

हमें TypeError: datetime.datetime(2016, 9, 26, 4, 44) is not JSON serializable एरर कहते हुए एक त्रुटि मिलती है TypeError: datetime.datetime(2016, 9, 26, 4, 44) is not JSON serializable ।

डेटाटाइम ऑब्जेक्ट को ठीक से अनुक्रमित करने में सक्षम होने के लिए, हमें इसे परिवर्तित करने के लिए कस्टम कोड लिखने की आवश्यकता है:

class DatetimeJSONEncoder(json.JSONEncoder):
    def default(self, obj):
        try:
            return obj.isoformat()
        except AttributeError:
            # obj has no isoformat method; let the builtin JSON encoder handle it
            return super(DatetimeJSONEncoder, self).default(obj)

और फिर json.dumps बजाय इस एनकोडर वर्ग का उपयोग करें:

encoder = DatetimeJSONEncoder()
print(encoder.encode(data))
# prints {"datetime": "2016-09-26T04:44:00"}