Python 中的嵌套字典，隐式创建不存在的中间容器？

Question

我想创建一个多态结构，可以以最少的打字工作量即时创建，并且非常具有可读性。例如：

a.b = 1
a.c.d = 2
a.c.e = 3
a.f.g.a.b.c.d = cucu
a.aaa = bau

我不想创建一个中间容器，例如：

a.c = subobject()
a.c.d = 2
a.c.e = 3

我的问题与此类似：

实现嵌套字典的最佳方法是什么？

但我对那里的解决方案不满意，因为我认为存在一个错误：
即使您不想要，也会创建项目：假设您想比较 2 个多态结构：它将在第二个结构中创建第一个结构中存在的任何属性，并且仅在另一个结构中进行检查。例如：

a = {1:2, 3: 4}
b = {5:6}

# now compare them:

if b[1] == a[1]
    # whoops, we just created b[1] = {} !

我也想获得

a.b.c.d = 1
    # neat
a[b][c][d] = 1
    # yuck

我尝试从对象类派生的最简单的可能符号...但我无法避免留下与上面相同的错误，其中属性仅通过尝试读取它们而诞生：一个简单的目录() 会尝试创建像“方法”这样的属性...就像这个例子一样，这显然已经被破坏了：

class KeyList(object):
    def __setattr__(self, name, value):
        print "__setattr__ Name:", name, "value:", value
        object.__setattr__(self, name, value)
    def __getattribute__(self, name):
        print "__getattribute__ called for:", name
        return object.__getattribute__(self, name)
    def __getattr__(self, name):
        print "__getattr__ Name:", name
        try:
            ret = object.__getattribute__(self, name)
        except AttributeError:
            print "__getattr__ not found, creating..."
            object.__setattr__(self, name, KeyList())
            ret = object.__getattribute__(self, name)
        return ret

>>> cucu = KeyList()
>>> dir(cucu)
__getattribute__ called for: __dict__
__getattribute__ called for: __members__
__getattr__ Name: __members__
__getattr__ not found, creating...
__getattribute__ called for: __methods__
__getattr__ Name: __methods__
__getattr__ not found, creating...
__getattribute__ called for: __class__

谢谢，真的！

ps：到目前为止我找到的最好的解决方案是：

class KeyList(dict):
    def keylset(self, path, value):
        attr = self
        path_elements = path.split('.')
        for i in path_elements[:-1]:
            try:
                attr = attr[i]
            except KeyError:
                attr[i] = KeyList()
                attr = attr[i]
        attr[path_elements[-1]] = value

# test
>>> a = KeyList()
>>> a.keylset("a.b.d.e", "ferfr")
>>> a.keylset("a.b.d", {})
>>> a
{'a': {'b': {'d': {}}}}

# shallow copy
>>> b = copy.copy(a)
>>> b
{'a': {'b': {'d': {}}}}
>>> b.keylset("a.b.d", 3)
>>> b
{'a': {'b': {'d': 3}}}
>>> a
{'a': {'b': {'d': 3}}}

# complete copy
>>> a.keylset("a.b.d", 2)
>>> a
{'a': {'b': {'d': 2}}}
>>> b
{'a': {'b': {'d': 2}}}
>>> b = copy.deepcopy(a)
>>> b.keylset("a.b.d", 4)
>>> b
{'a': {'b': {'d': 4}}}
>>> a
{'a': {'b': {'d': 2}}}

Answer 1

如果您正在寻找的内容不像原始帖子那么动态，但更像是迄今为止最好的解决方案，您可能会看到 Ian Bicking 的 formencode 的 variabledecode 可以满足您的需求。该包本身旨在用于 Web 表单和验证，但其中一些方法似乎非常接近您正在寻找的内容。
如果不出意外，它可以作为您自己的实现的示例。

一个小例子：

>>> from formencode.variabledecode import variable_decode, variable_encode
>>>
>>> d={'a.b.c.d.e': 1}
>>> variable_decode(d)
{'a': {'b': {'c': {'d': {'e': 1}}}}}
>>>
>>> d['a.b.x'] = 3
>>> variable_decode(d)
{'a': {'b': {'c': {'d': {'e': 1}}, 'x': 3}}}
>>>
>>> d2 = variable_decode(d)
>>> variable_encode(d2) == d
True

Answer 2

我认为至少您需要在 __getattr__ 中进行检查，确保请求的属性不以 __ 开头和结尾。与该描述匹配的属性实现已建立的 Python API，因此您不应该实例化这些属性。即便如此，您最终仍然会实现一些 API 属性，例如 next。在这种情况下，如果将对象传递给某个使用鸭子类型来查看它是否是迭代器的函数，最终会抛出异常。

最好创建一个有效属性名称的“白名单”，无论是作为文字集，还是使用简单的公式：例如 name.isalpha() 和 len(name) == 1 会适用于您在示例中使用的单字母属性。为了更实际的实现，您可能需要定义一组适合您的代码正在工作的域的名称。

我想另一种选择是确保您不会动态创建属于该域的任何各种属性名称某些协议的一部分，因为 next 是迭代协议的一部分。 集合中的 ABC 方法module 包含部分列表，但我不知道在哪里可以找到完整的列表。

您还必须跟踪该对象是否创建了任何此类子节点，以便您知道如何与其他此类对象进行比较。

如果您希望进行比较以避免自动生存，则必须实现 __cmp__ 方法，或 丰富的比较方法，在检查被比较对象的__dict__的类中。

我隐隐感觉有一些我没有想到的复杂情况，这并不奇怪，因为这并不是 Python 真正应该工作的方式。仔细思考，考虑一下这种方法所增加的复杂性是否值得它所带来的好处。