请教一个关于__getattr__的问题

def Private(*privates):

    def onDecorator(aClass):   

            class onInstance:  

                    def __init__(self, aClass,*args): 

                            print("onInstance init") 

                            self.aClass=aClass 

                            print("onInstance init over") 

                    def __call__(self, *args, **kargs): 

                            print("call")                 

                            self.wrapped = self.aClass(*args, **kargs)    

                    def __getattr__(self, attr):  

                            if attr in privates: 

                                    raise TypeError('private attribute fetch: ' + attr) 

                            else: 

                                    print("getarrt") 

                                    return getattr(self.wrapped, attr) 

            return onInstance   

    return onDecorator

if name == 'main':

    @Private('data', 'size')  

    class Doubler: 

            def __init__(self, label, start): 

                    print("Doubler init") 

                    self.label = label  

                    self.data = start   
     
    X = Doubler('X is', [1, 2, 3]) 

    print("X.label1=",X.label)

上面的程序输出如下：

onInstance init

onInstance init over

getarrt

getarrt #后续跟着无数个 getarrt，出现死循环

但是如果把__call__方法删除，并对__init__方法修改成如下后，就不会出现 print("getarrt")语句的死循环了：

def Private(*privates):

    def onDecorator(aClass):   

            class onInstance:  

                    def __init__(self, *args,**kargs): 

                            print("onInstance init") 

                            self.wrapped=aClass(*args,**kargs) 

                            print("onInstance init over") 

                    def __getattr__(self, attr):  

                            if attr in privates: 

                                    raise TypeError('private attribute fetch: ' + attr) 

                            else: 

                                    print("getarrt") 

                                    return getattr(self.wrapped, attr) 

            return onInstance   

    return onDecorator

if name == 'main':

    @Private('data', 'size')   

    class Doubler: 

            def __init__(self, label, start): 

                    print("Doubler init") 

                    self.label = label  

                    self.data = start   
     
    X = Doubler('X is', [1, 2, 3]) 

    print("X.label1=",X.label)

输出如下：

onInstance init

Doubler init

onInstance init over

getarrt

X.label1= X is

我的问题如下：

1、第一段代码会导致反复打印"getarrt"是 getattr(self.wrapped, attr) 这个语句中的 self.wrapped 导致的对吧，但是 self.wrapped 在__call__方法中是有声明的，虽然__call__方法还未得到执行，这样也会被__getattr__视作未定义的属性而捕获么？

2、第二段代码做了修改后，为何 getattr(self.wrapped, attr)不会导致对__getattr_的递归调用了？

u2386

2017-08-24 00:45:56 +08:00

以下摘自[https://docs.python.org/2/reference/datamodel.html#object.__getattribute__]

object.__getattribute__(self, name)

Called unconditionally to implement attribute accesses for instances of the class. If the class also defines getattr(), the latter will not be called unless getattribute() either calls it explicitly or raises an AttributeError. This method should return the (computed) attribute value or raise an AttributeError exception. In order to avoid infinite recursion in this method, its implementation should always call the base class method with the same name to access any attributes it needs, for example, object.getattribute(self, name).

所以第一个实现，通过__getattr__里查找一个不存在的属性 wrapped，但是在最后又一次使用 self.wrapped，递归就发生了。

第二个实现之所以没有问题，是因为 wrapped 已经存在，并且是 aClass 的实例。

另：推荐 pdb 查问题。

saximi

2017-08-24 01:13:24 +08:00

@u2386
@lrxiao 感谢大家！我终于明白了，我对代码中的错误总结如下：
1、第一段代码，类 onInstance 的__init__方法中，错误地传入了 aClass 参数，这样传入后该参数并不是装饰器 onDecorator 参数中的类 aClass，实际上却会对应到类 Doubler 的第一个位置参数 label。
2、第一段代码，因为程序执行到 X.label 时始终没有触发类 onInstance 的__call__方法，所以在__call__方法中才首次赋值的 self.wrapped 并未出现在 onInstance 的__dict__中，
从而在__getattr__中的 self.wrapped 会导致死循环。我之前一直以为只要在类定义中写出来的变量都会出现在类的__dict__中，原来是要被执行后才会加入__dict__的，受教了！

另外，上面有朋友提到的“在__getattr__中永远不要直接使用 getattr()或者 self.xxx ”，这句话要辩证地看，
一方面使用 getattr 本身并不等于死循环，只要确保方法的参数不会递归调用__getattr__即可；另一方面只要确保 self.xxx 已经被赋值，就会出现在 self.__dict__中，从而就不会递归调用__getattr__了。