Вложенный defaultdict из defaultdict

Для произвольного количества уровней:

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

Конечно, вы также можете сделать это с помощью лямбды, но я считаю, что лямбды менее читабельны. В любом случае это будет выглядеть так:

rec_dd = lambda: defaultdict(rec_dd)

Другие ответы здесь рассказывают вам, как создать defaultdict, который содержит «бесконечно много» defaultdict, но они не могут удовлетворить то, что, как я думаю, могло быть вашей первоначальной потребностью, а именно просто иметь двухуровневый defaultdict.

Возможно, вы искали:

defaultdict(lambda: defaultdict(dict))

Причины, по которым вы можете предпочесть эту конструкцию:

• Это более явное решение, чем рекурсивное, и поэтому, вероятно, более понятное для читателя.
• Это позволяет «листу» defaultdict быть чем-то отличным от словаря, например: defaultdict(lambda: defaultdict(list)) или defaultdict(lambda: defaultdict(set))

Для этого есть хитрый трюк:

tree = lambda: defaultdict(tree)

Затем вы можете создать свой x с x = tree().

Подобно решению BrenBarn, но не содержит дважды имя переменной tree, поэтому оно работает даже после изменений в словаре переменных:

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

Затем вы можете создавать каждый новый x с x = tree().

Для версии def мы можем использовать область закрытия функции, чтобы защитить структуру данных от недостатка, из-за которого существующие экземпляры перестают работать, если имя tree восстанавливается. Это выглядит так:

from collections import defaultdict

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

Я бы также предложил реализацию в стиле ООП, которая поддерживает бесконечное вложение, а также правильно отформатированное repr.

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

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

Использование:

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

Я основывал это на ответе Эндрю. Если вы хотите загрузить данные из json или существующего словаря в нестерский defaultdict, см. этот пример:

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

вот рекурсивная функция для преобразования рекурсивного словаря по умолчанию в обычный словарь

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

ответ @nucklehead также можно расширить для обработки массивов в 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)

Вот функция для произвольного базового defaultdict для произвольной глубины вложенности.

(перекрестная публикация из Невозможно рассолить defaultdict)

def wrap_defaultdict(instance, times=1):
    """Wrap an instance an arbitrary number of `times` to create nested defaultdict.
    
    Parameters
    ----------
    instance - list, dict, int, collections.Counter
    times - the number of nested keys above `instance`; if `times=3` dd[one][two][three] = instance
    
    Notes
    -----
    using `x.copy` allows pickling (loading to ipyparallel cluster or pkldump)
        - thanks https://stackoverflow.com/questions/16439301/cant-pickle-defaultdict
    """
    from collections import defaultdict

    def _dd(x):
        return defaultdict(x.copy)

    dd = defaultdict(instance)
    for i in range(times-1):
        dd = _dd(dd)

    return dd