我有一个大列表，例如：
[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，但这只有在我对这些插入语句进行硬编码时才有效。
在解析列表时，我不知道需要多少个 [] 才能调用 table[key1][key2][...]。
【问题讨论】：
标签： python dictionary
你甚至可以在不定义类的情况下做到这一点：
from collections import defaultdict
nested_dict = lambda: defaultdict(nested_dict)
nest = nested_dict()
nest[0][1][2][3][4][5] = 6
【讨论】：
table[0][1][2][3][4][5] += 1
您的示例表明，在任何级别都可以有一个值，也可以是一个子元素字典。这称为树，并且有许多可用的实现。这是一个：
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 将其作为嵌套字典结构读取来执行类似的操作。
【讨论】：
value 构造是不必要的，至少就提议的问题而言。只需删除对value 的引用并将值直接分配给字典键。
value arg/属性并不是真正需要的。
value 实例变量是必要的，否则当您直接分配给节点时，您会丢失子节点（请参阅我对 Jason 优雅解决方案的评论）。干预__setitem__ 将提供更强大的解决方案，但对于简单的需求来说，这将是一个过于复杂的解决方案。
list 而不是int/float 的其他答案。这个答案很清楚，self.value = [] 正是我想要的！
我认为递归字典的最简单实现是这样的。只有叶节点可以包含值。
# 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
}
}
}
【讨论】：
我会使用定义__missing__ 的dict 的子类：
>>> 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 expects the factory function在初始化时，但是在初始化时，没有办法描述同一个defaultdict。上面的构造与默认 dict 所做的事情相同，但由于它是一个命名类（NestedDict），它可以在遇到缺失键时引用自己。也可以继承 defaultdict 并覆盖__init__。
【讨论】：
table['A']['B1']['C1']['D2'] = 2，你会得到一个错误。节点必须能够保存一个值和子节点。
value 属性是不必要的。
defaultdict？
这相当于上面的，但避免使用 lambda 表示法。也许更容易阅读？
def dict_factory():
return defaultdict(dict_factory)
your_dict = dict_factory()
另外——来自 cmets——如果你想从现有的字典中更新，你可以简单地调用
your_dict[0][1][2].update({"some_key":"some_value"})
为了给字典添加值。
【讨论】：
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: {}}}}}}
【讨论】：
KeyError，使用dict() 很容易转换回标准字典。
return self.setdefault(key, NestedDict()) 就足够了。不需要 if。
您可以通过递归defaultdict 来实现这一点。
from collections import defaultdict
def tree():
def the_tree():
return defaultdict(the_tree)
return the_tree()
在闭包（“私有”本地函数范围）中保护默认工厂名称 the_tree 很重要。避免使用由于 Python 的 late binding closures 而存在错误的单行 lambda 版本，而是使用 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
【讨论】：
添加到@Hugo
拥有最大深度：
l=lambda x:defaultdict(lambda:l(x-1)) if x>0 else defaultdict(dict)
arr = l(2)
【讨论】：
允许常规字典初始化的稍微不同的可能性：
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
【讨论】：