How to Remove a Key from JSON Object in Python

In this tutorial, you’ll learn how to remove a key from a JSON object in Python using various methods.

We’ll cover multiple ways to handle this task, including the use of del keyword, pop() method, dictionary comprehension, and libraries like Pandas.

We’ll also explore handling nested JSON objects, and removing empty keys.

 

 

Using del Keyword

The del keyword in Python allows you to remove a key and its corresponding value.

Suppose you have a JSON object representing customer data, and you need to remove the account number.

Here’s how you can do it:

customer_data = {
    "name": "Jordan",
    "account_number": "12345678",
    "plan": "Unlimited",
    "balance": 30.0
}
del customer_data["account_number"]
print(customer_data)

Output:

{'name': 'Jordan', 'plan': 'Unlimited', 'balance': 30.0}

 

Delete Key If Exists

In Python, attempting to remove a non-existent key from a dictionary (which represents a JSON object) using the del keyword can lead to a KeyError.

To handle this, you must check if the key exists before attempting to delete it.

Here’s how you can safely handle the removal of keys that might not exist in your JSON object:

customer_data = {
    "name": "Morgan",
    "plan": "Unlimited",
    "balance": 50.0
}
key_to_remove = "account_number"
if key_to_remove in customer_data:
    del customer_data[key_to_remove]
    print("Key removed:", key_to_remove)
else:
    print("Key not found:", key_to_remove)
print(customer_data)

Output:

Key not found: account_number
{'name': 'Morgan', 'plan': 'Unlimited', 'balance': 50.0}

In this output, the script checks for the existence of the key account_number before attempting to delete it.

Since the key is not present in customer_data, the message “Key not found: account_number” is displayed, and the dictionary remains unchanged.

 

Using pop() Method

This method not only removes the key-value pair but also returns the value, which can be useful if you need to use it before it’s removed.

customer_data = {
    "name": "Alex",
    "account_number": "987654321",
    "plan": "Basic",
    "balance": 15.0
}
removed_value = customer_data.pop("account_number", None)
print("Removed value:", removed_value)
print(customer_data)

Output:

Removed value: 987654321
{'name': 'Alex', 'plan': 'Basic', 'balance': 15.0}

In this example, pop() is used to remove the account_number.

The second argument, None, is a default value that pop() will return if the specified key is not found. This prevents a KeyError if the key does not exist in the dictionary.

 

Using Dictionary Comprehension

When it comes to removing a key from a JSON object, dictionary comprehension is useful if you want to filter out certain keys without altering the original dictionary.

customer_data = {
    "name": "Taylor",
    "account_number": "11223344",
    "plan": "Premium",
    "balance": 100.0
}

# Create a new dictionary without the account_number
updated_customer_data = {k: v for k, v in customer_data.items() if k != "account_number"}
print(updated_customer_data)

Output:

{'name': 'Taylor', 'plan': 'Premium', 'balance': 100.0}

In this code snippet, dictionary comprehension is used to iterate over customer_data and construct a new dictionary, updated_customer_data, which includes all key-value pairs except the one with the key account_number.

 

Remove Empty Keys

Empty keys could be empty strings or null values.

You can use dictionary comprehension which allows you to iterate over the key-value pairs in the JSON object and include only those pairs where the key is not empty.

customer_data = {
    "": "empty key",
    "name": "Chris",
    "plan": "Premium",
    "balance": 80.0
}
cleaned_data = {k: v for k, v in customer_data.items() if k}
print(cleaned_data)

Output:

{'name': 'Chris', 'plan': 'Premium', 'balance': 80.0}

In this example, dictionary comprehension is used to create a new dictionary, cleaned_data, which includes all key-value pairs from customer_data, excluding those where the key is empty.

 

Using popitem() Method

The popitem() method removes and returns the last key-value pair from the dictionary.

While it’s not typically used for targeting specific keys (since it removes the last item), it can be useful in cases where you need to process and remove items iteratively.

customer_data = {
    "name": "Sam",
    "account_number": "543210",
    "plan": "Data Saver",
    "balance": 25.0
}
removed_item = customer_data.popitem()
print("Removed item:", removed_item)
print(customer_data)

Output:

Removed item: ('balance', 25.0)
{'name': 'Sam', 'account_number': '543210', 'plan': 'Data Saver'}

In this output, the popitem() method removes the last key-value pair from customer_data.

The method returns a tuple containing the removed key and value.

After the removal, you can see that the key balance and its corresponding value 25.0 are no longer in the dictionary.

This method is particularly useful for cases where the order of items is significant, or when you need to process elements in a LIFO (Last In, First Out) way.

 

Using Pandas

First, you’ll need to install Pandas if you haven’t already. You can do this using pip:

pip install pandas

Now, let’s proceed with the example:

import pandas as pd
data = {
    "name": ["Adrian"],
    "account_number": ["23456789"],
    "plan": ["Super Value"],
    "balance": [45.0]
}
df = pd.DataFrame(data)
df.drop(columns=['account_number'], inplace=True)
print(df.to_json(orient="records"))

Output:

[{"name":"Adrian","plan":"Super Value","balance":45.0}]

In this code snippet, the JSON object is first converted into a Pandas DataFrame. Then, the drop method is used to remove the column corresponding to the key account_number.

The inplace=True argument ensures that the change is made directly to the DataFrame without creating a new one.

We used Pandas to_json to convert the DataFrame back to JSON format.

 

Remove Key from Nested JSON If Exists

You can use a recursive function to traverse and modify nested dictionaries.

def remove_key_recursively(data, key_to_remove):
    if isinstance(data, dict):
        # If it's a dictionary, proceed to remove the key
        data.pop(key_to_remove, None)
        for key, value in data.items():
            remove_key_recursively(value, key_to_remove)
    elif isinstance(data, list):
        # If it's a list, apply the function to each element
        for item in data:
            remove_key_recursively(item, key_to_remove)
customer_data = {
    "name": "Jordan",
    "account_info": {
        "account_number": "12345678",
        "plan": "Unlimited",
        "balance": 30.0
    },
    "history": [
        {"date": "2023-01-01", "account_number": "12345678", "transaction": "Deposit"},
        {"date": "2023-02-01", "account_number": "12345678", "transaction": "Withdrawal"}
    ]
}
remove_key_recursively(customer_data, "account_number")
print(customer_data)

Output:

{
    'name': 'Jordan',
    'account_info': {'plan': 'Unlimited', 'balance': 30.0},
    'history': [
        {'date': '2023-01-01', 'transaction': 'Deposit'},
        {'date': '2023-02-01', 'transaction': 'Withdrawal'}
    ]
}

In this example, the function remove_key_recursively is defined to remove a specified key from a nested JSON object.

It checks whether the current data is a dictionary or a list and applies the necessary operation.