Python: defaultdict von defaultdict?

Gibt es eine Möglichkeit, eine zu haben defaultdict(defaultdict(int)), damit der folgende Code funktioniert?

for x in stuff:
    d[x.a][x.b] += x.c_int

dmuss ad-hoc erstellt werden, abhängig von x.aund x.bElementen.

Ich könnte benutzen:

for x in stuff:
    d[x.a,x.b] += x.c_int

aber dann könnte ich nicht verwenden:

d.keys()
d[x.a].keys()

Ja genau so:

defaultdict(lambda: defaultdict(int))

Das Argument von a defaultdict(in diesem Fall is lambda: defaultdict(int)) wird aufgerufen, wenn Sie versuchen, auf einen nicht vorhandenen Schlüssel zuzugreifen. Der Rückgabewert wird als neuer Wert dieses Schlüssels festgelegt, was in unserem Fall bedeutet, dass der Wert von sein d[Key_doesnt_exist]wird defaultdict(int).

Wenn Sie versuchen, von diesem letzten Standarddikt auf einen Schlüssel zuzugreifen d[Key_doesnt_exist][Key_doesnt_exist], gibt er 0 zurück. Dies ist der Rückgabewert des Arguments des letzten Standarddikts, d int(). H.

Der Parameter für den defaultdict-Konstruktor ist die Funktion, die zum Erstellen neuer Elemente aufgerufen wird. Verwenden wir also ein Lambda!

>>> from collections import defaultdict
>>> d = defaultdict(lambda : defaultdict(int))
>>> print d[0]
defaultdict(<type 'int'>, {})
>>> print d[0]["x"]
0

Seit Python 2.7 gibt es eine noch bessere Lösung mit Counter :

>>> from collections import Counter
>>> c = Counter()
>>> c["goodbye"]+=1
>>> c["and thank you"]=42
>>> c["for the fish"]-=5
>>> c
Counter({'and thank you': 42, 'goodbye': 1, 'for the fish': -5})

Einige Bonusfunktionen

>>> c.most_common()[:2]
[('and thank you', 42), ('goodbye', 1)]

Weitere Informationen finden Sie unter PyMOTW - Sammlungen - Containerdatentypen und Python-Dokumentation - Sammlungen

Ich finde es etwas eleganter zu benutzen partial:

import functools
dd_int = functools.partial(defaultdict, int)
defaultdict(dd_int)

Dies ist natürlich dasselbe wie ein Lambda.

Als Referenz ist es möglich, eine generische verschachtelte defaultdictFactory-Methode zu implementieren , indem Sie:

from collections import defaultdict
from functools import partial
from itertools import repeat


def nested_defaultdict(default_factory, depth=1):
    result = partial(defaultdict, default_factory)
    for _ in repeat(None, depth - 1):
        result = partial(defaultdict, result)
    return result()

Die Tiefe definiert die Anzahl der verschachtelten Wörterbücher, bevor der in definierte Typ default_factoryverwendet wird. Zum Beispiel:

my_dict = nested_defaultdict(list, 3)
my_dict['a']['b']['c'].append('e')

Frühere Antworten befassten sich mit der Erstellung von zwei oder n Ebenen defaultdict. In einigen Fällen möchten Sie eine unendliche:

def ddict():
    return defaultdict(ddict)

Verwendungszweck:

>>> d = ddict()
>>> d[1]['a'][True] = 0.5
>>> d[1]['b'] = 3
>>> import pprint; pprint.pprint(d)
defaultdict(<function ddict at 0x7fcac68bf048>,
            {1: defaultdict(<function ddict at 0x7fcac68bf048>,
                            {'a': defaultdict(<function ddict at 0x7fcac68bf048>,
                                              {True: 0.5}),
                             'b': 3})})

Andere haben Ihre Frage, wie Sie Folgendes zum Laufen bringen können, richtig beantwortet:

for x in stuff:
    d[x.a][x.b] += x.c_int

Eine Alternative wäre die Verwendung von Tupeln für Schlüssel:

d = defaultdict(int)
for x in stuff:
    d[x.a,x.b] += x.c_int
    # ^^^^^^^ tuple key

Das Schöne an diesem Ansatz ist, dass er einfach ist und leicht erweitert werden kann. Wenn Sie eine dreistufige Zuordnung benötigen, verwenden Sie einfach ein Tupel mit drei Elementen für den Schlüssel.