为什么有两种魔术方法可以访问Python中的对象属性？

Question

I'm studying Python's object attribute access patterns ( Descriptor HowTo Guide and Data model docs ). The thing I can't clearly understand is why did Guido provide both __getattr__ and __getattribute__ methods for objects? They both do exactly the same thing but are invoked differently.

For me this seems as if a badly designed class could be fixed by even worse design. I mean, if something needs refactoring, it should not be "glued" with magic methods being called with high or higher precedence.

The question is - why are there two similar methods if one would be perfectly enough?

I'm not referring to descriptors, which are something different.

Answer 1

The two methods serve different purposes.

__getattribute__ is called for all attribute access. __getattr__ is only called by __getattribute__ if the latter failed to locate an attribute.

It is far easier to implement a correct __getattr__ method than it is to implement a __getattribute__ replacement. Sure, you can do without __getattr__ in that scenario, but that also would make implementing the common use-case all the harder.

For example, in __getattr__ you can easily access other, existing attributes on self ; if you need self.bar to fulfil a dynamic attribute, then that's easy to do so. In __getattribute__ you cannot access anything on self with normal attribute access, as that is all handled by __getattribute__ methods; you'd end up in an infinite recursion if you tried. Instead, all attribute access within that method has to use super(ClassName, self).__getattribute__(name) calls.

Note that __getattribute__ is always implemented; object.__getattribute__ provides the default implementation. Use __getattribute__ only if you need to intercept the default behaviour; say you need to override existing attributes in special circumstances, or override the normal descriptor behaviour . See Understanding __getattribute__ for an example where existing attribute access is being overridden.

Use __getattr__ for everything else; eg dynamic attributes where those attributes do not already exist on the object. Say, you are providing a proxy class, where most attribute access is passed on to the wrapped object:

class Proxy(object):
    def __init__(self, wrapped):
        self._wrapped = wrapped

    def foo(self):
        return self._wrapped.foo() + 42

    def __getattr__(self, name):
        return getattr(self._wrapped, name)

Here _wrapped and foo are found directly on Proxy() , but if you tried to access bar , an attribute that does not exist on the Proxy class, __getattr__ is called instead which translates that as attribute access on self._wrapped .