Ошибка десериализации json python

Нужно реализовать key-value хранилище, при получении значения по ключу выдает ошибку :

Traceback (most recent call last):

File "storage.py", line 36, in <module>
json_data = json.load(f)  

File "/usr/lib/python3.6/json/__init__.py", line 299, in load
parse_constant=parse_constant, object_pairs_hook=object_pairs_hook, **kw)

File "/usr/lib/python3.6/json/__init__.py", line 354, in loads
return _default_decoder.decode(s)

File "/usr/lib/python3.6/json/decoder.py", line 342, in decode
raise JSONDecodeError("Extra data", s, end)

json.decoder.JSONDecodeError: Extra data: line 1 column 5 (char 4)

Программа:

import os, sys, argparse, json, tempfile

def get_key(d, key):
    for v, k in d.keys():
        if k == key:
            return v


parser = argparse.ArgumentParser()
parser.add_argument('--key', dest = 'key_name')
parser.add_argument('--val', dest = 'value')

args = parser.parse_args()

my_dict = {}
storage_path = os.path.join(tempfile.gettempdir(), 'storage.data')
if os.path.isfile(u'/tmp/storage.data') == False:            
    if args.key_name != None:
        if args.value != None: 
            with open(storage_path, 'w') as f:
                json_dp = json.dump(my_dict.update([(args.key_name,args.value)]),f)
    else:
        print(None)
else:
    if args.key_name != None: 
        if args.value != None:  
            with open(storage_path, 'a') as f: 
                json_dp = json.dump(my_dict.update([(args.key_name,args.value)]), f) 

        else: 
            with open(storage_path, 'r') as f: 
               json_data = json.load(f)   
               print(get_key(json_data, args.key_name))                       

{
[
{
«id»:1,
«Рус. Название»:»Храм Василия Блаженного»,
«Англ. Название»:»St. Basil’s Cathedral»,
«Категория»:»Объект Красной Площади»,
«Рус. Wiki»:»https://ru.wikipedia.org/wiki/Храм_Василия_Блаженного»,
«Англ. Wiki»:»https://en.wikipedia.org/wiki/Saint_Basil%27s_Cathedral»,
«Адрес»:»Красная площадь, 7″,
«Координаты»:»55.75253278804399,37.62309622086314″
},
{
«id»:2,
«Рус. Название»:»Памятник Минину и Пожарскому»,
«Англ. Название»:»Monument to Minin and Pozharsky»,
«Категория»:»Объект Красной Площади»,
«Рус. Wiki»:»https://ru.wikipedia.org/wiki/Памятник_Минину_и_По…»,
«Англ. Wiki»:»https://en.wikipedia.org/wiki/Monument_to_Minin_an…»,
«Адрес»:»Красная площадь, 7″,
«Координаты»:»55.75278691817848,37.622645609748645″
},
{
«id»:3,
«Рус. Название»:»Спасская башня»,
«Англ. Название»:»Spasskaya Tower»,
«Категория»:»Объект Красной Площади»,
«Рус. Wiki»:»https://ru.wikipedia.org/wiki/Спасская_башня»,
«Англ. Wiki»:»https://en.wikipedia.org/wiki/Spasskaya_Tower»,
«Адрес»:»Тверской район, Кремль, 12″,
«Координаты»:»55.75263262508084,37.62150298870831″
},
{
«id»:4,
«Рус. Название»:»Лобное место на Красной Площади»,
«Англ. Название»:»Lobnoye mesto»,
«Категория»:»Объект Красной Площади»,
«Рус. Wiki»:»https://ru.wikipedia.org/wiki/Лобное_место»,
«Англ. Wiki»:»https://en.wikipedia.org/wiki/Lobnoye_Mesto»,
«Адрес»:»Красная площадь»,
«Координаты»:»55.753216515339,37.62251149929791″
},
{
«id»:5,
«Рус. Название»:»Мавзолей Ленина»,
«Англ. Название»:»Lenin’s Mausoleum»,
«Категория»:»Объект Красной Площади»,
«Рус. Wiki»:»https://ru.wikipedia.org/wiki/Мавзолей_Ленина»,
«Англ. Wiki»:»https://en.wikipedia.org/wiki/Lenin%27s_Mausoleum»,
«Адрес»:»Красная площадь»,
«Координаты»:»55.7537349753831,37.61993877843665″
},
{
«id»:6,
«Рус. Название»:»ГУМ»,
«Англ. Название»:»GUM»,
«Категория»:»Объект Красной Площади»,
«Рус. Wiki»:»https://ru.wikipedia.org/wiki/ГУМ»,
«Англ. Wiki»:»https://en.wikipedia.org/wiki/GUM_(department_store)»,
«Адрес»:»Красная площадь, 3″,
«Координаты»:»55.75452047240065,37.621000934165615″
},
{
«id»:8,
«Рус. Название»:»Столовая № 57 «,
«Англ. Название»:»Dining room No. 57″,
«Категория»:»Объект Красной Площади»,
«Рус. Wiki»:»»,
«Англ. Wiki»:»»,
«Адрес»:»Красная площадь, 3″,
«Координаты»:»55.754176181320865,37.623260171748136″
},
{
«id»:9,
«Рус. Название»:»Казанский собор»,
«Англ. Название»:»Kazan Cathedral»,
«Категория»:»Объект Красной Площади»,
«Рус. Wiki»:»https://ru.wikipedia.org/wiki/Казанский_собор_(Москва)»,
«Англ. Wiki»:»https://en.wikipedia.org/wiki/Kazan_Cathedral,_Moscow»,
«Адрес»:»Никольская улица, 3″,
«Координаты»:»55.75539606348181,37.61918185441502″
},
{
«id»:10,
«Рус. Название»:»Исторический музей «,
«Англ. Название»:»Historical Museum»,
«Категория»:»Объект Красной Площади»,
«Рус. Wiki»:»https://ru.wikipedia.org/wiki/Государственный_исто…»,
«Англ. Wiki»:»https://en.wikipedia.org/wiki/State_Historical_Museum»,
«Адрес»:»Красная площадь, 1″,
«Координаты»:»55.755393354751924,37.61799095361239″
},
{
«id»:11,
«Рус. Название»:»Воскресенские ворота»,
«Англ. Название»:»Resurrection Gate»,
«Категория»:»Объект Красной Площади»,
«Рус. Wiki»:»https://ru.wikipedia.org/wiki/Воскресенские_ворота»,
«Англ. Wiki»:»https://en.wikipedia.org/wiki/Iberian_Gate_and_Chapel»,
«Адрес»:»проезд Воскресенские Ворота, 1А»,
«Координаты»:»55.75566505507187,37.618045211312165″
},
{
«id»:12,
«Рус. Название»:»Нулевой километр»,
«Англ. Название»:»Kilometre Zero»,
«Категория»:»Объект Красной Площади»,
«Рус. Wiki»:»»,
«Англ. Wiki»:»»,
«Адрес»:»проезд Воскресенские Ворота»,
«Координаты»:»55.75582236123602,37.61769652414025″
},
{
«id»:13,
«Рус. Название»:»Александровский сад «,
«Англ. Название»:»Alexander Garden»,
«Категория»:»Объект Красной Площади»,
«Рус. Wiki»:»https://ru.wikipedia.org/wiki/Александровский_сад_…»,
«Англ. Wiki»:»https://en.wikipedia.org/wiki/Alexander_Garden»,
«Адрес»:»Александровский сад»,
«Координаты»:»55.75211610144802,37.613610828416256″
},
{
«id»:15,
«Рус. Название»:»Охотный ряд «,
«Англ. Название»:»Okhotny Ryad»,
«Категория»:»Объект Красной Площади»,
«Рус. Wiki»:»https://ru.wikipedia.org/wiki/Охотный_Ряд»,
«Англ. Wiki»:»»,
«Адрес»:»пл. Манежная, д. 1, стр. 2″,
«Координаты»:»55.755758,37.61468″
}
]
}

