How To Handle JSON missing keys in Python

In this tutorial, you’ll learn several methods to handle JSON data with missing keys or null values.

You’ll learn various methods to address these challenges, including using try-except blocks, the get method with default values, and Python’s defaultdict.



Using try-except blocks

When working with JSON in Python, you can use try-except blocks to handle missing keys.

Using try-except, you can catch the KeyError and handle it:

customer_data = {
    "name": "Taylor",
    "age": 30
    email = customer_data["email"]
except KeyError:
    email = "No email provided"


No email provided

In this example, attempting to access the ’email’ key throws a KeyError, which is caught by the except block.


Using the get() Method with Default Values

You can use the get() method in Python for safely accessing values in a dictionary, such as a JSON object.

It allows you to specify a default value that is returned when the requested key is not found.

This approach is useful in avoiding KeyError exceptions and managing missing data.

user_profile = {
    "username": "user123",
    "age": 27
email = user_profile.get("email", "")
membership_status = user_profile.get("membership_status", "Free")
print("Email:", email)
print("Membership Status:", membership_status)


Membership Status: Free

In this code, get() checks for the ’email’ and ‘membership_status’ keys. Since they are not present, it returns the specified default values.

Handling Null Values in JSON

Sometimes, keys might be present, but their values are null (None in Python). Here’s a method to handle such cases:

customer_data = {
    "name": "Alex",
    "age": 28,
    "email": None
email = customer_data.get("email")
if email is None:
    email = "No email provided"


No email provided

Here, the code checks if the ’email’ key exists but has a null value, then provides a default message.

The same way when you deal with nested JSON objects, using get with default values can prevent errors due to missing nested keys. Here’s an example:

user_data = {
    "username": "user456",
    "details": {
        "age": 32
address = user_data.get("details", {}).get("address", "No address provided")
print("Address:", address)


Address: No address provided

Here, the first get safely accesses the ‘details’ key, and the second get looks for the ‘address’ key within the nested dictionary.

The empty dictionary {} serves as a default value to prevent errors if ‘details’ is missing.


Using Python defaultdict for Default Values

Python’s collections module offers defaultdictwhich is a variant of the standard dictionary (dict) that automatically assigns a default value when a key that doesn’t exist is accessed.

First, let’s see how to use defaultdict to provide default values.

from collections import defaultdict
customer_data = defaultdict(lambda: 'Not Available', {
    "name": "Morgan",
    "age": 40
print("Name:", customer_data["name"])
print("Email:", customer_data["email"])  # Key not present in the original data


Name: Morgan
Email: Not Available

In this code, defaultdict is initialized with a lambda function that returns ‘Not Available’. This value is used whenever a key is not found in customer_data.

defaultdict can also be useful for nested JSON structures, providing a default value at each level of nesting:

def recursive_defaultdict():
    return defaultdict(recursive_defaultdict)
user_profile = defaultdict(recursive_defaultdict, {
    "username": "userXYZ",
    "details": {
        "age": 29
print("Username:", user_profile["username"])
print("Address:", user_profile["details"]["address"])  # Nested key not present


Username: userXYZ
Address: defaultdict(<function recursive_defaultdict at 0x...>, {})

Here, the recursive_defaultdict function creates a defaultdict that can handle multiple levels of nesting.

If a nested key is missing, it returns another defaultdict instead of throwing a KeyError.

Leave a Reply

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