Nested dictionaries in python with error when accessing non-existent key

The problem you’ll run into is that, in order to set an item on a nested dictionary, you must first be able to get all the parent items. For example:

d[1][2][3] = 42

requires getting d[1][2] in order to set d[1][2][3]. There’s no way to know whether an assignment is in process when you are accessing the intermediate dictionaries, so the only way to get assignment to work is to always create the sub-dictionary on access. (You could return some kind of proxy object instead of creating the sub-dictionary, and defer creation of the intermediate dictionaries until assignment, but you’re still not going to get an error when you access a path that doesn’t exist.)

The simplest way around this is to use a single tuple key rather than repeated subkeys. In other words, instead of setting d[1][2][3] you would set d[1, 2, 3]. Assignments then are self-contained operations: they do not require getting any intermediate nesting levels, so you can create the intermediate levels only on assignment.

As a bonus, you may find working with a tuple much more straightforward when passing multiple keys around, since you can just stick ’em in the [] and get the item you want.

You could do this with a single dictionary, using the tuples as keys. However, this loses the hierarchical structure of the data. The implementation below uses sub-dictionaries. A dictionary subclass called node is used so that we can assign an attribute on the dictionary to represent the value of the node at that location; this way, we can store values on the intermediate nodes as well as at the leaves. (It has a __repr__ method that shows both the node’s value and its children, if it has any.) The __setitem__ method of the tupledict class handles creating intermediate nodes when assigning an element. __getitem__ traverses the nodes to find the value you want. (If you want to access the individual nodes as nodes, you can use get() to reach them one at a time.)

class tupledict(dict):

    class node(dict):
        def __repr__(self):
            if self:
                if hasattr(self, "value"):
                    return repr(self.value) + ", " + dict.__repr__(self)
                return dict.__repr__(self)
            else:
                return repr(self.value)

    def __init__(self):
        pass

    def __setitem__(self, key, value):
        if not isinstance(key, tuple):   # handle single value
            key = [key]
        d = self
        for k in key:
            if k not in d:
                dict.__setitem__(d, k, self.node())
            d = dict.__getitem__(d, k)
        d.value = value

    def __getitem__(self, key):
        if not isinstance(key, tuple):
            key = [key]
        d = self
        for k in key:
            try:
                d = dict.__getitem__(d, k)
            except KeyError:
                raise KeyError(key[0] if len(key) == 1 else key)
        try:
            return d.value
        except AttributeError:
            raise KeyError(key[0] if len(key) == 1 else key)

Usage:

td = tupledict()
td['foo', 'bar'] = 'spam'
td['foo', 'eggs']   # KeyError

key = 'foo', 'bar'
td[key]    # 'spam'