Are you looking for a simple way to fix Object of type ARandomClass is not JSON serializable where ARandomClass is a built-in Python object or a custom class you’ve defined on your own. You’re probably trying to encode a Python object to a JSON formatted string. In this article, we will show you a few cases where this error would happen, and how to avoid it in the future.

“Object of type is not JSON serializable” is a common error message in Python. It basically says that the built-in json module cannot transform the current object type into a JSON-formatted string.

The built-in json module of Python can only handle basic Python objects such as dictionaries, lists, strings, numbers, None, etc. Below is a table of how native Python objects are translated to JSON.

Now you have two options to handle Object of type is not JSON serializable

• Create a custom JSON decoder for the object type of your choice. (https://pynative.com/make-python-class-json-serializable/)
• Fix your script so that it returns one of the Python primitives mentioned above.

Decode bytes to string before serialization

If you’re seeing something like “Object of type bytes is not JSON serializable”, it means that json module has failed to convert a bytes object into JSON formatted string. What you have to do is either removing string.encode() calls or adding string.decode() to make sure that json.dumps() only takes in raw string as input. Consider the code below:

import json
bytes_object = 'mystring'.encode('utf-8')
json_str = json.dumps({'message': bytes_object})
Code language: Python (python)

In the code snippet, we’ve tried passing a bytes object into json.dumps, which will eventually result in “TypeError: Object of type ‘bytes’ is not JSON serializable”. In order to get rid of it, we can either remove the string.encode() call or add a string.decode() call before actually serialize the object.

Writing a custom JSON encoder

The json module relies on its “encoders” to transform native Python objects to strings. By default, every single object is passed onto an instance of json.JSONEncoder class which must have encode(), default() and iterencode() methods to do the serialization.

In order to serialize your own object type, you would have to overload json.JSONEncoder and implement custom encode(), default() and iterencode() methods. Let’s look at an example where we define a new class and encode it to JSON:

import json
from json import JSONEncoder

class CustomData:
    def __init__(self, name, value):
        self.name = name
        self.value = value

class CustomEncoder(json.JSONEncoder):
    def default(self, o):
            return o.__dict__

# Create an instance and serialize it with our new encoder
the_value = CustomData("Paris", 120)
jsonized = json.dumps(the_value, indent=4, cls=CustomEncoder)
print(jsonized)

We’ll see something like this :

{
    "name": "Paris",
    "value": 120,
}
Code language: JSON / JSON with Comments (json)

Use jsonpickle

If you need a quick and dirty solution without involving in too much coding, then jsonpickle is made for you.

jsonpickle is a Python library for serialization and deserialization of complex Python objects to and from JSON.

jsonpickle is built so that it allows more complex data structure to be serialized right out of the box. Most of the time, jsonpickle can take almost any Python object and turn the object into JSON. Additionally, it can reconstitute the object back into Python.

Under the hood, jsonpickle uses the same toolset you’re already familiar with : stdlib’s json, simplejson, and demjson. By default, it uses built-in json library from stdlib, but you can choose another JSON backend as well as roll your own backend if you want.

Below is an example of how we would serialize an object with jsonpickle:

import jsonpickle
class Thing(object):
    def __init__(self, name):
        self.name = name

obj = Thing('Awesome')
frozen = jsonpickle.encode(obj)

We hope that the information above helped you fix “Object of type is not JSON serializable” error message in Python. We’ve written a few other guides on troubleshooting other common Python problems such as Fix Python Unresolved Import in VSCode, Fix “Max retries exceeded with URL” error in Python requests library and Fix locale.Error: unsupported locale setting in Python.

If you have any suggestion, please feel free to leave a comment below.

Russian (Pусский) translation by Ilya Nikov (you can also view the original English article)

1

simple = dict(int_list=[1, 2, 3],

2

3

              text='string',

4

5

              number=3.44,

6

7

              boolean=True,

8

9

              none=None) 

1

from datetime import datetime

2

3

4

5

class A(object):

6

7

    def __init__(self, simple):

8

9

        self.simple = simple        

10

11

    def __eq__(self, other):

12

13

        if not hasattr(other, 'simple'):

14

15

            return False

16

17

        return self.simple == other.simple

18

19

    def __ne__(self, other):

20

21

        if not hasattr(other, 'simple'):

22

23

            return True

24

25

        return self.simple != other.simple

26

27

28

29

complex = dict(a=A(simple), when=datetime(2016, 3, 7))

1

import cPickle as pickle

2

3

4

5

pickle.dumps(simple)

6

7

"(dp1nS'text'np2nS'string'np3nsS'none'np4nNsS'boolean'np5nI01nsS'number'np6nF3.4399999999999999nsS'int_list'np7n(lp8nI1naI2naI3nas."

8

9

10

11

pickle.dumps(simple, protocol=pickle.HIGHEST_PROTOCOL)

12

13

'x80x02}qx01(Ux04textqx02Ux06stringqx03Ux04noneqx04NUx07booleanx88Ux06numberqx05G@x0bx85x1exb8Qxebx85Ux08int_list]qx06(Kx01Kx02Kx03eu.'

1

pickle.dump(simple, open('simple1.pkl', 'w'))

2

3

pickle.dump(simple, open('simple2.pkl', 'wb'), protocol=pickle.HIGHEST_PROTOCOL)

4

5

6

7

ls -la sim*.*

8

9

-rw-r--r--  1 gigi  staff  130 Mar  9 02:42 simple1.pkl

10

11

-rw-r--r--  1 gigi  staff   85 Mar  9 02:43 simple2.pkl

1

x = pickle.loads("(dp1nS'text'np2nS'string'np3nsS'none'np4nNsS'boolean'np5nI01nsS'number'np6nF3.4399999999999999nsS'int_list'np7n(lp8nI1naI2naI3nas.")

2

3

assert x == simple

4

5

6

7

x = pickle.loads('x80x02}qx01(Ux04textqx02Ux06stringqx03Ux04noneqx04NUx07booleanx88Ux06numberqx05G@x0bx85x1exb8Qxebx85Ux08int_list]qx06(Kx01Kx02Kx03eu.')

8

9

assert x == simple

1

x = pickle.load(open('simple1.pkl'))

2

3

assert x == simple

4

5

6

7

x = pickle.load(open('simple2.pkl'))

8

9

assert x == simple

10

11

12

13

x = pickle.load(open('simple2.pkl', 'rb'))

14

15

assert x == simple

1

pickle.dumps(complex)

2

3

"(dp1nS'a'nccopy_regn_reconstructornp2n(c__main__nAnp3nc__builtin__nobjectnp4nNtRp5n(dp6nS'simple'np7n(dp8nS'text'np9nS'string'np10nsS'none'np11nNsS'boolean'np12nI01nsS'number'np13nF3.4399999999999999nsS'int_list'np14n(lp15nI1naI2naI3nassbsS'when'np16ncdatetimendatetimenp17n(S'x07xe0x03x07x00x00x00x00x00x00'ntRp18ns."

4

5

6

7

pickle.dumps(complex, protocol=pickle.HIGHEST_PROTOCOL)

8

9

'x80x02}qx01(Ux01ac__main__nAnqx02)x81qx03}qx04Ux06simpleqx05}qx06(Ux04textqx07Ux06stringqx08Ux04noneqtNUx07booleanx88Ux06numberqnG@x0bx85x1exb8Qxebx85Ux08int_list]qx0b(Kx01Kx02Kx03eusbUx04whenqx0ccdatetimendatetimenqrUnx07xe0x03x07x00x00x00x00x00x00x85Rqx0eu.'

10

11

12

13

pickle.dump(complex, open('complex1.pkl', 'w'))

14

15

pickle.dump(complex, open('complex2.pkl', 'wb'), protocol=pickle.HIGHEST_PROTOCOL)

16

17

18

19

ls -la comp*.*

20

21

-rw-r--r--  1 gigi  staff  327 Mar  9 02:58 complex1.pkl

22

23

-rw-r--r--  1 gigi  staff  171 Mar  9 02:58 complex2.pkl

1

import json

2

3

print json.dumps(simple)

4

5

{"text": "string", "none": null, "boolean": true, "number": 3.44, "int_list": [1, 2, 3]}

1

print json.dumps(simple, indent=4)

2

3

{

4

5

    "text": "string",

6

7

    "none": null,

8

9

    "boolean": true,

10

11

    "number": 3.44,

12

13

    "int_list": [

14

15

        1,

16

17

        2,

18

19

        3

20

21

    ]

22

23

}

1

json.dumps(complex)

2

3

---------------------------------------------------------------------------

4

5

TypeError                                 Traceback (most recent call last)

6

7

<ipython-input-19-1be2d89d5d0d> in <module>()

8

9

----> 1 json.dumps(complex)

10

11

12

13

/usr/local/Cellar/python/2.7.10/Frameworks/Python.framework/Versions/2.7/lib/python2.7/json/__init__.pyc in dumps(obj, skipkeys, ensure_ascii, check_circular, allow_nan, cls, indent, separators, encoding, default, sort_keys, **kw)

14

15

    241         cls is None and indent is None and separators is None and

16

17

    242         encoding == 'utf-8' and default is None and not sort_keys and not kw):

