Defaultdict imbriqué de defaultdict

Existe-t-il un moyen de faire d'un defaultdict également la valeur par défaut pour le defaultdict? (ie defaultdict récursif de niveau infini?)

Je veux pouvoir faire:

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

Donc, je peux le faire x = defaultdict(defaultdict), mais ce n'est qu'un deuxième niveau:

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

Il existe des recettes qui peuvent le faire. Mais cela peut-il être fait simplement en utilisant les arguments normaux defaultdict?

Notez que cela demande comment faire un defaultdict récursif de niveau infini, donc il est distinct de Python: defaultdict de defaultdict? , qui était comment faire un defaultdict à deux niveaux.

Je finirai probablement par utiliser le modèle de groupe , mais quand j'ai réalisé que je ne savais pas comment faire cela, cela m'a intéressé.

Pour un nombre arbitraire de niveaux:

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": {}}}}}

Bien sûr, vous pouvez également le faire avec un lambda, mais je trouve que les lambdas sont moins lisibles. Dans tous les cas, cela ressemblerait à ceci:

rec_dd = lambda: defaultdict(rec_dd)

Les autres réponses ici vous indiquent comment créer un " defaultdictqui contient" une infinité " defaultdict, mais elles ne parviennent pas à répondre à ce que je pense avoir été votre besoin initial qui était simplement d'avoir un defaultdict à deux profondeurs.

Vous cherchiez peut-être:

defaultdict(lambda: defaultdict(dict))

Les raisons pour lesquelles vous pourriez préférer cette construction sont:

• Elle est plus explicite que la solution récursive, et donc probablement plus compréhensible pour le lecteur.
• Cela permet à la "feuille" de defaultdictêtre autre chose qu'un dictionnaire, par exemple: defaultdict(lambda: defaultdict(list))oudefaultdict(lambda: defaultdict(set))

Il y a une astuce astucieuse pour faire cela:

tree = lambda: defaultdict(tree)

Ensuite, vous pouvez créer votre xavec x = tree().

Similaire à la solution de BrenBarn, mais ne contient pas le nom de la variable treedeux fois, donc cela fonctionne même après des modifications du dictionnaire de variables:

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

Ensuite, vous pouvez créer chaque nouveau xavec x = tree().

Pour la defversion, nous pouvons utiliser la portée de fermeture de fonction pour protéger la structure de données de la faille où les instances existantes cessent de fonctionner si le treenom est rebondi. Cela ressemble à ceci:

from collections import defaultdict

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

Je proposerais également une implémentation plus de style POO, qui prend en charge l'imbrication infinie ainsi que correctement formatée repr.

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

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

Usage:

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': {}}

voici une fonction récursive pour convertir un dict par défaut récursif en un dict normal

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

J'ai basé ceci de la réponse d'Andrew ici. Si vous cherchez à charger des données à partir d'un json ou d'un dict existant dans le defaultdict de nester, consultez cet exemple:

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