python中的__getattr__方法

Question

i meet this code today, and it seems confusing

class ClassOne:
    def __init__(self,some_object):
        self.not_important_attribute=some_object   
class ClassTwo:
    def __init__(self,some_object):
        self.tmp=ClassOne(some_object)
    def __getattr__(self,attr):
        return getattr(self.tmp,attr)
a=ClassTwo('not_important_string')
print(getattr(a,'undefined_attribute',3))

When we use getattr at the last line we trigger the __getattr__ method in the SubClass , then delegate to the getattr(self.tmp,attr) function which will raise an exception if the attribute is undefined and no default value was given. But how the value 3 at the last line still go through all the process, and eventually return to getattr(a,'undefined_attribute',3) function ?. Because we didn't have a slot for the default value when we delegate getattr(self.tmp,attr) , how is that possible ?

Answer 1

In your case

getattr(self.tmp,attr)

raises AttributeError and if getattr has third argument(default value) then it return default value instead of raising AttributeError

Answer 2

Step by step why 3 value is shown:

the super class has has an atribute not_important_attribute and it is set when the constructor is called

class ClassOne:
    def __init__(self,some_object):
        self.not_important_attribute=some_object   

Here, in the ClassTwo contructor, you create an instance of ClassOne and save it into tmp variable. Meaning that when you overrides __getattr__ you will be asking for the value of attribute of ClassOne

print(getattr(a,'not_important_attribute',3))
not_important_string # founds the method
print(getattr(a,'any',3))
3 #doesn't found method, returns default

That is the same of directly do:

b = ClassOne("not_important_string")
print(getattr(b,'not_important_attribute',3))
not_important_string # founds the method
print(getattr(b,'any',3))
3 # doesn't found method, returns default  

Answer 3

When calling getattr(a,'undefined_attribute',3) you are calling the standard python getattr function and pass it a default value. This actually wraps your custom getattr in ClassTwo. We can see that by modifying getattr al little bit.

   def __getattr__(self, attr, *args, **kwargs):
        print(args)  # -> empty
        print(kwargs)  # -> empty
        return getattr(self.tmp, attr)

You can actually go around that wrapping and call getattr from ClassTwo directly, by using print(a.__getattr__('undefined_attribute', 3)) . This method would raise an Exception.

So essentially getattr(a,'undefined_attribute',3) is the standard python method that internally calls the custom getattr from ClassTwo.

Answer 4

class ClassTwo:
...
    def __getattr__(self,attr):
        return getattr(self.tmp,attr)

getattr(a,'undefined_attribute',3) method is a wrapper to call __getattribute__ and if __getattribute__ fails, it will call __getattr__ . It is implemented with handling of exception AttributeError . In your case, getattr(a,'undefined_attribute',3) calls ClassTwo.__getattr__ above.

It seems you think when it reaches return getattr(self.tmp,attr) , it will throw errors or return some kind of errors and break and stop at that point complete. However, in python, program will pass exception up the call stack. Along the upstream of the call stack, if that exception gets handle, it will exit/complete normally. In this case, AttributeError get passed back along the call stack to getattr(a,'undefined_attribute',3) . this getattr has default value for AttributeError so it returns 3 and exits normally.