Safe method to get value of nested dictionary

python

error-handling

nested-dictionaries

best-practices

byAnton Shumikhin·Oct 3, 2024

If you have to navigate through the choppy waters of a deeply nested dictionary, use chained get calls. This elegant solution can step around the pesky potholes of exceptions:

# You have a dictionary that looks like a Russian novel:
nested_dict = {'a': {'b': {'c': 'd'}}}

# Get the value or run to 'Default' if any key is MIA:
value = nested_dict.get('a', {}).get('b', {}).get('c', 'Default')

The above code fetches 'd' or defaults to 'Default' if the nested_dict decides to play hide and seek.

Grace under pressure: Handling missing keys

A common reason for application crashes is non-existent keys in nested dictionaries. To prevent your software from throwing a tantrum mid-execution, you can wrap potential KeyError exceptions in a soft, comforting layer of error handling:

def safeget(dct, *keys, default=None):
    for key in keys:
        try:
            dct = dct[key]  # trying to access the keys without breaking a sweat! 😉
        except (KeyError, TypeError):
            return default  # If stuff goes south, we have a safety net!
    return dct

# Usage:
value = safeget(nested_dict, 'a', 'b', 'c', default='Default')

This function is a comforting cup of hot chocolate in the cold winter days of error handling.

Efficiency++ with the 'deep_get' function

Valuable time is an irreplaceable asset. To reduce execution time when retrieving deeply nested dictionary values, you can employ the deep_get function. It takes a detour through the scenic route of the functools.reduce and get method:

from functools import reduce  # We are not talking about your carbon footprint here! 😄

def deep_get(dct, keys, default=None):
    return reduce(
        lambda d, key: d.get(key, default) if isinstance(d, dict) else default,
        keys.split('.'), dct
    )

# Usage:
value = deep_get(nested_dict, 'a.b.c', default='Default')

This method is the fast-forward button on your console of nested dictionary operations.

'Hasher': A treasure chest of flexibility

For those looking to seamlessly interconvert between regular dictionaries & robust structures, the Hasher class is akin to a golden chariot:

class Hasher(dict):
    def get(self, path, default=None):
        return deep_get(self, path, default=default)

# Usage:
hasher_dict = Hasher(nested_dict)
value = hasher_dict.get('a.b.c', default='Default')

The Hasher class is basically your genie-in-a-bottle that can be customized for more complex logic or error reporting.

Sturdy fortifications: Robust type checking

There might be times when your data types enjoy playing musical chairs. Utilizing isinstance() checks can prevent a Type Error from crashing your party:

def deep_get(dct, keys, default=None):
    for key in keys.split('.'):
        if isinstance(dct, dict):  # Are you sure it's a dictionary, not a list in disguise? 🕵️‍♀️
            dct = dct.get(key, default)
        else:
            return default  # Return default if our dictionary is actually a 'list' in a 'dict' costume.
    return dct

This strategy ensures that only dictionaries are passed to get, providing a consistent and error-free system.

Dos and don'ts: Practical tips

Here are some practical gems to enhance your experience with nested dictionary access:

Set {} as default for the get method to avoid AttributeError for non-existent nested dictionaries.
Keep your main flow clean - encapsulate error handling in dedicated functions or classes.
Custom solutions like Hasher or safeget are great for customized handling.
Code Pythonically - Consult PEP 20, the Zen of Python, for a pro-level Python experience.