具有可变深度的多级defaultdict？

我有很多类似的清单：

[A][B1][C1]=1
[A][B1][C2]=2
[A][B2]=3
[D][E][F][G]=4

我想建立一个多层次的字典，像：

A
--B1
-----C1=1
-----C2=1
--B2=3
D
--E
----F
------G=4

我知道，如果我用递归defaultdict我可以写table[A][B1][C1]=1，table[A][B2]=2但如果我硬编码的INSERT语句这只适用。

解析列表时，我不需要事先调用多少[]个table[key1][key2][...]。

您甚至不需要定义类就可以做到：

from collections import defaultdict

nested_dict = lambda: defaultdict(nested_dict)
nest = nested_dict()

nest[0][1][2][3][4][5] = 6

您的示例表明，在任何级别上都可以有一个值，也可以有一个子元素字典。这称为一棵树，并且有许多可用的实现。这是一：

from collections import defaultdict
class Tree(defaultdict):
    def __init__(self, value=None):
        super(Tree, self).__init__(Tree)
        self.value = value

root = Tree()
root.value = 1
root['a']['b'].value = 3
print root.value
print root['a']['b'].value
print root['c']['d']['f'].value

输出：

1
3
None

您可以通过使用JSON编写输入并将json.load其用作嵌套字典的结构来读取内容，从而执行类似的操作。

我会用一个dict定义的子类来做到这一点__missing__：

>>> class NestedDict(dict):
...     def __missing__(self, key):
...             self[key] = NestedDict()
...             return self[key]
...
>>> table = NestedDict()
>>> table['A']['B1']['C1'] = 1
>>> table
{'A': {'B1': {'C1': 1}}}

您无法直接使用defaultdict来执行此操作，因为defaultdict在初始化时需要工厂函数，但是在初始化时，无法描述相同的defaultdict。上面的构造与默认dict的作用相同，但是由于它是一个命名类（NestedDict），当遇到缺少的键时，它可以引用自身。也可以继承defaultdict和override __init__。

我认为递归字典的最简单实现就是这样。只有叶节点可以包含值。

# Define recursive dictionary
from collections import defaultdict
tree = lambda: defaultdict(tree)

用法：

# Create instance
mydict = tree()

mydict['a'] = 1
mydict['b']['a'] = 2
mydict['c']
mydict['d']['a']['b'] = 0

# Print
import prettyprint
prettyprint.pp(mydict)

输出：

{
  "a": 1, 
  "b": {
    "a": 1
  }, 
  "c": {},
  "d": {
    "a": {
      "b": 0
    }
  }
}

这与上述等效，但避免使用lambda表示法。也许更容易阅读？

def dict_factory():
   return defaultdict(dict_factory)

your_dict = dict_factory()

另外-从评论中-如果您想从现有字典更新，则只需调用

your_dict[0][1][2].update({"some_key":"some_value"})

为了给dict添加值。

Dan O'Huiginn在2010年的日记中发布了一个非常不错的解决方案：

http://ohuiginn.net/mt/2010/07/nested_dictionaries_in_python.html

>>> class NestedDict(dict):
...     def __getitem__(self, key):
...         if key in self: return self.get(key)
...         return self.setdefault(key, NestedDict())


>>> eggs = NestedDict()
>>> eggs[1][2][3][4][5]
{}
>>> eggs
{1: {2: {3: {4: {5: {}}}}}}

允许常规字典初始化的可能性稍有不同：

from collections import defaultdict

def superdict(arg=()):
    update = lambda obj, arg: obj.update(arg) or obj
    return update(defaultdict(superdict), arg)

例：

>>> d = {"a":1}
>>> sd = superdict(d)
>>> sd["b"]["c"] = 2

添加到@Hugo
的最大深度：

l=lambda x:defaultdict(lambda:l(x-1)) if x>0 else defaultdict(dict)
arr = l(2)

您可以通过递归实现defaultdict。

from collections import defaultdict

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

重要的是，the_tree在此处保护闭包（“私有”本地功能范围）中的默认工厂名称。避免使用单行lambda版本，该版本由于Python的后期绑定关闭而存在bug而，请使用def改用来实现。

使用lambda接受的答案存在一个缺陷，即实例必须依赖nested_dict外部作用域中存在的名称。如果由于某种原因无法解析工厂名称（例如，工厂名称被反弹或删除），则先前存在的实例也将被巧妙地破坏：

>>> nested_dict = lambda: defaultdict(nested_dict)
>>> nest = nested_dict()
>>> nest[0][1][2][3][4][6] = 7
>>> del nested_dict
>>> nest[8][9] = 10
# NameError: name 'nested_dict' is not defined