具有可变深度的多级默认字典？

问题描述：

我有一个很长的清单，例如：

[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][...]。

解决方案 1：

你甚至不需要定义一个类就可以做到这一点：

from collections import defaultdict

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

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

解决方案 2：

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

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其作为嵌套字典结构读取来做类似的事情。

解决方案 3：

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 子类化并覆盖__init__。

解决方案 4：

这相当于上面的代码，但避免使用 lambda 符号。也许更容易阅读？

def dict_factory():
   return defaultdict(dict_factory)

your_dict = dict_factory()

此外 - 从评论中 - 如果您想从现有字典中进行更新，您可以简单地调用

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

为了向字典添加值。

解决方案 5：

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

解决方案 6：

您可以使用递归来实现这一点defaultdict。

from collections import defaultdict

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

在这里，在闭包（“私有”本地函数作用域）中保护默认工厂名称非常重要the_tree。避免使用单行lambda版本，该版本因 Python 的后期绑定闭包而存在错误，而是使用 来实现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

解决方案 7：

添加到@Hugo
以获得最大深度：

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

解决方案 8：

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

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

解决方案 9：

您可以使用NestedDict。

from ndicts.ndicts import NestedDict

nd = NestedDict()
nd[0, 1, 2, 3, 4, 5] = 6

作为字典的结果：

>>> nd.to_dict()
{0: {1: {2: {3: {4: {5: 6}}}}}}

安装ndicts

pip install ndicts