Check if a nested key exists in a Dictionary in Python

# Table of Contents

1. Check if a nested key exists in a Dictionary in Python
2. Check if a nested key exists in a Dictionary using dict.get()
3. Remove keys from a nested Dictionary in Python
4. Remove keys from a nested Dictionary without mutating original

Note: If you need to remove keys from a nested dictionary, click on the following subheading:

• Remove keys from a nested Dictionary in Python

# Check if a nested key exists in a Dictionary in Python

Use a try/except statement to check if a nested key exists in a dictionary.

If one or more of the nested keys doesn't exist, a KeyError is raised and is then handled by the except block.

Copied!
my_dict = {
    'address': {
        'country': 'Finland',
        'city': 'Oulu'
    }
}

try:
    city = my_dict['address']['city']
    print(city)  # 👉️ Oulu
except KeyError:
    print('The specified key does NOT exist')

# -------------------------------------------------

try:
    result = my_dict['not']['found']['key']
except KeyError:
    # 👇️ this runs
    print('The specified key does NOT exist')

We try to access a nested key in the try block of the try/except statement.

# If one of the keys doesn't exist, a KeyError exception is raised

If one of the keys doesn't exist, a KeyError exception is raised and is then handled by the except block.

You can use a pass statement if you need to ignore the exception.

Copied!
my_dict = {
    'address': {
        'country': 'Finland',
        'city': 'Oulu'
    }
}

try:
    result = my_dict['not']['found']['key']
except KeyError:
    pass

The pass statement does nothing and is used when a statement is required syntactically but the program requires no action.

# Creating a reusable function

If you have to do this often, extract the logic into a reusable function.

Copied!
def keys_exists(dictionary, keys):
    nested_dict = dictionary

    for key in keys:
        try:
            nested_dict = nested_dict[key]
        except KeyError:
            return False
    return True


my_dict = {
    'address': {
        'country': 'Finland',
        'city': 'Oulu'
    }
}

# 👇️ True
print(
    keys_exists(my_dict, ['address', 'city'])
)


# 👇️ False
print(
    keys_exists(my_dict, ['key', 'not', 'found'])
)

The function takes a dictionary and a list of keys and checks if the sequence of keys exist in the dictionary.

We iterate over the list of keys and try to access each nested key, so the order of the keys in the list is important.

The function returns True if the sequence of keys exists in the dictionary, otherwise False is returned.

Alternatively, you can use the dict.get() method.

# Table of Contents

1. Check if a nested key exists in a Dictionary using dict.get()
2. Remove keys from a nested Dictionary in Python
3. Remove keys from a nested Dictionary without mutating original

# Check if a nested key exists in a Dictionary using dict.get()

This is a three-step process:

1. Use the dict.get() method to get each key.
2. Specify an empty dictionary as a default value if the key doesn't exist.
3. You can chain as many calls to the dict.get() method as necessary.

Copied!
my_dict = {
    'address': {
        'country': 'Finland',
        'city': 'Oulu'
    }
}

result = my_dict.get('address', {}).get('city')
print(result)  # 👉️ Oulu

result = my_dict.get('key', {}).get('not', {}).get('found')
print(result)  # 👉️ None

The dict.get method returns the value for the given key if the key is in the dictionary, otherwise a default value is returned.

The method takes the following 2 parameters:

If a value for the default parameter is not provided, it defaults to None, so the get() method never raises a KeyError.

If the specified key doesn't exist an empty dictionary is returned on which we can safely call the dict.get() method again.

You don't have to pass an empty dictionary in the last call to dict.get() because the method returns None if a default value is not provided and the key doesn't exist.

Copied!
my_dict = {
    'address': {
        'country': 'Finland',
        'city': 'Oulu'
    }
}

result = my_dict.get('key', {}).get('not', {}).get('found')
print(result)  # 👉️ None

Which approach you pick is a matter of personal preference. I'd use a try/except statement because I find them quite direct and easy to read.

# Table of Contents

1. Remove keys from a nested Dictionary in Python
2. Remove keys from a nested Dictionary without mutating original

# Remove keys from a nested Dictionary in Python

To remove keys from a nested dictionary:

1. Use a for loop to iterate over the collection of keys to remove.
2. Remove all direct keys from the dictionary.
3. Iterate over the dictionary's values and recursively remove the specified keys.

