Zagnieżdżony defaultdict o defaultdict

Czy istnieje sposób, aby defaultdict był również domyślny dla defaultdict? (tj. rekurencyjny słownik default z poziomu nieskończonego?)

Chcę móc:

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

Więc mogę to zrobić x = defaultdict(defaultdict), ale to tylko drugi poziom:

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

Istnieją przepisy, które mogą to zrobić. Ale czy można to zrobić po prostu używając zwykłych argumentów defaultdict?

Zauważ, że jest to pytanie, jak wykonać rekurencyjny defaultdict na nieskończonym poziomie, więc różni się od Python: defaultdict of defaultdict? , czyli jak zrobić dwupoziomowy defaultdict.

Prawdopodobnie skończę po prostu używając wzoru wiązki , ale kiedy zdałem sobie sprawę, że nie wiem, jak to zrobić, zainteresowało mnie to.

Dla dowolnej liczby poziomów:

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

Oczywiście można to również zrobić z lambdą, ale uważam, że lambdy są mniej czytelne. W każdym razie wyglądałoby to tak:

rec_dd = lambda: defaultdict(rec_dd)

Inne odpowiedzi tutaj mówią ci, jak stworzyć, defaultdictktóry zawiera „nieskończenie wiele” defaultdict, ale nie odpowiadają one temu, co moim zdaniem mogło być twoją początkową potrzebą, która polegała na po prostu posiadaniu domyślnego słowa o dwóch głębokościach.

Być może szukałeś:

defaultdict(lambda: defaultdict(dict))

Powody, dla których możesz preferować tę konstrukcję, to:

• Jest bardziej wyraźne niż rozwiązanie rekurencyjne, a zatem prawdopodobnie bardziej zrozumiałe dla czytelnika.
• Dzięki temu „liść” defaultdictmoże być czymś innym niż słownik, np.: defaultdict(lambda: defaultdict(list))Lubdefaultdict(lambda: defaultdict(set))

Jest na to sprytna sztuczka:

tree = lambda: defaultdict(tree)

Następnie możesz utworzyć swój plik xz x = tree().

Podobne do rozwiązania BrenBarna, ale nie zawiera treedwukrotnie nazwy zmiennej , więc działa nawet po zmianach w słowniku zmiennych:

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

Następnie możesz utworzyć każdy nowy xz x = tree().

W przypadku defwersji możemy użyć zakresu zamknięcia funkcji, aby zabezpieczyć strukturę danych przed błędem, w którym istniejące instancje przestają działać, jeśli treenazwa zostanie ponownie powiązana. To wygląda tak:

from collections import defaultdict

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

Proponowałbym również implementację w stylu OOP, która obsługuje nieskończone zagnieżdżanie, a także odpowiednio sformatowaną repr.

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

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

Stosowanie:

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

tutaj jest rekurencyjna funkcja do konwersji rekurencyjnego domyślnego dyktu na normalny dykt

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

Oparłem to na odpowiedzi Andrew tutaj. Jeśli chcesz załadować dane z json lub istniejącego dyktu do domyślnego narzędzia nester, zobacz ten przykład:

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