Ich würde gerne weiter ausbauendas Beispiel der automatischen Belebung in einer vorherigen Antwort von gegebennosklo um den Wörterbuchzugriff per Tupel zuzulassen.

Die Lösung von nosklo sieht folgendermaßen aus:

class AutoVivification(dict):
    """Implementation of perl's autovivification feature."""
    def __getitem__(self, item):
        try:
            return dict.__getitem__(self, item)
        except KeyError:
            value = self[item] = type(self)()
            return value

Testen:

a = AutoVivification()

a[1][2][3] = 4
a[1][3][3] = 5
a[1][2]['test'] = 6

print a

Ausgabe:

{1: {2: {'test': 6, 3: 4}, 3: {3: 5}}}

Ich habe einen Fall, in dem ich einen Knoten mit einem beliebigen Tupel von Indizes festlegen möchte. Wenn ich nicht weiß, wie viele Ebenen das Tupel enthält, wie kann ich dann einen Weg finden, um den entsprechenden Knoten festzulegen?

Ich denke, dass ich vielleicht die folgende Syntax verwenden könnte:

mytuple = (1,2,3)
a[mytuple] = 4

Aber ich habe Probleme, eine funktionierende Implementierung zu finden.

Aktualisieren

Ich habe ein voll funktionsfähiges Beispiel basierend auf der Antwort von @ JCash:

class NestedDict(dict):
    """                                                                       
    Nested dictionary of arbitrary depth with autovivification.               

    Allows data access via extended slice notation.                           
    """
    def __getitem__(self, keys):
        # Let's assume *keys* is a list or tuple.                             
        if not isinstance(keys, basestring):
            try:
                node = self
                for key in keys:
                    node = dict.__getitem__(node, key)
                return node
            except TypeError:
            # *keys* is not a list or tuple.                              
                pass
        try:
            return dict.__getitem__(self, keys)
        except KeyError:
            raise KeyError(keys)
    def __setitem__(self, keys, value):
        # Let's assume *keys* is a list or tuple.                             
        if not isinstance(keys, basestring):
            try:
                node = self
                for key in keys[:-1]:
                    try:
                        node = dict.__getitem__(node, key)
                    except KeyError:
                        node[key] = type(self)()
                        node = node[key]
                return dict.__setitem__(node, keys[-1], value)
            except TypeError:
                # *keys* is not a list or tuple.                              
                pass
        dict.__setitem__(self, keys, value)

Welche können die gleiche Ausgabe wie oben mit erweiterten Slice-Notation erzielen:

d = NestedDict()
d[1,2,3] = 4
d[1,3,3] = 5
d[1,2,'test'] = 6