Working with JSON Data in Python

Haris Bin Nasir Avatar



In this article, you will learn how to parse, read, and write JSON Data in Python.

The JSON (JavaScript Object Notation) format is a standard for storing and exchanging data between processes. Json was originally part of JavaScript, but it has since grown, gained its own standard, and currently exists independently of JS or any other programming language. If you want to be a programmer, you’ll come across the json format sooner or later. Json should be one of the first words that springs to mind whenever there is a need for storage (hard disk, database) or data interchange between programs.

In Python, how do you deal with JSON Data?

Serialize and Deserialize operations

Python is simple to learn yet highly powerful, as evidenced by the way it handles json file processing. Using a dynamic type language, as well as two data structures: dict, list, and python, will make handling json feel natural and simple.

Before you go into the intricacies, you first understand how the computer software interacts with the file. You manipulate items in the application. When you wish to store or send data across a network, you must first convert the objects into a format that your computer can handle. Serialize is the term for this procedure.

Deserialize, on the other hand, is a procedure that restores an object from a file or bit sequence received over the network. Simply said, if you wish to handle json files, you must convert the contents of the json files on your hard drive into objects that the Python program recognizes (deserialize). When saving items as json, you must first convert them to a format that the hard disk can save (serialize).

Deserialize JSON Python

Python’s standard library now includes the json module, which was introduced in version 2.6. As a result, if your Python version is greater, you only need to import this module to work with json. If you’re using an older version of Python, you can install this package with pips. However, I strongly advise you to switch to a newer version of Python, as Python 2.x is no longer supported.

import json

We must transition from json to python type in deserialize. The following is the equivalent conversion table:

JSON Python
object dict
array list
string str
number(int) int
number(real) int
true True
false False
null None 

The load function is used to deserialize a json file into an object. Consider the following from the people.json file:

with open("people.json", "r") as fin: data = json.load(fin) print(data) >>> {'name': 'Guido van Rossum', 'age': 65, 'degree': ['mathematics', 'computer science'], 'retired': True, 'carrer': {'google': {'from': 1999, 'to': 2013}, 'dropbox': {'from': 2013, 'to': 2019}}} print(type(data)) >>> <class 'dict'> print(type(data['age'])) >>> <class 'int'> print(type('carrer')) >>> <class 'dict'> We can also deserialize a json string, using load functions. json_string = """ { "name": "Guido van Rossum", "age": 65, "degree": ["mathematics", "computer science"], "retired": true, "carrer": { "google":{ "from": 1999, "to": 2013 }, "dropbox": { "from": 2013, "to": 2019 } } } """ data = json.loads(json_string) print(data) >>> {'name': 'Guido van Rossum', 'age': 65, 'degree': ['mathematics', 'computer science'], 'retired': True, 'carrer': {'google': {'from': 1999, 'to': 2013}, 'dropbox': {'from': 2013, 'to': 2019}}} print(type(data)) <class 'dict'> After deserializing objects, you can now use them as normal. print(len(data['degree'])) >>> 2 print(data['degree'][0]) >>> mathematics print(data['age'] + 3) >>> 68

Serialize Python Objects Into JSON

We must switch from python’s data type to json’s data type during the serialization process. The following is the equivalent conversion table:

Python JSON
dict object
list,tuple array
str string
Int, long, float number
True true
False false
None null

The dump function is used to store a Python object as a json file.

data = {'name': 'Guido van Rossum', 'age': 65, 'degree': ['mathematics', 'computer science'], 'retired': True, 'carrer': {'google': {'from': 1999, 'to': 2013}, 'dropbox': {'from': 2013, 'to': 2019}}} with open("people.json", "w") as fout: json.dump(data, fout)

Use the dumps function if you only need to convert a python object to a string json. Dumps and dumps also include more indent parameters, allowing you to create more professional-looking outcomes.

data = {'name': 'Guido van Rossum', 'age': 65, 'degree': ['mathematics', 'computer science'], 'retired': True, 'carrer': {'google': {'from': 1999, 'to': 2013}, 'dropbox': {'from': 2013, 'to': 2019}}} json_string = json.dumps(data) print(json_string) >>> {"name": "Guido van Rossum", "age": 65, "degree": ["mathematics", "computer science"], "retired": true, "carrer": {"google": {"from": 1999, "to": 2013}, "dropbox": {"from": 2013, "to": 2019}}} print(type(json_string) >>> <class 'str'> json_string_2 = json.dumps(data, indent=4) print(json_string_2) >>> { "name": "Guido van Rossum", "age": 65, "degree": [ "mathematics", "computer science" ], "retired": true, "carrer": { "google": { "from": 1999, "to": 2013 }, "dropbox": { "from": 2013, "to": 2019 } } }

Dealing with objects that the json module does not support

The json module supports the majority of built-in types of data, but there are a few sorts of data that it does not, complicated being one of them. Similarly, because it lacks information about user-defined types of data, the json module cannot self-serialize or deserialize them. If you proceed normally, you will encounter an error.

z = 3 + 2j print(type(z)) >>> <class 'complex'> json.dumps(z) >>> TypeError: Object of type complex is not JSON serializable

With this type of data, you should provide additional help functions to Python, such as default for serialize and object hook for deserialize.

Serialize complex data types, for example.

z = 3 + 2j def encode_complex(z): if isinstance(z, complex): return (z.real, z.imag) else: raise TypeError("This type is not Json serializable") a = json.dumps(z, default=encode_complex) print(a) >>> [3.0, 2.0]

Deserialize complex data type

def decode_complex(dct): return complex(dct['real'], dct['imag']) a = """ { "real": 3.0, "imag": 2.0 } """ b = json.loads(a, object_hook=decode_complex) print(b) >>> (3 + 2j) print(type(b)) >>> <class 'complex'>

Serialize and deserialize the user-defined class

You can use dict attributes to serialize and desialize data with self-defined classes. The object’s properties are stored in a dictionary returned by dict.

class People(object): def __init__(self, first_name: str, second_name: str): self.first_name = first_name self.second_name = second_name people = People("Guido", "Russom") print(people.__dict__) >>> {'first_name': 'Guido', 'second_name': 'Russom'} encode_data = json.dumps(people.__dict__) print(encode_data) >>> {"first_name": "Guido", "second_name": "Russom"} decode_data = People(**json.loads(encode_data)) print(decode_data) >>> <__main__.People object at 0x7f85a03e1990> print(decode_data.first_name) >>> Guido print(decode_data.second_name) >>> Russom

The ** in decode data = People(**json.loads(encode data)) is a specific python syntax for passing a list of keyword arguments to a function. As a result, we’ve discovered the general approach to working with the json format in Python. I hope you found the information above to be useful.


In this article, we took a look at how to work with JSON Data in Python. We learned with the help of examples how to serialize and deserialize JSON data. As always, If you have found this article useful do not forget to share it and leave a comment if you have any questions. Happy Coding

Leave a Reply

Your email address will not be published. Required fields are marked *