10 Python JSON Interview Questions and Answers

Python JSON is a crucial aspect of modern programming, enabling seamless data interchange between systems. JSON (JavaScript Object Notation) is a lightweight data format that is easy for humans to read and write, and easy for machines to parse and generate. Python’s built-in support for JSON makes it an essential tool for developers working on web applications, APIs, and data processing tasks.

This article provides a curated selection of interview questions focused on Python JSON. By exploring these questions and their detailed answers, you will gain a deeper understanding of how to effectively utilize JSON in Python, enhancing your problem-solving skills and technical proficiency for your upcoming interview.

Python JSON Interview Questions and Answers

1. Write a Python function to parse a JSON string into a Python dictionary.

To parse a JSON string into a Python dictionary, use the json.loads() method from the json module. This method converts a JSON string into a Python dictionary.

Example:

import json

def parse_json(json_string):
    return json.loads(json_string)

json_string = '{"name": "John", "age": 30, "city": "New York"}'
parsed_dict = parse_json(json_string)

print(parsed_dict)
# Output: {'name': 'John', 'age': 30, 'city': 'New York'}

2. Write a Python script to read JSON data from a file and write JSON data to a file.

To read and write JSON data from and to a file, use the json module. Here’s an example demonstrating both operations:

import json

# Reading JSON data from a file
with open('data.json', 'r') as file:
    data = json.load(file)

# Modifying the data (optional)
data['new_key'] = 'new_value'

# Writing JSON data to a file
with open('output.json', 'w') as file:
    json.dump(data, file, indent=4)

3. How would you handle errors that occur during JSON parsing or serialization in Python? Provide a code example.

Handle errors during JSON parsing or serialization using try-except blocks to catch exceptions. This ensures your program can manage unexpected data without crashing.

Example:

import json

# JSON parsing with error handling
json_string = '{"name": "John", "age": 30}'

try:
    data = json.loads(json_string)
    print(data)
except json.JSONDecodeError as e:
    print(f"Error parsing JSON: {e}")

# JSON serialization with error handling
data = {"name": "John", "age": 30, "birthdate": None}

try:
    json_string = json.dumps(data)
    print(json_string)
except TypeError as e:
    print(f"Error serializing to JSON: {e}")

4. Write a Python class that extends json.JSONEncoder to serialize a custom object.

To serialize a custom object using JSON, extend the json.JSONEncoder class. This allows you to define how your object should be converted to a JSON-compatible format.

Example:

import json

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

class CustomEncoder(json.JSONEncoder):
    def default(self, obj):
        if isinstance(obj, CustomObject):
            return {'name': obj.name, 'value': obj.value}
        return super().default(obj)

custom_obj = CustomObject('example', 42)
json_str = json.dumps(custom_obj, cls=CustomEncoder)
print(json_str)

5. Write a Python function to extract a specific value from a deeply nested JSON structure.

To extract a specific value from a deeply nested JSON structure, use recursive functions. This approach navigates through the nested levels until the desired key is found.

Example:

def extract_value(json_obj, key):
    if isinstance(json_obj, dict):
        if key in json_obj:
            return json_obj[key]
        for k, v in json_obj.items():
            result = extract_value(v, key)
            if result is not None:
                return result
    elif isinstance(json_obj, list):
        for item in json_obj:
            result = extract_value(item, key)
            if result is not None:
                return result
    return None

# Example JSON structure
json_data = {
    "level1": {
        "level2": {
            "level3": {
                "target_key": "desired_value"
            }
        }
    }
}

# Extracting the value
value = extract_value(json_data, "target_key")
print(value)  # Output: desired_value

6. Write a Python script to make an HTTP GET request to a web API that returns JSON data and parse the response.

To make an HTTP GET request to a web API that returns JSON data, use the requests library. Once you receive the JSON response, parse it with the json library.

Example:

import requests

# Make an HTTP GET request
response = requests.get('https://api.example.com/data')

# Check if the request was successful
if response.status_code == 200:
    # Parse the JSON response
    data = response.json()
    print(data)
else:
    print(f"Request failed with status code {response.status_code}")

7. Write a Python function to perform a complex transformation on a JSON object, such as merging two JSON objects with nested structures.

To merge two JSON objects with nested structures, use a recursive function. This function iterates through the keys of both JSON objects and merges them. If a key exists in both objects and the values are dictionaries, it recursively merges these dictionaries.

Example:

import json

def merge_json(obj1, obj2):
    if not isinstance(obj1, dict) or not isinstance(obj2, dict):
        return obj2
    result = obj1.copy()
    for key, value in obj2.items():
        if key in result:
            result[key] = merge_json(result[key], value)
        else:
            result[key] = value
    return result

json1 = {
    "a": 1,
    "b": {
        "c": 2,
        "d": 3
    }
}

json2 = {
    "b": {
        "c": 4,
        "e": 5
    },
    "f": 6
}

merged_json = merge_json(json1, json2)
print(json.dumps(merged_json, indent=2))

8. Write a Python function to validate JSON data against a given schema.

JSON schema validation ensures that JSON data conforms to a specified format. This is useful for validating data from external sources. Use the jsonschema library to perform validation.

Example:

import json
from jsonschema import validate, ValidationError

def validate_json(data, schema):
    try:
        validate(instance=data, schema=schema)
        return True
    except ValidationError as e:
        print(f"Validation error: {e.message}")
        return False

# Example usage
data = {
    "name": "John Doe",
    "age": 30
}

schema = {
    "type": "object",
    "properties": {
        "name": {"type": "string"},
        "age": {"type": "integer"}
    },
    "required": ["name", "age"]
}

is_valid = validate_json(data, schema)
print(f"Is the JSON data valid? {is_valid}")

9. Write a Python function to convert JSON data to another format, such as XML, and vice versa.

JSON and XML are both formats for data interchange. JSON is lightweight, while XML is more verbose. Converting between these formats involves parsing the input and generating the output format.

Example:

import json
import dicttoxml
import xmltodict

def json_to_xml(json_data):
    data_dict = json.loads(json_data)
    xml_data = dicttoxml.dicttoxml(data_dict)
    return xml_data.decode()

def xml_to_json(xml_data):
    data_dict = xmltodict.parse(xml_data)
    json_data = json.dumps(data_dict)
    return json_data

# Example usage
json_data = '{"name": "John", "age": 30, "city": "New York"}'
xml_data = json_to_xml(json_data)
print(xml_data)

json_result = xml_to_json(xml_data)
print(json_result)

10. Write a Python function to create a nested JSON structure programmatically.

To create a nested JSON structure programmatically, use dictionaries and lists to build the structure, then convert it to a JSON string.

Example:

import json

def create_nested_json():
    data = {
        "name": "John",
        "age": 30,
        "address": {
            "street": "123 Main St",
            "city": "New York",
            "zipcode": "10001"
        },
        "phone_numbers": [
            {"type": "home", "number": "212-555-1234"},
            {"type": "work", "number": "646-555-5678"}
        ]
    }
    
    json_data = json.dumps(data, indent=4)
    return json_data

print(create_nested_json())