python——反射

1、概述

运行时，区别于翻译时，指的是程序被加载到内存中执行的时候。
反射，reflection，指的是运行时获取类型定义信息。
一个对象能够在运行时，像照镜子一样，反射出其类型信息。简单说，在Python中，能够通过一个对象，找出其type、class、attribute或method的能力，称为反射或自省。
具有反射能力的函数有type(),isinstance(),callable().dir().getattr()等

2、反射相关函数的用法

class Point:
    '''反射函数用法举例'''
    name = 'alex'
    def __init__(self, x, y):
        self.x = x
        self.y = y
    def __str__(self):
        return "{} and {}".format(self.x, self.y)
    def show(self):
        print(self.x, self.y)

p = Point(4, 5)
print(p)  # 触发__str__()  输出：4 and 5
print(p.__dict__)   # 不会有类变量和方法存在，只存在私有属性,可以清楚实例的机制  输出：{'x': 4, 'y': 5}
print(Point.__dict__)
# 修改实例的属性
p.__dict__['y'] = 15
print(p.__dict__)  #输出：{'x': 4, 'y': 15}
# 增加实例的属性
p.z = 10
print(p.__dict__)   # 输出：{'x': 4, 'y': 15, 'z': 10}
# 对象可进行的操作
print(dir(p))

 上例通过属性字典__dict__来访问对象的属性，本质上就是利用反射的能力（可以将字典理解为一种反射），但是上面的例子中，访问的方式不优雅，Python提供了内置的函数

 3、反射函数

