Python: defaultdict de defaultdict?

Existe-t-il un moyen d'avoir un defaultdict(defaultdict(int))afin de faire fonctionner le code suivant?

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

ddoit être construit de manière ad hoc, en fonction des éléments x.aet x.b.

Je pourrais utiliser:

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

mais je ne pourrais pas utiliser:

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

Oui comme ça:

defaultdict(lambda: defaultdict(int))

L'argument d'un defaultdict(dans ce cas est lambda: defaultdict(int)) sera appelé lorsque vous essayez d'accéder à une clé qui n'existe pas. La valeur de retour de celle-ci sera définie comme la nouvelle valeur de cette clé, ce qui signifie dans notre cas que la valeur de d[Key_doesnt_exist]sera defaultdict(int).

Si vous essayez d'accéder à une clé de ce dernier defaultdict, c'est- d[Key_doesnt_exist][Key_doesnt_exist]à- dire qu'elle retournera 0, qui est la valeur de retour de l'argument du dernier defaultdict, c'est-à-dire int().

Le paramètre du constructeur defaultdict est la fonction qui sera appelée pour construire de nouveaux éléments. Alors utilisons un lambda!

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

Depuis Python 2.7, il existe une solution encore meilleure en utilisant 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})

Quelques bonus

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

Pour plus d'informations, consultez PyMOTW - Collections - Types de données de conteneur et documentation Python - collections

Je le trouve un peu plus élégant à utiliser partial:

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

Bien sûr, c'est la même chose qu'une lambda.

Pour référence, il est possible d'implémenter une defaultdictméthode d'usine imbriquée générique via:

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 profondeur définit le nombre de dictionnaires imbriqués avant que le type défini dans ne default_factorysoit utilisé. Par exemple:

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

Les réponses précédentes ont porté sur la façon de créer un niveau à deux niveaux ou n defaultdict. Dans certains cas, vous en voulez un infini:

def ddict():
    return defaultdict(ddict)

Usage:

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

D'autres ont répondu correctement à votre question sur la façon de faire fonctionner les éléments suivants:

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

Une alternative serait d'utiliser des tuples pour les clés:

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

La bonne chose à propos de cette approche est qu'elle est simple et peut être facilement développée. Si vous avez besoin d'une cartographie à trois niveaux, utilisez simplement un tuple à trois éléments pour la clé.