Zagnieżdżony defaultdict of defaultdict

Inne odpowiedzi mówią ci, jak stworzyć defaultdict, która zawiera "nieskończenie wiele" defaultdict, ale nie rozwiązują tego, co myślę, że mogło być twoją początkową potrzebą, którą było po prostu posiadanie dwu-głębokiego domyślnego dict.

Być może szukałeś:

defaultdict(lambda: defaultdict(dict))

Powody, dla których możesz preferować ten konstrukt to:

• jest bardziej jednoznaczne niż rozwiązanie rekurencyjne, a zatem prawdopodobnie bardziej zrozumiałe dla czytelnika.
• umożliwia to "liść" defaultdict być czymś innym niż słownik, np.: defaultdict(lambda: defaultdict(list)) lub defaultdict(lambda: defaultdict(set))

Istnieje sprytny trik, aby to zrobić:

tree = lambda: defaultdict(tree)

Następnie możesz utworzyć x za pomocą x = tree().

Podobne do rozwiązania Brenbarna, ale nie zawiera dwukrotnie nazwy zmiennej tree, 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 x za pomocą x = tree().

Dla wersji def, możemy użyć funkcji closure scope, aby chronić strukturę danych przed wadą, w której istniejące instancje przestają działać, jeśli nazwa tree jest rebound. Wygląda to 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 zarówno nieskończone zagnieżdżanie, jak i odpowiednio sformatowane repr.

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

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

Użycie:

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

Oparłem tę odpowiedź Andrew tutaj. Jeśli chcesz załadować dane z json lub istniejącego dict do domyślnego pakietu 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

Oto funkcja rekurencyjna do konwersji rekurencyjnego domyślnego dict na normalny dict

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

Odpowiedź

@nucklehead może być rozszerzona również o obsługę tablic w JSON:

def nested_dict(existing=None, **kwargs):
    if existing is None:
        existing = defaultdict()
    if isinstance(existing, list):
        existing = [nested_dict(val) for val in existing]
    if not isinstance(existing, dict):
        return existing
    existing = {key: nested_dict(val) for key, val in existing.items()}
    return defaultdict(nested_dict, existing, **kwargs)