18

19

--> 243         return _default_encoder.encode(obj)

20

21

    244     if cls is None:

22

23

    245         cls = JSONEncoder

24

25

26

27

/usr/local/Cellar/python/2.7.10/Frameworks/Python.framework/Versions/2.7/lib/python2.7/json/encoder.pyc in encode(self, o)

28

29

    205         # exceptions aren't as detailed.  The list call should be roughly

30

31

    206         # equivalent to the PySequence_Fast that ''.join() would do.

32

33

--> 207         chunks = self.iterencode(o, _one_shot=True)

34

35

    208         if not isinstance(chunks, (list, tuple)):

36

37

    209             chunks = list(chunks)

38

39

40

41

/usr/local/Cellar/python/2.7.10/Frameworks/Python.framework/Versions/2.7/lib/python2.7/json/encoder.pyc in iterencode(self, o, _one_shot)

42

43

    268                 self.key_separator, self.item_separator, self.sort_keys,

44

45

    269                 self.skipkeys, _one_shot)

46

47

--> 270         return _iterencode(o, 0)

48

49

    271

50

51

    272 def _make_iterencode(markers, _default, _encoder, _indent, _floatstr,

52

53

54

55

/usr/local/Cellar/python/2.7.10/Frameworks/Python.framework/Versions/2.7/lib/python2.7/json/encoder.pyc in default(self, o)

56

57

    182

58

59

    183         """

60

61

--> 184         raise TypeError(repr(o) + " is not JSON serializable")

62

63

    185

64

65

    186     def encode(self, o):

66

67

68

69

TypeError: <__main__.A object at 0x10f367cd0> is not JSON serializable

1

from datetime import datetime

2

3

import json

4

5

6

7

8

9

class CustomEncoder(json.JSONEncoder):

10

11

     def default(self, o):

12

13

         if isinstance(o, datetime):

14

15

             return {'__datetime__': o.replace(microsecond=0).isoformat()}

16

17

         return {'__{}__'.format(o.__class__.__name__): o.__dict__}

1

serialized = json.dumps(complex, indent=4, cls=CustomEncoder)

2

3

print serialized

4

5

6

7

{

8

9

    "a": {

10

11

        "__A__": {

12

13

            "simple": {

14

15

    "text": "string",

16

17

    "none": null,

18

19

    "boolean": true,

20

21

    "number": 3.44,

22

23

    "int_list": [

24

25

        1,

26

27

        2,

28

29

        3

30

31

    ]

32

33

            }

34

35

            }

36

37

    },

38

39

    "when": {

40

41

        "__datetime__": "2016-03-07T00:00:00"

42

43

            }

44

45

}

1

> deserialized = json.loads(serialized)

2

3

> deserialized == complex

4

5

False

1

> from pprint import pprint

2

3

> pprint(deserialized)

4

5

{u'a': {u'__A__': {u'simple': {u'boolean': True,

6

7

                               u'int_list': [1, 2, 3],

8

9

                               u'none': None,

10

11

                               u'number': 3.44,

12

13

                               u'text': u'string'}}},

14

15

 u'when': {u'__datetime__': u'2016-03-07T00:00:00'}}

1

def decode_object(o):

2

3

    if '__A__' in o:

4

5

        a = A()

6

7

        a.__dict__.update(o['__A__'])

8

9

        return a

10

11

    elif '__datetime__' in o:

12

13

        return datetime.strptime(o['__datetime__'], '%Y-%m-%dT%H:%M:%S')        

14

15

    return o

1

> deserialized = json.loads(serialized, object_hook=decode_object)

2

3

> print deserialized

4

5

{u'a': <__main__.A object at 0x10d984790>, u'when': datetime.datetime(2016, 3, 7, 0, 0)}

6

7

8

9

> deserialized == complex

10

11

True

If you try to parse invalid JSON or decode an empty string as JSON, you will encounter the JSONDecodeError: Expecting value: line 1 column 1 (char 0). This error can occur if you read an empty file using json.load, read an empty JSON or receive an empty response from an API call.

You can use a try-except code block to catch the error and then check the contents of the JSON string or file before retrying.

This tutorial will go through the error in detail and how to solve it with code examples.

JSONDecodeError: Expecting value: line 1 column 1 (char 0)

In Python, JSONDecodeError occurs when there is an issue with the formatting of the JSON data. This specific error tells us the JSON decoder has encountered an empty JSON.

Example #1: Incorrect use of json.loads()

Let’s look at an example where we have a JSON file with the following contents:

[
        {"margherita":7.99},
        {"pepperoni":9.99},
        {"four cheeses":10.99}
]

We want to read the data into a program using the json library. Let’s look at the code:

import json

json_path = 'pizza.json'

data = json.loads(json_path)

In the above code, we try to read the data in using json.loads(). Let’s run the code to see the result:

JSONDecodeError: Expecting value: line 1 column 1 (char 0)

The error occurs because json.loads() expects a JSON encoded string, not a filename. The string pizza.json is not a valid JSON encoded string.

Solution

We need to use json.load() instead of json.loads() to read a file. Let’s look at the revised code:

import json

json_path = 'pizza.json'

with open(json_path, 'r') as f:

    data = json.loads(f.read())

print(data)

In the above code, we use the open() function to create a file object that json.load() can read and return the decoded data object. The with statement is a context manager that ensures that the file is closed once the code is complete. Let’s run the code to see the result:

[{'margherita': 7.99}, {'pepperoni': 9.99}, {'four cheeses': 10.99}]

Example #2: Empty JSON file

Let’s look at an example where we have an empty file, which we will try to read in using json.loads(). The file is called particles.json. Since the JSON file is empty, the JSON decoder will throw the JSONDecodeError when it tries to read the file’s contents. Let’s look at the code:

import json

filename = 'particles.json'

with open(filename, 'r') as f:
    contents = json.loads(f.read())
    print(contents)

---------------------------------------------------------------------------
JSONDecodeError                           Traceback (most recent call last)
Input In [1], in <cell line: 5>()
      3 filename = 'particles.json'
      5 with open(filename, 'r') as f:
----> 6     contents = json.loads(f.read())
      7     print(contents)

File ~/opt/anaconda3/lib/python3.8/json/__init__.py:357, in loads(s, cls, object_hook, parse_float, parse_int, parse_constant, object_pairs_hook, **kw)
    352     del kw['encoding']
    354 if (cls is None and object_hook is None and
    355         parse_int is None and parse_float is None and
    356         parse_constant is None and object_pairs_hook is None and not kw):
--> 357     return _default_decoder.decode(s)
    358 if cls is None:
    359     cls = JSONDecoder

File ~/opt/anaconda3/lib/python3.8/json/decoder.py:337, in JSONDecoder.decode(self, s, _w)
    332 def decode(self, s, _w=WHITESPACE.match):
    333     """Return the Python representation of ``s`` (a ``str`` instance
    334     containing a JSON document).
    335 
    336     """
--> 337     obj, end = self.raw_decode(s, idx=_w(s, 0).end())
    338     end = _w(s, end).end()
    339     if end != len(s):

File ~/opt/anaconda3/lib/python3.8/json/decoder.py:355, in JSONDecoder.raw_decode(self, s, idx)
    353     obj, end = self.scan_once(s, idx)
    354 except StopIteration as err:
--> 355     raise JSONDecodeError("Expecting value", s, err.value) from None
    356 return obj, end

JSONDecodeError: Expecting value: line 1 column 1 (char 0)

Solution

If the file is empty, it is good practice to add a try-except statement to catch the JSONDecodeError. Let’s look at the code:

import json

filename = 'particles.json'

with open(filename, 'r') as f:

   try:

       contents = json.loads(f.read())

       print(contents)

   except json.decoder.JSONDecodeError:

       print('File is empty')

File is empty

Now we have verified the file is empty, we can add some content to the file. We will add three particle names together with their masses.

[
        {"proton":938.3},
        {"neutron":939.6},
        {"electron":0.51}
]

Let’s try to read the JSON file into our program and print the contents to the console:

import json

filename = 'particles.json'

with open(filename, 'r') as f:

   try:

       contents = json.loads(f.read())

       print(contents)

   except json.decoder.JSONDecodeError:

       print('File is empty')

[{'proton': 938.3}, {'neutron': 939.6}, {'electron': 0.51}]

We successfully read the contents of the file into a list object.

Example #3: Response Request

Let’s look at an example where we want to parse a JSON response using the requests library. We will send a RESTful GET call to a server, and in return, we get a response in JSON format. The requests library has a built-in JSON decoder, response.json(), which provides the payload data in the JSON serialized format.

We may encounter a response that has an error status code or is not content-type application/json. We must check that the response status code is 200 (OK) before performing the JSON parse. Let’s look at the code to check the response has the 200 status code and has the valid content type. application/json.

import requests

from requests.exceptions import HTTPError

url = 'https://httpbin.org/get'

try:

    response = requests.get(url)

    status = response.status_code

    if (status != 204 and response.headers["content-type"].strip().startswith("application/json")):

        try:

            json_response = response.json()

            print(json_response)

        except ValueError:
            
            print('Bad Data from Server. Response content is not valid JSON')

    elif (status != 204):

        try:

            print(response.text)

        except ValueError:

            print('Bad Data From Server. Reponse content is not valid text')

except HTTPError as http_err:

    print(f'HTTP error occurred: {http_err}')

except Exception as err:

    print(f'Other error occurred: {err}')

In the above example, we use httpbin.org to execute a GET call. Let’s run the code to get the result:

{'args': {}, 'headers': {'Accept': '*/*', 'Accept-Encoding': 'gzip, deflate, br', 'Host': 'httpbin.org', 'User-Agent': 'python-requests/2.27.1', 'X-Amzn-Trace-Id': 'Root=1-6265a5c1-3b57327c02057a3a39ffe86d'}, 'origin': '90.206.95.191', 'url': 'https://httpbin.org/get'}

Summary

Congratulations on reading to the end of this tutorial! The JSONDecodeError: Expecting value: line 1 column 1 (char 0) occurs either when data is not present in a file, the JSON string is empty, or the payload from a RESTful call is empty.

You can resolve this error by checking the JSON file or string for valid content and using an if-statement when making a RESTful call to ensure the status code is 200 and the content type is application/json.

For further reading on errors involving JSON, go to the articles:

• How to Solve Python ValueError: Trailing data
• How to Solve Python JSONDecodeError: extra data
• How to Solve Python TypeError: Object of type datetime is not JSON serializable
• How to Solve Python JSONDecodeError: Expecting ‘,’ delimiter: line 1

Have fun and happy researching!

Сразу после появления, JSON быстро стал де факто стандартом обмена информации. Вероятно вы здесь из-за того, что вы хотите переместить данные из одного места в другое. Возможно вы получаете данные через API, или храните их в документной базе данных. Так или иначе, вы заинтересовались JSON, и вам нужно пользоваться им через Python.

Содержание

• Подробнее про JSON
• Структура JSON
• Python поддерживает JSON
• Небольшой словарь
• Сериализация JSON
• Пример сериализации JSON Python
• Несколько полезных аргументов
• Десериализация JSON
• Пример десериализации JSON Python
• Пример работы с JSON Python
• Кодирование и декодирование объектов Python
• Упрощение структур данных
• Кодирование пользовательских типов
• Декодирование пользовательских типов
• Готово!

К счастью, это достаточно тривиальная задача, и как и с большинством тривиальных задач, Python делает все до омерзения простым.

Итак, используем ли мы JSON для хранения и обмена данными? Именно так. Это не более, чем стандартизированный формат, который используется сообществом для передачи данных. Помните, что JSON не является единственным доступным форматом для такой работы, XML и YAML наверное, единственные альтернативные способы, которые стоит упомянуть.

Не удивительно, что JavaScript Object Notation был вдохновен подмножеством языка программирования JavaScript, связанным с синтаксисом объектного литерала. У них есть отличный сайт, в котором все прекрасно объясняется. Не переживайте: JSON уже давно стал агностиком языка и существует как отдельный стандарт, по этому мы можем убрать JavaScript из этой дискуссии.

В конечном счете, большая часть сообщества приняла JSON благодаря его простоте как для людей, так и для машин.
Смотрите, это JSON!

Структура JSON

Готовьтесь. Я собираюсь показать реальный пример JSON— такой же, какой вы встретите в реальной жизни. Это нормально, подразумевается что JSON является читаемым для любого, кто пользовался С-языками, а Python – это С-язык, так что мы говорим о вас!

Как видите, JSON поддерживает примитивные типы, такие как строки python и числа, а также вложенные списки и объекты.

Погодите, это выглядит как словарь Python, верно? На данный момент это достаточно универсальная нотация объектов, и не думаю что UON может так же легко отскакивать от зубов. Кстати, предлагайте альтернативы в комментариях!

НУ что же, вы пережили первый контакт с диким JSON. Теперь вам нужно научиться приручать его!

Python поддерживает JSON

Python содержит встроенный модуль под названием json для кодирования и декодирования данных JSON.

Просто импортируйте модуль в начале вашего файла:

Небольшой словарь

Как правило, процесс кодирования JSON называется сериализация. Этот термин обозначает трансформацию данных в серию байтов (следовательно, серийных) для хранения или передачи по сети. Также вы, возможно, уже слышали о термине «маршалинг», но это уже совсем другая область.

Естественно, десериализация — является противоположным процессом декодирования данных, которые хранятся или направлены в стандарт JSON.

Звучит как много технических терминов. Определенно. Но в реальности, все, о чем мы сейчас говорим — это чтение и написание. Представьте это следующим образом: кодирование это запись данных на диск, в то время как декодирование — это чтение данных в памяти.

Сериализация JSON

Что происходит после того, как компьютер обрабатывает большие объемы информации? Ему нужно принять дамп данных. Соответственно, модуль json предоставляет метод dump() для записи данных в файлы. Также есть метод dumps() для записей в строку Python.

Простые объекты Python переводятся в JSON согласно с весьма интуитивной конверсией.

Пример сериализации JSON Python

Представьте, что вы работаете с объектом Python в памяти, который выглядит следующим образом:

Сохранить эту информацию на диск — критично, так что ваша задача — записать на файл.

Используя контекстный менеджер Python, вы можете создать файл под названием data_file.json и открыть его в режиме write (файлы JSON имеют расширение .json).

Обратите внимание на то, что dump() принимает два позиционных аргумента: (1) объект данных, который сериализуется и (2), файловый объект, в который будут вписаны байты.

Или, если вы склонны продолжать использовать эти сериалзированные данные JSON в вашей программе, вы можете работать как со строкой.

Обратите внимание, что файловый объект является пустым, так как вы на самом деле не выполняете запись на диск. Кроме того, dumps() аналогичен dump().

Ура! У вас получился малыш JSON и вы можете выпустить его в реальный мир, чтобы он вырос большим и сильным.

Несколько полезных аргументов

Помните, что JSON создан таким образом, чтобы быть читаемым для людей. Но читаемого синтаксиса недостаточно, если все слеплено вместе. Кроме этого, ваш стиль программирования скорее всего отличается от моего, и вам будет проще читать код, если он отформатирован по вашему вкусу.

Обратите внимание: Методы dump() и dumps() пользуются одними и теми же аргументами ключевых слов.

Первая опция, которую большинство людей хотят поменять, это пробел. Вы можете использовать аргумент indent для определения размера отступа вложенных структур. Ощутите разницу лично, используя данные, упомянутые выше и выполните следующие команды в консоли:

Еще один вариант форматирования — это аргумент separators. По умолчанию, это двойной кортеж строк разделителя («, «, «: «), но обычно в качестве альтернативы для компактного JSON является («,», «:»). Взгляните на пример JSON еще раз, чтобы понять, где в игру вступают разделители.

Есть и другие аргументы, такие как sort_keys, но я не имею понятия, что он делает. Вы можете найти полный список в документации, если вам интересно.

Десериализация JSON

Отлично, похоже вам удалось поймать экземпляр дикого JSON! Теперь нам нужно предать ему форму. В модуле json вы найдете load() и loads() для превращения кодированных данных JSON в объекты Python.

Как и сериализация, есть простая таблица конверсии для десериализации, так что вы можете иметь представление о том, как все выглядит.

Технически, эта конверсия не является идеальной инверсией таблицы сериализации. По сути, это значит что если вы кодируете объект сейчас, а затем декодируете его в будущем, вы можете не получить тот же объект назад. Я представляю это как своего рода телепортацию: мои молекулы распадаются в точке А и собираются в точке Б. Буду ли я тем же самым человеком?

В реальности, это как попросить одного друга перевести что-нибудь на японский, а потом попросить другого друга перевести это обратно на русский. В любом случае, самым простым примером будет кодировать кортеж и получить назад список после декодирования, вот так:

Пример десериализации JSON Python

На этот раз, представьте что у вас есть некие данные, хранящиеся на диске, которыми вы хотите манипулировать в памяти. Вам все еще нужно будет воспользоваться контекстным менеджером, но на этот раз, вам нужно будет открыть существующий data_file.json в режиме для чтения.

Здесь все достаточно прямолинейно, но помните, что результат этого метода может вернуть любые доступные типы данных из таблицы конверсий. Это важно только в том случае, если вы загружаете данные, которые вы ранее не видели. В большинстве случаев, корневым объектом будет dict или list.

Если вы внесли данные JSON из другой программы, или полученную каким-либо другим способом строку JSON форматированных данных в Python, вы можете легко десериализировать это при помощи loads(), который естественно загружается из строки:

Ву а ля! Вам удалось укротить дикого JSON, теперь он под вашим контролем. Но что вы будете делать с этой силой — остается за вами. Вы можете кормить его, выращивать, и даже научить новым приемам. Не то чтобы я не доверяю вам, но держите его на привязи, хорошо?

Пример работы с JSON Python

Для тестового API, мы воспользуемся JSONPlaceholder, отличный источник фейковых данных JSON для практических целей.

Для начала, создайте файл под названием scratch.py, или как вам удобно. Здесь я не могу вас контролировать.

Вам нужно выполнить запрос API в сервис JSONPlaceholder, так что просто используйте пакет requests, чтобы он сделал за вас всю грязную работу. Добавьте следующие импорты вверху файла:

Теперь вам предстоит поработать со списком TODOs, потому что… это своего рода обряд посвящения, вроде того.

Идем дальше и создаем запрос в API JSONPlaceholder для конечной точки GET /todos. Если вы слабо знакомы с запросами, есть очень удобный метод json(), который выполнит за вас всю работу, но вы можете попрактиковаться в использовании модуля json для десериализации атрибута текста объекта response. Это должно выглядеть следующим образом:

Не верится, что это работает? Хорошо, запустите файл в интерактивном режиме и проверьте лично. Пока вы там, проверьте тип todos. Если вам любопытно, обратите внимание на первые 10 элементов в списке.

Как видите, никто вас не обманывает, и мы ценим здравый скептицизм.

Что такое интерактивный режим? Я уже думал вы не спросите! Вы знакомы с тем, что приходится постоянно прыгать туда-сюда между вашим редактором и терминалом? Мы, хитрые питонисты, используем интерактивный флаг -i, когда запускаем скрипт. Это отличный небольшой трюк для тестирования кода, так как он запускает скрипт, и затем открывает интерактивную командную строку с доступом ко всем данным скрипта!

Хорошо, теперь перейдем к действиям. Вы можете видеть структуру данных полученную от тестового API, посетив адрес в браузере https://jsonplaceholder.typicode.com/todos:

Здесь несколько пользователей, каждый из которых имеет уникальный userId, а каждая задача имеет свойство Boolean. Можете определить, какие пользователи выполнили большую часть задач?

Да, да, ваша версия лучше, но суть в том, что теперь вы можете манипулировать данными JSON как нормальным объектом Python!

Не знаю как вы, но я запустил скрипт в интерактивном режиме еще раз, и получил следующий результат:

Это круто, и все такое, но мы занимаемся изучением JSON. В качестве вашей последней задачи, вы создадите файл JSON, который содержит готовые задачи (TODO) для каждого пользователя, который выполнил максимальное количество задач. Здесь мы использовали F-Строки Python.

Все, что вам нужно сделать, это отфильтровать задачи и вписать итоговый список в файл. Ради оригинальности, вы можете назвать файл выдачи filtered_data_file.json. Существует много способов сделать это, вот один из них:

Отлично, теперь вы избавились от всех данных, которые вам не нужны и сохранили необходимое для нового файла!

Запустите скрипт еще раз и проверьте filtered_data_file.json, чтобы убедиться в том, что все работает. Он будет в той же папке, что и scratch.py, когда вы запустите его.

Теперь, когда вы зашли так далеко, вы начинаете понимать что коснулись темы с большим потенциалом, не так ли? Не зазнавайтесь: скромность сестра таланта. Хотя и не могу не согласиться. Пока что мы работали в плавном потоке, но под конец мы можем поддать газку.

Кодирование и декодирование объектов Python

Что случается, когда мы пытаемся сериализировать класс Elf из приложения Dungeons & Dragons, с которым вы работаете?

Ничего удивительного, Возникла ошибка, что класс Elf нельзя сериализировать:

Хотя, модуль json может обрабатывать большинство типов Python, он не понимает, как кодировать пользовательские типы данных по умолчанию. Это как пытаться поместить кубик в круглое отверстие — вам понадобится бензопила и надзор специалиста.

Упрощение структур данных

Сейчас вопрос в том, что делать с более сложными структурами данных. Например, вы можете попробовать кодировать и декодировать JSON вручную, но есть более разумное решение, которое избавит вас от лишней работы. Вместо того, чтобы идти непосредственно от пользовательского типа данных к JSON, вы можете перейти к промежуточному шагу.

Все что вам нужно, это отобразить ваши данные в контексте встроенных типов, которые изначально понятны json. По сути, вы переводите более сложный объект в его упрощенное представление, которое модуль json затем переводит в JSON.

Это наглядно представляется в математике: А = В, и В = С, значит А = С.

Чтобы добиться этого, вам нужен сложный объект для работы. Вы можете использовать любой пользовательский класс на ваш вкус, но Python имеет встроенный тип под названием complex, для представления сложных чисел, и он не может быть сериализированным по умолчанию. Итак, ради этих примеров, ваш сложный объект станет сложным объектом. Уже запутались?

Откуда приходят комплексные числа? Когда реальное число и представляемое число очень любят друг друга, они складываются вместе для создания числа, которое (справедливо) называется комплексным.

Хороший вопрос, который стоит задать себе при работе со сложными типами: «Какой минимальный объем информации необходим для воссоздания этого объекта?» В случае со комплексными числами, вам нужно знать только реальное и представляемое число, доступ к которым (в качестве атрибутов) доступен в объекте complex:

Передачи одних и тех же чисел в сложный конструктор достаточно для удовлетворения оператора сравнения __eq__:

Разбивать пользовательские типы данных на их составляющие компоненты — критически важно как для процесса сериализации, так и для десериализации.

Кодирование пользовательских типов

Для перевода пользовательского объекта в JSON, все что вам нужно — это предоставить функцию кодирования параметру по умолчанию метода dump(). Модуль json вызовет эту функцию для любых объектов, которые не являются естественно сериализируемыми. Вот простая функция декодирования, которую вы можете использовать на практике:

Обратите внимание на то, что ожидается получение ошибки TypeError, если вы не получите ожидаемый тип объекта. Таким образом, вы избегаете случайной сериализации любых пользовательских типов. Теперь вы можете кодировать сложные объекты самостоятельно!

Почему мы кодируем комплексное число как кортеж? Хороший вопрос. Это определенно не является единственными выбором, впрочем, как и не является лучшим выбором. Фактически, это не может быть хорошим отображением, если вы планируете декодировать объект в будущем, что вы и увидите дальше.

Еще один частый подход — создать дочерний класс JSONEncoder и переопределить его метод default():

Вместо создания ошибки TypeError, вы можете дать классу base справиться с ней. Вы можете использовать его как напрямую в метод dump() при помощи параметра cls, или создав экземпляр encoder-а и вызова метода encode():

Декодирование пользовательских типов

В то время, как реальные и представляемые части сложных чисел абсолютно необходимы, на самом деле их не совсем достаточно для воссоздания объекта. Вот что случается, если вы попробуете кодировать комплексное число при помощи ComplexEncoder, а затем декодировать результат:

Все что вы получаете обратно — это список, и вы можете передать значения в конструктор, если вы хотите получить этот сложный объект еще раз. Напоминаю о нашем разговоре о телепортации. Чего нам в итоге не хватает? Метаданные, или информации о типа данных, которые вы кодируете.

Я предполагаю, что вопрос, который действительно важно задать себе, это «Какое минимальное количество информации, которая необходима, и которой достаточно для воссоздания объекта?»

Модуль json ожидает, что все пользовательские типы будут отображаться как объекты стандарта JSON. Для разнообразия, вы можете создать файл JSON, на этот раз назовем его complex_data.json и добавим следующий объект, отображающий комплексное число:

Заметили хитрую часть? Вот ключ «__complex__» является метаданными, которые мы только что упоминали. Неважно, какое ассоциируемое значение мы имеем. Чтобы эта хитрость сработала, все что вам нужно, это подтвердить существование ключа:

Если «__complex__» не находится в словаре, вы можете просто вернуть объект и позволить декодеру по умолчанию разобраться с этим.

Каждый раз, когда метод load() пытается парсить объект, у вас есть возможность выступить в роли посредника, перед тем как декодер пройдет свой путь с данными. Вы можете сделать это, спарсив вашу функцию декодирования с параметром object_hook.

Теперь сыграем в ту же игру, что и раньше:

Хотя объект object_hook может показаться аналогом параметра по умолчанию метода dump(), на самом деле аналогия здесь же и заканчивается.

Это не просто работает с одним объектом. Попробуйте внести этот список сложных чисел в complex_data.json и запустить скрипт еще раз:

Если все идет гладко, вы получите список комплексных объектов:

Вы также можете попробовать создать подкласс JSONDecoder и переопределить object_hook, но лучше придерживаться более легких решений при каждой возможности.

Итоги

Поздравляю, теперь вы обладаете могущественной силой JSON для любых ваших потребностей в Python.

Хотя примеры, с которыми вы работали, безусловно, оригинальные и чрезмерно упрощены, они демонстрируют рабочий процесс, который вы можете применить к более общим задачам:

1. Импорт модуля json
2. Чтение данных с load() или loads()
3. Обработка данных
4. Запись измененных данных при помощи dump() или dumps()

Что вы будете делать с данными, после того как они загрузились в память — зависит от вашего случая. В целом, ваша задача — собрать данные из источника, извлечение полезной информации, и передача этой информации (или ее запись).

Сегодня вы проделали небольшое путешествие: вы поймали и приручили JSON, и вернулись домой как раз к ужину! И в качестве бонуса, научившись работать с модулем json, можете начать изучение модулей pickle и marshal.

Спасибо за внимание, и удачи с вашими начинаниями в Python!