Python: defaultdict of defaultdict?

C'è un modo per avere un defaultdict(defaultdict(int))per far funzionare il seguente codice?

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

ddeve essere costruita ad-hoc, seconda x.ae x.belementi.

Potrei usare:

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

ma poi non sarei in grado di usare:

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

Sì come questo:

defaultdict(lambda: defaultdict(int))

L'argomento di un defaultdict(in questo caso è lambda: defaultdict(int)) verrà chiamato quando si tenta di accedere a una chiave che non esiste. Il valore di ritorno verrà impostato come nuovo valore di questa chiave, il che significa che nel nostro caso il valore di d[Key_doesnt_exist]sarà defaultdict(int).

Se si tenta di accedere a una chiave da questo ultimo defaultdict cioè d[Key_doesnt_exist][Key_doesnt_exist]restituirà 0, che è il valore restituito dall'argomento dell'ultimo defaultdict ie int().

Il parametro per il costruttore defaultdict è la funzione che verrà chiamata per la creazione di nuovi elementi. Quindi usiamo un lambda!

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

Da Python 2.7, c'è una soluzione ancora migliore usando 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})

Alcune funzioni bonus

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

Per ulteriori informazioni, consultare PyMOTW - Collezioni - Tipi di dati contenitore e Documentazione Python - Collezioni

Lo trovo leggermente più elegante da usare partial:

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

Certo, questo è lo stesso di una lambda.

Per riferimento, è possibile implementare un defaultdictmetodo factory nidificato generico tramite:

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()

La profondità definisce il numero di dizionario nidificato prima dell'utilizzo del tipo definito in default_factory. Per esempio:

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

Le risposte precedenti hanno indicato come creare due livelli o livelli n defaultdict. In alcuni casi ne vuoi uno infinito:

def ddict():
    return defaultdict(ddict)

Uso:

>>> 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})})

Altri hanno risposto correttamente alla tua domanda su come far funzionare quanto segue:

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

Un'alternativa sarebbe usare le tuple per le chiavi:

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

La cosa bella di questo approccio è che è semplice e può essere facilmente ampliato. Se hai bisogno di una mappatura profonda tre livelli, usa semplicemente una tupla a tre elementi per la chiave.