3

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

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

我确实尝试从对象类派生......但我无法避免留下与上面相同的错误，即仅通过尝试读取属性就诞生了：一个简单的 dir() 会尝试创建像“方法”这样的属性...就像在这个例子中，这显然是坏的：

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}}}
4

2 回答 2

1

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

创建一个有效属性名称的“白名单”确实会更好，可以作为文字集，也可以使用简单的公式：例如name.isalpha() and len(name) == 1，适用于您在示例中使用的单字母属性。对于更现实的实现，您可能希望定义一组适合您的代码所在域的名称。

我想另一种选择是确保您不会像next迭代协议的一部分那样动态创建属于某些协议的各种属性名称中的任何一个。collections模块中 ABC 的方法包括部分列表，但我不知道在哪里可以找到完整的列表。

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

如果您希望比较避免自动激活，则必须在检查被比较对象的 s 的类中实现一个__cmp__方法或丰富的比较方法。__dict__

我有一种偷偷摸摸的感觉，有一些我没有想到的复杂情况，这并不奇怪，因为这并不是 Python 应该如何工作的。仔细考虑，并考虑这种方法增加的复杂性是否值得你得到它。

于 2010-10-18T01:18:47.830 回答
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
于 2010-10-18T18:04:33.023 回答