内建函数	意义
getattr(object,name[,default])	通过name返回object的属性值，当属性不存在，当属性不存在，将使用default返回，如果没有default，则抛出AttributeError,name必须是字符串
setattr(object,name,value)	若存在object.name这是属性，则覆盖，不存在则新增
hasattr(object,name	判断对象是否具有这个名字的属性，返回bool值，name必须为字符串
delattr(object，name)	用于删除对象的属性，相当于del object.name

 

getattr()和hasattr()

（1）动态调用方法和增添方法

def bulk(self):
    print('%s is yelling...' % self.name)
class Dog(object):
    num = 123
    def __init__(self, name):
        self.name = name

    def eat(self, food):
        print('%s is eating %s' % (self.name, food))

obj = Dog('alex')

for i in range(2):
    choice = input('>>>').strip()
    # 动态调用方法
    if hasattr(obj, choice):
        func = getattr(obj, choice)
        func('hotdog')
    # 增添方法
    else:
        setattr(obj, choice, bulk)
        func = getattr(obj, choice)
        func(obj)

执行结果：

>>>eat
alex is eating hotdog
>>>talk
alex is yelling...

（2）动态调用属性和增添属性

for i in range(2):
    choice = input('>>>')
#动态调用属性
    if hasattr(obj, choice):
        argu = getattr(obj, choice)
        print('%s=%s'%(choice,argu))
    else:
        setattr(obj, choice, 5)
        argu_new = getattr(obj, choice)
        print('{}={}'.format(choice, argu_new))

执行结果：

>>>num
num=123
>>>age
age=5

delattr()删除属性或方法

>>> class Myclass:
...     num = 2
...     def __init__(self,name):
...             self.name=name
...     def func(self):
...             print('This is func')
...
>>> obj = Myclass('alex')
>>> obj.num
2
>>> obj.func()
This is func
>>> delattr(obj,'num')   # num是类变量只能通过类去删除，在实例对象中不存在num这一个变量
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: num
>>> obj.num
2
>>> delattr(Myclass,'num')  # 删除属性num
>>> obj.num
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Myclass' object has no attribute 'num'
>>> delattr(Myclass,'func')    # 删除方法
>>> func()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'func' is not defined

4、在类中使用内建反射函数（慎用，和直接外部使用反射函数有所不同）

（1）getattr(object,name[,default])

class Base(object):
    n = 0
class Point(Base):
    z = 6
    def __init__(self, x, y):
        self.x = x
        self.y = y
    def show(self):
        print(self.x, self.y)
    def __getattr__(self, item):
        return item

p = Point(4,5)
print('p.x>>>>', p.x)
print('p.y>>>', p.y)
print('p.n>>>', p.n)
print('p.t>>>', p.t)

执行结果：

p.x>>>> 4
p.y>>> 5
p.n>>> 0
p.t>>> t

实例属性会按照继承关系寻找，如果找不到，就会执行__getattr__()方法，如果没有这个方法，就会抛出AttributeError异常标识找不到属性
查找属性顺序为：
p.__dict__---->继承的祖先类(直到object)的__dict__—>找不到—>调用getattr()

2、setattr(object,name,value)

class Base:
    n = 0
class Point(Base):
    z = 6
    def __init__(self, x, y):
        self.x = x
        self.y = y
    def show(self):
        print(self.x, self.y)
    def __getattr__(self, item):
        return item
    def __setattr__(self, key, value):
        print('in the setattr:
key->{}	value->{},'.format(key,value))

（1）实例化对象：

p1 = Point(4, 5)
print(p1.__dict__)
执行结果
in the setattr:
key->x    value->4,
in the setattr:
key->y    value->5,
{}

注释掉第12、13行代码

p1 = Point(4, 5)
print(p1.__dict__)
执行结果：
{'x': 4, 'y': 5}

结论：我们可以看出，__setattr__()函数会先于__init__()执行，且并不会在实例化对象开辟的内存中保存，而是单独开辟了内存，保存变量初始化的值。其实执行顺序是先执行__setattr__()，再执行__init__()，

只是变量的初始化已经完成了，不会再在实例对象的内存中保存实例变量了。

（2）属性查找顺序

print(p1.x, p1.y)
print(p1.z)
print(p1.n)
执行结果：
x y
6
0

结论：其实我们变量的初始化函数根本就没有生效，在实例对象p1.__dict__什么都没有保存进去，应为setattr（）另外开辟地址进行存储啦。所以找查找属性x,y时，先在实例属性中查找——》在类中查找——》在父类中查找——》找不到，触发__getattr__().

p1.x = 50
print(p1.x)
print(p1.__dict__)
执行结果>>>
key->x    value->50,
x
{}

(3)在设置属性的时候，属性需要加到实例的__dict__中，才会生效。

p1.__dict__['x']=60
print(p1.__dict__)
print(p1.x)
执行结果>>>
{'x': 60}
60

3.__delattr__()

class Point:
    z = 5
    def __init__(self, x, y):
        self.x = x
        self.y = y
    def __delattr__(self,item):
        print(item)
p = Point(14,5)
del p.x
p.z = 15
del p.z
del p.Z
print(Point.__dict__)

执行结果：

x
z
Z
{'__module__': '__main__', 'z': 5, '__init__': <function Point.__init__ at 0x000002049C0A7620>, 

'__delattr__': <function Point.__delattr__ at 0x000002049C0A76A8>, '__dict__': <attribute '__dict__' of 'Point' objects>, 

'__weakref__': <attribute '__weakref__' of 'Point' objects>, '__doc__': None}

结论：其实我们并未删除实例对象中的实例变量，我们最后可以看到p.__dict__的内容{'x': 14, 'y': 5}，这说明del x操作只能触发__delattr_()函数，实际并没有完成相应的功能。

4、getattribute()

class  Base:
    n=0
class Point(Base):
    z=6
    def __init__(self,x,y):
        self.x=x
        self.y=y
    def __getattr__(self,item):
        return item
    def __getattribute__(self,item):
        return item
p1=Point(4,5)
print(p1.__dict__)
print(p1.x)
print(p1.z)
print(p1.n)
print(p1.t)
print(Point.__dict__)
print(Point.z)

执行结果：

__dict__
x
z
n
t
{'__module__': '__main__', 'z': 6, '__init__': <function Point.__init__ at 0x000001F1C07C7620>, 

'__getattr__': <function Point.__getattr__ at 0x000001F1C07C76A8>, '__getattribute__': <function Point.__getattribute__ at 0x000001F1C07C7730>, '__doc__': None}
6

实例的所有的属性访问，第一个都会调用__getattribute__方法，它阻止了属性的查找，该方法应该返回值或者抛出一个AttributeError异常

它的return值将作为属性查找的结果
如果抛出AttributeError异常，则会直接调用__getattr__方法，因为属性没有找到
__getattribute__方法中为了避免在该方法中无线递归，它的实现应该永远调用基类的同名方法以访问需要的任何属性，需要注意的是，除非明确知道__getattrtbute__方法用来做什么，否则不要使用
属性查找顺序：
实例调用__getattribute__()—>instance.dict–>instance.class.dict–>继承的祖先类(直到object)的__dict__–>调用__getattr__()