为什么 Python 没有混合 getattr + __getitem__ 内置？

Question

我有接受字典或其他对象以及从这些对象中获取的“字段”名称的方法。如果对象是字典，则该方法使用 __getitem__ 来检索命名键，否则使用 getattr 来检索命名属性。这在网络模板语言中很常见。例如，在 Chameleon 模板中，您可能有：

<p tal:content="foo.keyname">Stuff goes here</p>

如果您将 foo 作为字典传入就像 {'keyname':'bar'} 一样，然后 foo.keyname 获取 'keyname' 键来获取 'bar'。如果 foo 是如下类的实例：

class Foo(object):
    keyname = 'baz'

则 foo.keyname 从 keyname 属性中获取值。 Chameleon 本身实现了该函数（在 chameleon.py26 模块中），如下所示：

def lookup_attr(obj, key):
    try:
        return getattr(obj, key)
    except AttributeError as exc:
        try:
            get = obj.__getitem__
        except AttributeError:
            raise exc
        try:
            return get(key)
        except KeyError:
            raise exc

我已在 我自己的包就像：

try:
    value = obj[attribute]
except (KeyError, TypeError):
    value = getattr(obj, attribute)

事实是，这是一个非常常见的模式。我在很多模块中都看到过这种方法或与其非常相似的方法。那么，为什么语言的核心或至少核心模块之一没有类似的东西呢？如果做不到这一点，是否有一个明确的方法应该如何编写？

Answer 1

我读了一半你的问题，写了下面的内容，然后重读你的问题，意识到我回答了一个略有不同的问题。但我想，经过一番整理，下面的内容实际上仍然提供了答案。如果您不这么认为，请假装您问了这个更一般的问题，我认为该问题包括您的子问题：

“为什么 Python 不提供任何内置方法来将属性和物品视为可互换的吗？”

---

我对这个问题进行了相当多的思考，我认为答案很简单。创建容器类型时，区分属性和项目非常重要。任何相当完善的容器类型都将具有许多属性（通常但不总是方法），使其能够以优雅的方式管理其内容。例如，字典有 items、values、keys、iterkeys 等。这些属性均使用 . 表示法进行访问。另一方面，项目是使用 [] 表示法访问的。所以不可能有碰撞。

当您使用 . 表示法启用项目访问时会发生什么？突然之间，你就有了重叠的命名空间。现在如何处理碰撞？如果您对字典进行子类化并赋予它此功能，那么您通常不能使用像 items 这样的键，或者您必须创建某种名称空间层次结构。第一个选项创建了一个繁琐、难以遵循且难以执行的规则。第二个选项会产生令人烦恼的复杂性，但无法完全解决冲突问题，因为您仍然需要有一个替代接口来指定您是想要 items 项目还是 items属性。

现在，对于某些非常原始的类型，这是可以接受的。例如，这可能就是标准库中存在 namedtuple 的原因。 （但请注意，namedtuple 也存在这些问题，这可能就是为什么它被实现为工厂函数（防止继承）并使用奇怪的私有方法名称，如 _asdict .)

创建没有（公共）属性的 object 子类并在其上使用 setattr 也非常非常容易。重写 __getitem__、__setitem__ 和 __delitem__ 来调用 __getattribute__、__setattr__ 甚至非常容易code> 和 __delattr__，这样项目访问就变成了 getattr()、setattr() 的语法糖， （尽管这有点可疑，因为它会产生一些意想不到的行为。）

但是对于您希望能够扩展和继承的任何类型的开发良好的容器类，添加新的、有用的属性，__getattr__坦率地说，+ __getitem__ 混合体将是一个巨大的 PITA。

Answer 2

python标准库中最接近的东西是namedtuple()，http:// /docs.python.org/dev/library/collections.html#collections.namedtuple

Foo = namedtuple('Foo', ['key', 'attribute'])
foo = Foo(5, attribute=13)
print foo[1]
print foo.key

或者您可以轻松定义自己的类型，该类型始终实际存储到其字典中，但允许出现属性设置和获取：

class MyDict(dict):
    def __getattr__(self, attr):
        return self[attr]
    def __setattr__(self, attr, value):
        self[attr] = value

d = MyDict()

d.a = 3
d[3] = 'a'
print(d['a']) # 3
print(d[3]) # 'a'
print(d['b']) # Returns a keyerror

但是不要'要做d.3 因为这是一个语法错误。当然，还有更复杂的方法可以制作这样的混合存储类型，请在网上搜索许多示例。

至于如何检查两者，变色龙方式看起来很彻底。当谈到“为什么没有一种方法可以在标准库中同时完成这两项工作”时，这是因为歧义是不好的。是的，我们在 python 中有鸭子打字和所有其他类型的伪装，无论如何，类实际上只是字典，但在某些时候，我们希望从像字典或列表这样的容器中获得与我们想要从类中获得的功能不同的功能，其方法解析顺序、覆盖等

Answer 3

您可以非常轻松地编写自己的 dict 子类，该子类本身就以这种方式运行。一个最小的实现，我喜欢称之为属性“堆”，是这样的：

class Pile(dict):
    # raise AttributeError for missing key here to fulfill API
    def __getattr__(self, key):
        if key in self:
            return self[key]
        else:
            raise AttributeError(key)
    def __setattr__(self, key, value):
        self[key] = value

不幸的是，如果您需要能够处理传递给您的字典或包含属性的对象，而不是从开始，这没有帮助。

在你的情况下，我可能会使用与你所拥有的非常相似的东西，除了将其分解为一个函数，这样我就不必一直重复它。