defaultdict de defaultdict ?

Question

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

d doit être construit de manière ad-hoc, en fonction de x.a y x.b éléments.

Je pourrais utiliser :

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

mais alors je ne pourrais pas l'utiliser :

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

Answer 1

Oui, comme ça :

defaultdict(lambda: defaultdict(int))

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

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

Answer 2

Le paramètre du constructeur de defaultdict est la fonction qui sera appelée pour construire de nouveaux éléments. Utilisons donc 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 fonction 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, voir PyMOTW - Collections - Types de données des conteneurs y Documentation Python - collections

Answer 3

Les réponses précédentes ont traité de la façon de faire un système à deux niveaux ou à n niveaux. defaultdict . Dans certains cas, vous voulez une infinité :

def ddict():
    return defaultdict(ddict)

Utilisation :

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

Answer 4

Je trouve qu'il est légèrement plus élégant d'utiliser partial :

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

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

Answer 5

À titre de référence, il est possible de mettre en œuvre un système générique imbriqué. defaultdict méthode d'usine à travers :

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 dictionnaire imbriqué avant le type défini dans default_factory est utilisé. Par exemple :

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