浅谈Python中的反射

反射

reflection，指运行时获取类型定义的信息。

一个对象能够在运行时，如同照镜子一样，反射出其类型信息。简单而言，在Python中，能够通过一个对象，找出其type、class、attribute或者method的能力，称为反射或者自省。

Python的反射能力，主要体现在对象的属性上。

---

请看以下例子： 有一个Point类，并提供了一个方法去查看实例属性。

class Point:
    def __init__(self,x,y):
        self.x = x
        self.y = y

    def __str__(self):
        return "Point({},{})".format(self.x,self.y)

    def show(self):
        print(self.x,self.y)

p = Point(3,8)
p.show() # 3 8
print(p.__dict__) # {'x': 3, 'y': 8}

# 直接修改属性,并添加属性
p.__dict__['y'] = 10
p.z = 100
print(p.__dict__) # {'x': 3, 'y': 10, 'z': 100}

上述的例子，是对象在运行时获取了它的属性，并且修改属性和添加了属性。本质上，这利用了Python的反射的能力。

但是，上例的访问方式并不优雅，Python提供了内置的函数。

反射相关的内建函数

于是，上例的访问变成了这样：

class Point:
    def __init__(self,x,y):
        self.x = x
        self.y = y

    def __str__(self):
        return "Point({},{})".format(self.x,self.y)

    def show(self):
        print(self.x,self.y)

p1 = Point(3,8)
p2 = Point(4,9)

print(getattr(p1,'x')) # 3
print(getattr(p2,'y')) # 9
print(getattr(p1,'__dict__')) # {'x': 3, 'y': 8}

这里，我们可以理解为，通过访问字符串的方式，访问到了字符串的变量值(而一般情况下，访问字符串，就返回字符串本身)。

这就是反射最明显的特征。

# 接上例
if hasattr(p1,'show'):
    getattr(p1,'show')() # 3 8

有时，我们并不清楚一个对象是否支持show方法，此时可以利用反射，在对象运行期间反射出其是否具有show方法，如果有则调用之。

有时，我们并非代码的开发者，而是使用者。此时我们如果想了解某个对象的属性，就需要用如镜子一样的能力把对象的能力反射出来。

这就是反射的含义。

当然，如果某个类的属性不存在，我们能动态添加之。

# 接上例
if not hasattr(Point,'add'):
    setattr(Point,'add',lambda self,other:Point(self.x + other.x,self.y + other.y))

p3 = Point(1,2)
p4 = Point(3,4)
print(p3.add(p4)) # Point(4,6)

也就是说，反射时看到的属性，你也能修改之或者添加之！

这种动态增删属性的方式是运行时改变类或者改变实例的方式。但是装饰器或者Mixin都是定义时就决定了，因此反射能力具有更大的灵活性。

例子：利用反射，实现命令分发器

class Dispatcher():
    def __init__(self):
        self._run()

    def cmd1(self):
        print('I am cmd1')

    def cmd2(self):
        print('I am cmd2')

    def _run(self):
        while True:
            cmd = input('input CMD:')
            if cmd == 'quit':
                break
            ret = getattr(self,cmd,lambda :print('unknow command {}'.format(cmd)))
            ret()


Dispatcher()

反射相关的魔术方法

__getattr__

我们已经知道，可以通过getattr(object,name[,default]) 这种方式去获取一个对象的属性。如果该对象的属性没有定义，则会抛出异常。

是否有一种方法，当属性不存在时，可以避免异常的发生？

先看一个例子：

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 'missing {}'.format(item)

p1 = Point(4,5)
print(p1.x) # 4
print(p1.z) # 6
print(p1.n) # 0
print(p1.t) # missing t

一个对象属性会按照继承关系往上寻找，如果找不到，则执行__getattr__方法。如果此方法无定义，则抛出AttributeError异常表示找不到属性。

总结：

instance.__dict__ --> 
instance.__class__.__dict__ --> 
继承的祖先类(直到object).__dict__ --> 
找不到 --> 
调用__getattr__

__setattr__

先看一个例子：

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 'missing {}'.format(item)

    def __setattr__(self,key,value):
        print("setattr {}={}".format(key,value))


p1 = Point(4,5)
print(p1.x)
# 输出：
# setattr x=4
# setattr y=5
# missing x 

为什么输出这样的信息？

当实例通过.点号设置属性时，比如self.x = 4，就会调用__setattr__函数。此时阻止了属性x添加到实例字典的流程，相当于x并没有添加到实例字典中。因此，当访问x属性时，就会提示missing x。

如果需要添加到实例字典中，则需要显式完成：

def __setattr__(self,key,value):
	print("setattr {}={}".format(key,value))
	self.__dict__[key] = value

此方法，可以拦截对实例属性的增加、修改操作。如果要设置属性字典生效，则需要自己手动操作实例的属性字典。

理解下面的访问方式：

print(p1.z) # 6
print(p1.n) # 0
print(p1.t) # missing t
p1.x = 50 # setattr x=50，调用了__setattr__
print(p1.__dict__) # {}  因为阻止了实例字典的添加
p1.__dict__['x'] = 60  # 显式添加
print(p1.__dict__) # {'x': 60}
print(p1.x) # 60

__delattr__

上面讲述了添加，修改对象属性时，具体发生了什么事情。那删除属性时，又会发生什么事情呢？

class Point:
    Z = 5
    def __init__(self,x,y):
        self.x = x
        self.y = y

    def __delattr__(self,item):
        print('Can not del {}'.format(item))


p = Point(14,5)
del p.x #  Can not del x 

p.z = 15
del p.z # Can not del z
print(p.__dict__) # {'x': 14, 'y': 5, 'z': 15}

del Point.Z # 无输出，已经删除了z属性了吗？
print(Point.__dict__) # 类属性字典 已经删除Point的z属性
print(p.__dict__) # {'x': 14, 'y': 5, 'z': 15} 实例属性字典依然保留z属性

__delattr__魔术方法可以阻止通过实例删除属性的操作，但是依然可通过类删除类属性。

---

__getattribute__

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 'missing {}'.format(item)

    def __getattribute__(self, item):
        return item

p1 = Point(4,5)
print(p1.__dict__)  # 竟然输出了__dict__？实例的属性字典哪儿去了？
print(p1.x) # x  访问x属性，竟然返回了x字符串?
print(p1.z) # z
print(p1.n) # n
print(p1.t) # t
print(Point.z) # 6，能输出类的属性字典的值

对实例的所有属性访问，第一个都会调用此方法。

它阻止了属性的查找，该方法应该返回(计算后的)值或者抛出一个AttributeError异常。

它的return值可作为属性查找的结果，如果抛出AttributeError异常，则会直接调用__getattr__方法，因为属性没有找到。

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 'missing {}'.format(item)

    def __getattribute__(self, item):
        return object.__getattribute__(self,item) ## object为基类


p1 = Point(4,5)
print(p1.__dict__) # {'x': 4, 'y': 5} 此时终于表现得符合预期了
print(p1.x) # 4
print(p1.z) # 6
print(p1.n) # 0
print(p1.t) # missing t
print(Point.z) # 6

__getattribute__方法中为了避免在该方法中无限递归，它的实现应该永远调用基类的同名方法以访问需要的任何属性。

注意：除非你明确知道此方法的后果，否则不要使用它。

此时，可以总结访问一个对象的属性时，其查找顺序：

实例调用__getattribute__ --> 
instance.__dict__ --> 
instance.__class__.__dict__ --> 
继承的祖先类(直到object).__dict__ --> 
找不到 --> 
调用__getattr__

转载：https://blog.csdn.net/qchl2015/article/details/105394711