Introduction and examples of the built in function getattr of in python

In python's official documentation: getattr() is explained as follows:

getattr(object, name[, default])

Return the value of the named attribute of object. name must be a string. If the string is the name of one of the object's attributes, the result is the value of that attribute. For example, getattr(x, 'foobar') is equivalent to x.foobar. If the named attribute does not exist, default is returned if provided, otherwise AttributeError is raised.

Returns the object value by the property name. If "name" is the name of the property on the object, the value of the corresponding property is returned.

'# -*- coding: utf-8 -*-'

__author__ = 'lucas'

class attrtest(object):

  def __init__(self):
    pass

  def trygetattr0(self):
    self.name = 'lucas'
    print self.name
    #equals to self.name
    print getattr(self,'name')

  def attribute1(self,para1):
    print 'attribute1 called and '+ para1+' is passed in as a parameter'

  def trygetattr(self):
    fun = getattr(self,'attribute1')
    print type(fun)
    fun('crown')

if __name__=='__main__':
  test = attrtest()
  print 'getattr(self,'name') equals to self.name '
  test.trygetattr0()
  print 'attribute1 is indirectly called by fun()'
  test.trygetattr()
  print 'attrribute1 is directly called'
  test.attribute1('tomato')

  The result of this code execution is:

getattr(self,'name') equals to self.name 
lucas
lucas
attribute1 is indirectly called by fun()
<type 'instancemethod'>
attribute1 called and crown is passed in as a parameter
attrribute1 is directly called
attribute1 called and tomato is passed in as a parameter

Process finished with exit code 0

The first function, tryattribute0 (), is easy to understand, just as the definition says. The second function tryattribute1() is a little confusing. Actually the principle is not complicated, we see that the type of fun is instancemethod, here you can think: for the function, the return value of getattr () is a pointer, the pointer is assigned to accept its variable, later call this variable is equal to call the function that the variable points to.

So we know how it works, so what does getattr do?

Are you familiar with reflection in Java or c#? An important function of reflection is lazy loading, which decouples the system and makes it run more efficiently. As a dynamic language, python is clearly more powerful in this respect,

Getattr () is a building block for python reflection, and we can do a lot of interesting things with other methods like setattr(),dir(), etc.

Let's look at the following scenario:

1. I need to dynamically add methods from other classes in one class:

# If a class A There are the following methods: 
def addnewattributesfromotherclass(self,class_name):
    func_names = dir(class_name)
    for func_name in func_names:
      if not func_name.startswith('_'):
        new_func = getattr(class_name,func_name)
        self.__setattr__(func_name,new_func())

All we need is:

a = A()

b = B()

a.addnewattributesfromotherclass(b)

So a can call the 'non-private' method in B.