如何实现 __getattribute__ 而不出现无限递归错误？

Question

我想重写对类中一个变量的访问，但正常返回所有其他变量。 如何使用 __getattribute__ 来实现此目的？

我尝试了以下操作（这也应该说明我正在尝试做什么），但出现递归错误：

class D(object):
    def __init__(self):
        self.test=20
        self.test2=21
    def __getattribute__(self,name):
        if name=='test':
            return 0.
        else:
            return self.__dict__[name]

>>> print D().test
0.0
>>> print D().test2
...
RuntimeError: maximum recursion depth exceeded in cmp

Answer 1

您会收到递归错误，因为您尝试访问 __getattribute__ 内的 self.__dict__ 属性会再次调用 __getattribute__。 如果您使用 object 的 __getattribute__ 来代替，它会起作用：

class D(object):
    def __init__(self):
        self.test=20
        self.test2=21
    def __getattribute__(self,name):
        if name=='test':
            return 0.
        else:
            return object.__getattribute__(self, name)

这是有效的，因为 object （在本例中）是基类。 通过调用 __getattribute__ 的基本版本，您可以避免之前陷入的递归地狱。

foo.py 中代码的 Ipython 输出：

In [1]: from foo import *

In [2]: d = D()

In [3]: d.test
Out[3]: 0.0

In [4]: d.test2
Out[4]: 21

更新：

标题为 当前文档中对新样式类的更多属性访问，他们建议这样做以避免无限递归。

Answer 2

实际上，我相信您想使用 __getattr__ 改为特殊方法。

引用Python文档：

__getattr__(自身，名称)

当属性查找在通常的位置没有找到属性时调用（即它不是实例属性，也没有在 self 的类树中找到）。 name 是属性名称。 此方法应返回（计算出的）属性值或引发 AttributeError 异常。
请注意，如果通过正常机制找到该属性，则不会调用 __getattr__()。 （这是 __getattr__() 和 __setattr__() 之间故意不对称的。）这样做既是出于效率原因，也是因为 __setattr__()将无法访问实例的其他属性。 请注意，至少对于实例变量，您可以通过不在实例属性字典中插入任何值（而是将它们插入另一个对象中）来伪造完全控制。 请参阅下面的 __getattribute__() 方法，了解在新型类中实际获得完全控制的方法。

注意：要使其正常工作，实例不应具有 test 属性，因此应删除 self.test=20 行。

Answer 3

Python 语言参考：

为了避免无限递归
在这个方法中，它的实现
应该总是调用基类
访问同名方法
它需要的任何属性，例如，
object.__getattribute__(self, name).

含义：

def __getattribute__(self,name):
    ...
        return self.__dict__[name]

您正在调用一个名为 __dict__ 的属性。 因为它是一个属性，所以在搜索 __dict__ 时调用 __getattribute__ ，它调用 __getattribute__ ，它调用 ... yada yada yada

return  object.__getattribute__(self, name)

使用基类 __getattribute__ 有助于找到真实的属性。

Answer 4

如何使用__getattribute__方法？

它在正常的点查找之前调用。 如果它引发AttributeError，那么我们调用__getattr__。

这种方法的使用相当罕见。 标准库中只有两个定义：

$ grep -Erl  "def __getattribute__\(self" cpython/Lib | grep -v "/test/"
cpython/Lib/_threading_local.py
cpython/Lib/importlib/util.py

最佳实践

以编程方式控制对单个属性的访问的正确方法是使用 属性。 类 D 应该写成如下（可以使用设置器和删除器来复制明显的预期行为）：

class D(object):
    def __init__(self):
        self.test2=21

    @property
    def test(self):
        return 0.

    @test.setter
    def test(self, value):
        '''dummy function to avoid AttributeError on setting property'''

    @test.deleter
    def test(self):
        '''dummy function to avoid AttributeError on deleting property'''

用法：

>>> o = D()
>>> o.test
0.0
>>> o.test = 'foo'
>>> o.test
0.0
>>> del o.test
>>> o.test
0.0

属性是一个数据描述符，因此它是在正常的点线中查找的第一个东西查找算法。

__getattribute__ 的选项

如果您确实需要通过 __getattribute__。

• 引发AttributeError，导致__getattr__被调用（如果实现）
• 通过以下方式从中返回一些内容
  • 使用 super 调用父级 (可能是对象的）实现
  • 调用__getattr__
  • 以某种方式实现您自己的点式查找算法

例如：

class NoisyAttributes(object):
    def __init__(self):
        self.test=20
        self.test2=21
    def __getattribute__(self, name):
        print('getting: ' + name)
        try:
            return super(NoisyAttributes, self).__getattribute__(name)
        except AttributeError:
            print('oh no, AttributeError caught and reraising')
            raise
    def __getattr__(self, name):
        """Called if __getattribute__ raises AttributeError"""
        return 'close but no ' + name    


>>> n = NoisyAttributes()
>>> nfoo = n.foo
getting: foo
oh no, AttributeError caught and reraising
>>> nfoo
'close but no foo'
>>> n.test
getting: test
20

您最初想要的。

这个例子展示了您如何做您最初想要的事情：

class D(object):
    def __init__(self):
        self.test=20
        self.test2=21
    def __getattribute__(self,name):
        if name=='test':
            return 0.
        else:
            return super(D, self).__getattribute__(name)

并且将表现得像这样：

>>> o = D()
>>> o.test = 'foo'
>>> o.test
0.0
>>> del o.test
>>> o.test
0.0
>>> del o.test

Traceback (most recent call last):
  File "<pyshell#216>", line 1, in <module>
    del o.test
AttributeError: test

代码审查

您的带有注释的代码。 您在 __getattribute__ 中对 self 进行了点式查找。
这就是您收到递归错误的原因。 您可以检查 name 是否为 "__dict__" 并使用 super 来解决方法，但这不包括 __slots__。 我将把它作为练习留给读者。

class D(object):
    def __init__(self):
        self.test=20
        self.test2=21
    def __getattribute__(self,name):
        if name=='test':
            return 0.
        else:      #   v--- Dotted lookup on self in __getattribute__
            return self.__dict__[name]

>>> print D().test
0.0
>>> print D().test2
...
RuntimeError: maximum recursion depth exceeded in cmp

Answer 5

您确定要使用__getattribute__吗？ 你到底想达到什么目的？

执行您要求的最简单方法是：

class D(object):
    def __init__(self):
        self.test = 20
        self.test2 = 21

    test = 0

或：

class D(object):
    def __init__(self):
        self.test = 20
        self.test2 = 21

    @property
    def test(self):
        return 0

编辑：
请注意，D 的实例在每种情况下都会具有不同的 test 值。 在第一种情况下，d.test 将为 20，在第二种情况下，它将为 0。我将让您找出原因。

编辑2：
Greg 指出示例 2 将失败，因为该属性是只读的，并且 __init__ 方法尝试将其设置为 20。更完整的示例是：

class D(object):
    def __init__(self):
        self.test = 20
        self.test2 = 21

    _test = 0

    def get_test(self):
        return self._test

    def set_test(self, value):
        self._test = value

    test = property(get_test, set_test)

显然，作为一个类，这几乎完全是无用，但它给了你一个继续前进的想法。

Answer 6

这是一个更可靠的版本：

class D(object):
    def __init__(self):
        self.test = 20
        self.test2 = 21
    def __getattribute__(self, name):
        if name == 'test':
            return 0.
        else:
            return super(D, self).__getattribute__(name)

它从父类调用 __getattribute__ 方法，最终返回到对象。__getattribute__ 方法（如果其他祖先没有覆盖它）。