Python json.JSONDecoder Class

---

---

The Python json.JSONDecoder class is used to deserialize JSON data (convert JSON strings into Python objects). It provides more control over how JSON is parsed, allowing custom object hooks and parsing functions.

This class is useful when working with JSON data that requires specialized decoding logic, such as custom data transformations or object reconstruction.

Syntax

Following is the syntax of the Python json.JSONDecoder class −

json.JSONDecoder(object_hook=None, parse_float=None, parse_int=None, parse_constant=None, strict=True, object_pairs_hook=None)

Parameters

This class accepts the following parameters −

• object_hook (optional): A function to transform JSON objects into custom Python objects.
• parse_float (optional): A function to parse floating-point numbers. Default is float.
• parse_int (optional): A function to parse integer numbers. Default is int.
• parse_constant (optional): A function to parse special constants like NaN, Infinity, etc.
• strict (optional): If True, raises an error on extra commas. Default is True.
• object_pairs_hook (optional): A function that processes key-value pairs while maintaining their order.

Return Value

This class returns a Python object that represents the JSON data.

Example: Basic Usage

In this example, we use json.JSONDecoder class to manually decode a JSON string −

import json

# JSON string
json_string = '{"name": "Alice", "age": 25, "city": "New York"}'

# Decode JSON string
decoder = json.JSONDecoder()
data = decoder.decode(json_string)

print("Decoded Data:", data)

Following is the output obtained −

Decoded Data: {'name': 'Alice', 'age': 25, 'city': 'New York'}

Example: Custom Object Conversion

The object_hook parameter allows us to convert JSON objects into custom Python objects −

import json

# Sample class
class Person:
   def __init__(self, name, age):
      self.name = name
      self.age = age

# Custom function to decode JSON into Person objects
def custom_decoder(obj):
   return Person(obj["name"], obj["age"])

# JSON string
json_string = '{"name": "Bob", "age": 30}'

# Decode JSON with object_hook
decoder = json.JSONDecoder(object_hook=custom_decoder)
person = decoder.decode(json_string)

print("Decoded Person:", vars(person))

The result produced is as shown below −

Decoded Person: {'name': 'Bob', 'age': 30}

Example: Parsing Numbers

We can use the parse_int and parse_float parameters to modify how numbers are parsed −

import json

# Custom parsing functions
def parse_int_custom(value):
   return int(value) * 10  # Multiply integers by 10

def parse_float_custom(value):
   return round(float(value), 2)  # Round floats to 2 decimal places

# JSON string
json_string = '{"integer": "5", "floating": "12.789"}'

# Decode JSON with custom number parsing
decoder = json.JSONDecoder(parse_int=parse_int_custom, parse_float=parse_float_custom)
data = decoder.decode(json_string)

print("Parsed Data:", data)

After executing the above code, we get the following output −

Parsed Data: {'integer': 5, 'floating': 12.789}

Example: Preserving Key Order

By default, Python dictionaries maintain order in Python 3.7+, but we can explicitly use the object_pairs_hook parameter to load a JSON object while preserving key order −

import json
from collections import OrderedDict

# JSON string
json_string = '{"c": 3, "b": 2, "a": 1}'

# Decode JSON while preserving key order
decoder = json.JSONDecoder(object_pairs_hook=OrderedDict)
data = decoder.decode(json_string)

print("Ordered Data:", data)

Following is the output of the above code −

Ordered Data: OrderedDict([('c', 3), ('b', 2), ('a', 1)])

Example: Handling Special Constants

The parse_constant parameter allows us to handle special constants like NaN, Infinity, and -Infinity −

import json

# Custom function to handle special constants
def parse_constant_custom(value):
    return f"Special value: {value}"

# JSON string with special constants
json_string = '{"value1": NaN, "value2": Infinity, "value3": -Infinity}'

# Decode JSON with custom parse_constant
decoder = json.JSONDecoder(parse_constant=parse_constant_custom)
data = decoder.decode(json_string)

print("Parsed Data:", data)

We get the output as shown below −

Parsed Data: {'value1': 'Special value: NaN', 'value2': 'Special value: Infinity', 'value3': 'Special value: -Infinity'}

Example: Handling JSON Arrays

The json.JSONDecoder class can also decode JSON arrays into Python lists −

import json

# JSON string (array)
json_string = '[{"name": "Alice", "age": 25}, {"name": "Bob", "age": 30}]'

# Decode JSON
decoder = json.JSONDecoder()
data = decoder.decode(json_string)

print("Decoded List:", data)

The result produced is as follows −

Decoded List: [{'name': 'Alice', 'age': 25}, {'name': 'Bob', 'age': 30}]