What is the relationship between __getattr__ and getattr?

Question

I know this code is right:

class A:        def __init__(self):         self.a = 'a'       def method(self):            print "method print"    a = A()    print getattr(a, 'a', 'default')    print getattr(a, 'b', 'default')   print getattr(a, 'method', 'default')  getattr(a, 'method', 'default')()    

And this is wrong:

# will __getattr__ affect the getattr?  class a(object):     def __getattr__(self,name):         return 'xxx'  print getattr(a) 

This is also wrong:

a={'aa':'aaaa'} print getattr(a,'aa') 

Where should we use __getattr__ and getattr?

Answer 1

Alex's answer was good, but providing you with a sample code since you asked for it :)

class foo:     def __init__(self):         self.a = "a"     def __getattr__(self, attribute):         return "You asked for %s, but I'm giving you default" % attribute   >>> bar = foo() >>> bar.a 'a' >>> bar.b "You asked for b, but I'm giving you default" >>> getattr(bar, "a") 'a' >>> getattr(bar, "b") "You asked for b, but I'm giving you default" 

So in short answer is

You use

__getattr__ to define how to handle attributes that are not found

and

getattr to get the attributes

Answer 2

getattr is a built-in function taking (at least) two arguments: the object from which you're getting the attribute, and the string name of the attribute.

If the string name is a constant, say 'foo', getattr(obj, 'foo') is exactly the same thing as obj.foo.

So, the main use case for the built-in function getattr is when you don't have the attribute name as a constant, but rather as a variable. A second important use case is when you pass it three arguments, rather than just two: in that case, if the attribute is absent from the object, getattr returns the third, "default", argument, rather than raising an exception.

__getattr__ is a special method, defined in a class, that gets invoked when some attribute of an instance of that class is requested, and other normal ways to supply that attribute (via the instance's __dict__, slots, properties, and so on) all failed. You can define it, for example, when you want to delegate otherwise-undefined attribute lookups to other objects.

So your second example is wrong because the builtin getattr can never be called with a single argument.

The third one fails because the dictionary you're trying to "get an attribute" from does not have that attribute -- it has items, which are totally disjoint from attributes of course.