Copied!
def remove_nested_keys(dictionary, keys_to_remove):
    for key in keys_to_remove:
        if key in dictionary:
            del dictionary[key]

    for value in dictionary.values():
        if isinstance(value, dict):
            remove_nested_keys(value, keys_to_remove)

    return dictionary


my_dict = {
    'address': {
        'country': 'Finland',
        'city': 'Oulu',
    },
    'name': 'Frank',
    'age': 30,
}

# 👇️ {'address': {'country': 'Finland'}, 'name': 'Frank'}
print(remove_nested_keys(my_dict, ['city', 'age']))

We created a reusable function that takes a dictionary and a list of keys and removes the specified nested and non-nested keys from the dictionary.

The first step is to iterate over the list of keys to be removed.

Copied!
for key in keys_to_remove:
    if key in dictionary:
        del dictionary[key]

On each iteration, we check if the key is present in the dictionary and if the condition is met, we remove the key.

This for loop takes care of removing all of the specified non-nested keys.

The next step is to iterate over the dictionary's values.

Copied!
for value in dictionary.values():
    if isinstance(value, dict):
        remove_nested_keys(value, keys_to_remove)

The dict.values method returns a new view of the dictionary's values.

Copied!
my_dict = {'id': 1,  'name': 'bobbyhadz'}

print(my_dict.values())  # 👉️ dict_values([1, 'bobbyhadz'])

Then the function iterates over the list of keys again and uses the del to remove the specified keys.

The isinstance function returns True if the passed-in object is an instance or a subclass of the passed-in class.

Copied!
# 👇️ True
print(
    isinstance({'site': 'bobbyhadz.com'}, dict)
)

# 👇️ False
print(
    isinstance(['a', 'b', 'c'], dict)
)

The function removes the keys from the nested dictionary in place. In other words, it mutates the original dict object.

# Remove keys from a nested Dictionary without mutating original

If you'd rather not mutate the original dictionary:

1. Use a for loop to iterate over the dictionary's items.
2. Check if each key is not in the list of keys to be removed.
3. If the current key is not a dictionary, add the key-value pair to a new dictionary.
4. If the key is a dictionary, call the function recursively.

Copied!
# ✅ function returns new dictionary (does NOT mutate original)

def remove_nested_keys(dictionary, keys_to_remove):
    new_dict = {}

    for key, value in dictionary.items():
        if key not in keys_to_remove:
            if isinstance(value, dict):
                new_dict[key] = remove_nested_keys(value, keys_to_remove)
            else:
                new_dict[key] = value

    return new_dict


my_dict = {
    'address': {
        'country': 'Finland',
        'city': 'Oulu',
    },
    'name': 'Frank',
    'age': 30,
}

result = remove_nested_keys(my_dict, ['country', 'name'])
print(result)  # 👉️ {'address': {'city': 'Oulu'}, 'age': 30}

result = remove_nested_keys(my_dict, ['city', 'age'])
print(result)  # 👉️ {'address': {'country': 'Finland'}, 'name': 'Frank'}

We used a for loop to iterate over the dictionary's items.

The dict.items method returns a new view of the dictionary's items ((key, value) pairs).

Copied!
my_dict = {'id': 1,  'name': 'BobbyHadz'}

# 👇️ dict_items([('id', 1), ('name', 'BobbyHadz')])
print(my_dict.items())

On each iteration, we check if the current key is not one of the keys to be removed.

Copied!
for key, value in dictionary.items():
    if key not in keys_to_remove:
        if isinstance(value, dict):
            new_dict[key] = remove_nested_keys(value, keys_to_remove)
        else:
            new_dict[key] = value

The isinstance() function then checks if the key points to a dictionary value.

If the key stores a dictionary, the remove_nested_keys function is invoked with the nested dictionary and the list of keys to remove.

If the key doesn't store a dictionary, the key-value pair gets added to the new dictionary.

The function returns the newly constructed dictionary excluding all of the keys in the list.

# Additional Resources

You can learn more about the related topics by checking out the following tutorials:

• Check if a value exists in a List of Dictionaries in Python
• Check if all values in a Dictionary are equal in Python
• Check if multiple Keys exist in a Dictionary in Python