Verschachteltes Standarddikt des Standarddikts

Gibt es eine Möglichkeit, ein Standarddikt auch zum Standard für das Standarddikt zu machen? (dh rekursives Standarddikt mit unendlicher Ebene?)

Ich möchte in der Lage sein:

x = defaultdict(...stuff...)
x[0][1][0]
{}

Also kann ich tun x = defaultdict(defaultdict), aber das ist nur eine zweite Ebene:

x[0]
{}
x[0][0]
KeyError: 0

Es gibt Rezepte, die dies tun können. Aber kann es einfach mit den normalen defaultdict-Argumenten gemacht werden?

Beachten Sie, dass hier gefragt wird, wie ein rekursives Standarddikt auf unendlicher Ebene erstellt werden soll. Es unterscheidet sich also von Python: Standarddikt des Standarddikts? , wie man ein zweistufiges Standarddikt macht.

Ich werde wahrscheinlich nur das Bündelmuster verwenden , aber als mir klar wurde, dass ich nicht wusste, wie ich das machen soll, hat mich das interessiert.

Für eine beliebige Anzahl von Ebenen:

def rec_dd():
    return defaultdict(rec_dd)

>>> x = rec_dd()
>>> x['a']['b']['c']['d']
defaultdict(<function rec_dd at 0x7f0dcef81500>, {})
>>> print json.dumps(x)
{"a": {"b": {"c": {"d": {}}}}}

Natürlich kann man das auch mit einem Lambda machen, aber ich finde Lambdas weniger lesbar. Auf jeden Fall würde es so aussehen:

rec_dd = lambda: defaultdict(rec_dd)

Die anderen Antworten hier zeigen Ihnen, wie Sie eine erstellen, defaultdictdie "unendlich viele" enthält defaultdict, aber sie sprechen nicht das an, was meiner Meinung nach Ihr ursprüngliches Bedürfnis gewesen sein könnte, einfach ein Zwei-Tiefen-Standarddikt zu haben.

Sie haben vielleicht gesucht:

defaultdict(lambda: defaultdict(dict))

Die Gründe, warum Sie dieses Konstrukt bevorzugen könnten, sind:

• Es ist expliziter als die rekursive Lösung und daher für den Leser wahrscheinlich verständlicher.
• Dies ermöglicht, dass das "Blatt" des defaultdictetwas anderes als ein Wörterbuch ist, z. B.: defaultdict(lambda: defaultdict(list))Oderdefaultdict(lambda: defaultdict(set))

Dafür gibt es einen raffinierten Trick:

tree = lambda: defaultdict(tree)

Dann können Sie Ihre xmit erstellen x = tree().

Ähnlich wie die Lösung von BrenBarn, enthält jedoch nicht treezweimal den Namen der Variablen , sodass sie auch nach Änderungen am Variablenwörterbuch funktioniert:

tree = (lambda f: f(f))(lambda a: (lambda: defaultdict(a(a))))

Dann können Sie jedes neue xmit erstellen x = tree().

Für die defVersion können wir den Funktionsabschlussbereich verwenden, um die Datenstruktur vor dem Fehler zu schützen, bei dem vorhandene Instanzen nicht mehr funktionieren, wenn der treeName neu gebunden wird. Es sieht aus wie das:

from collections import defaultdict

def tree():
    def the_tree():
        return defaultdict(the_tree)
    return the_tree()

Ich würde auch eine Implementierung im OOP-Stil vorschlagen, die sowohl eine unendliche Verschachtelung als auch eine ordnungsgemäße Formatierung unterstützt repr.

class NestedDefaultDict(defaultdict):
    def __init__(self, *args, **kwargs):
        super(NestedDefaultDict, self).__init__(NestedDefaultDict, *args, **kwargs)

    def __repr__(self):
        return repr(dict(self))

Verwendung:

my_dict = NestedDefaultDict()
my_dict['a']['b'] = 1
my_dict['a']['c']['d'] = 2
my_dict['b']

print(my_dict)  # {'a': {'b': 1, 'c': {'d': 2}}, 'b': {}}

Hier ist eine rekursive Funktion zum Konvertieren eines rekursiven Standarddiktats in ein normales Diktat

def defdict_to_dict(defdict, finaldict):
    # pass in an empty dict for finaldict
    for k, v in defdict.items():
        if isinstance(v, defaultdict):
            # new level created and that is the new value
            finaldict[k] = defdict_to_dict(v, {})
        else:
            finaldict[k] = v
    return finaldict

defdict_to_dict(my_rec_default_dict, {})

Ich habe diese Antwort von Andrew hier begründet. Wenn Sie Daten von einem JSON oder einem vorhandenen Diktat in das Standarddikt des Nesters laden möchten, sehen Sie sich dieses Beispiel an:

def nested_defaultdict(existing=None, **kwargs):
    if existing is None:
        existing = {}
    if not isinstance(existing, dict):
        return existing
    existing = {key: nested_defaultdict(val) for key, val in existing.items()}
    return defaultdict(nested_defaultdict, existing, **kwargs)

https://gist.github.com/nucklehead/2d29628bb49115f3c30e78c071207775