Python中类的魔术方法之--反射

本是古典何须时尚 2022-01-26 05:49 245阅读 0赞

### 文章目录 ###

*  Python中类的魔术方法之--反射
 *   *  概述
     *  与反射相关的内建函数
     *  反射相关的魔术方法
     *   *  \`\_\_getattr\_\_(self,item)\`方法
         *  \`\_\_setattr\_\_(self,item)\`方法
         *  \`\_\_delattr\_\_(self,item)\`方法
         *  \`\_\_getattribute\_\_(self,item)\`方法
     *  附加：访问流程图

# Python中类的魔术方法之–反射 #

## 概述 ##

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

示例：为类动态添加属性：

class Point:
        def __init__(self,x,y):
            self.x = x
            self.y = y
    
        def __str__(self):
            return "Point({},{})".format(self.x,self.y)
    
        __repr__ = __str__
    
        def show(self):
            print(self.x,self.y)
    
    p = Point(4,5)
    print(p)
    print(p.__dict__)
    p.__dict__["y"] = 16  #为对象动态修改属性值
    print(p.__dict__)
    p.__dict__["a"] = 10  #为对象动态添加属性值
    print(p.__dict__)
    p.z = 10  #为对象动态增加属性
    print(p.__dict__)
    print("dir查看p的属性",dir(p))
    print("******************************")
    print(dir(Point))
    # Point.__dict__["h"] = 100 #报错出现TypeError异常。type(Point.__dict__) = mappingproxy
    setattr(Point,"h",100) #动态为类对象添加属性
    Point.hh = 100  #动态为类对象添加属性
    print(dir(Point))
    print("dir查看p的属性",dir(p))
    print(type(Point.__dict__))

![class6\_001][class6_001]  
上例通过属性字典\_\_dict\_\_来访问对象的属性，本质上也是利用的反射的能力。  
但是，上面的例子中，访问的方式不优雅，Python提供了内置的函数。

## 与反射相关的内建函数 ##

<table> 
 <thead> 
  <tr> 
   <th align="left">内建函数</th> 
   <th align="left">意义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">getattr(object,name[,default])</td> 
   <td align="left">通过name返回object的属性值。当属性不存在，将使用default返回，如果没有default，则会抛出AttributeError异常。name必须为字符串</td> 
  </tr> 
  <tr> 
   <td align="left">setattr(object,name,value)</td> 
   <td align="left">object的属性存在，则覆盖，不存在，新增</td> 
  </tr> 
  <tr> 
   <td align="left">hasattr(object,name)</td> 
   <td align="left">判断对象是否有这个名字的属性，name必须为字符串</td> 
  </tr> 
 </tbody> 
</table>

*  简单演示：

class Point:
        def __init__(self,x,y):
            self.x = x
            self.y = y
    
        def __str__(self):
            return "Point({},{})".format(self.x,self.y)
    
        __repr__ = __str__
    
        def show(self):
            print("show 方法打印【{},{}】".format(self.x,self.y))
    
    p1 = Point(4,5)
    p2 = Point(5,6)
    print(p1,p2,sep="\t")
    print(p1.__dict__)
    #添加属性
    setattr(p1,"z",10)
    setattr(p2,"z",20)
    print(getattr(p1,"__dict__"),p2.__dict__)
    
    # 动态调用方法
    if hasattr(p1,"show"):
        getattr(p1,"show")()
    
    #动态为类增加方法
    if not hasattr(Point,"__add__"):
        setattr(Point,"__add__",lambda self,other: Point(self.x + other.x,self.y + other.y))
    
    p3 = p1 + p2  #等价于 p3 = p1.__add__(p2) 绑定
    print(p3.__add__) #b绑定
    print(p3)
    
    #动态为实例增加方法 未绑定
    if not hasattr(p1,"__sub__"):
        setattr(p1,"__sub__",lambda self,other:Point(self.x - other.x,self.y - other.y))
    
    print(p1.__sub__(p2,p1))
    print(p1.__sub__)
    
    
    #__sub__在实例里面
    print(p1.__dict__)
    print("- "*30)
    #__add__在类里面
    print(Point.__dict__)

![class6\_002][class6_002]

*  动态增加属性的方式和装饰器修饰一个类、Mixin方式的差异：
    
    1.  动态增加属性的方式是运行时改变类或者示例的方式。
    2.  装饰器或mixin都是定义时就决定了。
    3.  总结：**反射能力具有更大的灵活性**

## 反射相关的魔术方法 ##

<table> 
 <thead> 
  <tr> 
   <th align="left">方法</th> 
   <th align="left">对应的内建函数</th> 
   <th align="left">意义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><code>__getattr__(self,item)</code></td> 
   <td align="left"></td> 
   <td align="left">当通过搜索实例、实例的类及祖先类<strong>查不到</strong>属性，就会调用此方法</td> 
  </tr> 
  <tr> 
   <td align="left"><code>__setattr_(slef,key,values)</code></td> 
   <td align="left"><code>setattr(object,name,value)</code></td> 
   <td align="left">通过，访问实例属性，进行增加、修改都要调用它</td> 
  </tr> 
  <tr> 
   <td align="left"><code>__delattr__(self,item)</code></td> 
   <td align="left"><code>del obj.k</code></td> 
   <td align="left">当通过实例来删除属性时调用此方法</td> 
  </tr> 
  <tr> 
   <td align="left"><code>__getattribute__()</code></td> 
   <td align="left"><code>getattr(object,name[,default])</code></td> 
   <td align="left">实例所有的属性调用都从这个方法开始</td> 
  </tr> 
 </tbody> 
</table>

*  **属性查找顺序**
    
    1.  `实例调用__getattribute__()` \--> `instance.__dict__` \--> `instance.__class__.__dict__` \--> 继承的祖先类（直到 object）的`__dict__` \--> 调用`__getattr__()`

### `__getattr__(self,item)`方法 ###

*  实例属性会按照继承关系找，如果找不到，就会执行 `__getattr__(self,item)` 方法，如果没有这个方法，就会抛出 AttributeError异常表示找不到属性

![class6\_003][class6_003]

### `__setattr__(self,item)`方法 ###

*  实例通过.点号设置属性，例如 `self.x = x` 属性赋值，就会调用 `__setattr__(self,item)` ，属性要加到实例的 `__dict__` 中，就需要自己完成。
 *  `__setattr__(self,item)` 方法，可以拦截对实例属性的增加、修改操作，如果要设置生效，需要自己操作实例的 `__dict__` 。

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))
    
    p = Point(5,6)
    p.h = 5
    print(p.__dict__)
    print(p.x) #可以看出示例自己的属性self.x也会调用__setattr__方法

![class6\_004][class6_004]

*  `__setattr__(self,item)`与`__getattr__(self,item)`综合示例：

class B:
        b = 200
    
    class A(B):
        z = 100
        d = { }
    
        def __init__(self,x,y):
            self.x = x  #会调用__setattr__方法赋值
            setattr(self,"y",y)  #会调用__setattr__方法赋值
            self.__dict__["a"] = 5  #直接写入属性字典
    
        def __getattr__(self,item):
            print(" -----get---------",item)
            return self.d[item]
    
        def __setattr__(self,key,value):
            print("--------set-----",key,value)
            self.d[key] = value
    
        def __delattr__(self,item):
            print("{} 被删除".format(item))
    
    a = A(4,5)
    print(a.__dict__) #可以看到a的属性里面没有 x，y
    print(A.__dict__) #属性x,y被记录在了类属性d的字典里
    print(a.x,a.y) #找不到属性会调用getattr ，依然可以获取对应的x,y属性
    print(a.a)

![class6\_005][class6_005]

### `__delattr__(self,item)`方法 ###

*  可以阻止通过实例来删除属性的操作。但是通过类依然可以删除属性。
 *  当通过实例来删除属性时调用此方法

class Point:
        z = 5
    
        def __init__(self,x,y):
            self.x = x
            self.y = y
    
        def __delattr__(self,item):
            print("{} 要被删除，但是没做".format(item))
            # self.__dict__.pop(item) #删除可以从字典中移除
    
    p = Point(3,4)
    print(p.__dict__)
    del p.x
    print(p.__dict__) #可以看到并没有被删除
    del p.z  #通过实例访问删除属性z,被阻止
    print(Point.__dict__)
    del Point.z #通过类访问删除属性z可以
    print(Point.__dict__)

![class6\_006][class6_006]

### `__getattribute__(self,item)`方法 ###

*  实例的所有的属性访问，第一个都会调用 `__getattribute__` 方法，它阻止了属性的查找，该方法应该返回（计算 后的）值或者抛出一个AttributeError异常。
    
    1.  它的return值将作为属性查找的结果。
    2.  如果抛出AttributeError异常，则会直接调用 `__getattr__` 方法，因为表示属性没有找到。
 *  `__getattribute__` 方法中为了避免在该方法中无限的递归，它的实现应该永远调用基类的同名方法以访问需要的 任何属性，例如 `object.__getattribute__(self, name)` 。

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 "missing {}".format(item)
    
        def __getattribute__(self,item):
            # raise AttributeError("Not Found") #如果返回AttributeError异常，会调用getattr方法
            # pass
            # return self.__dict__[item]
            # return object.__getattribute__(self,item) #调用父类的方法
            print("__getattribute__被调用 {}".format(item))
            # return super(type(self),self).__getattribute__(item)
            return super().__getattribute__(item)
    
    p = Point(4,5)
    print(p.__dict__)
    print(p.x)
    print(p.z)

![class6\_007][class6_007]

## 附加：访问流程图 ##

*  getattr属性访问流程图  
    ![class6\_008][class6_008]

[class6_001]: /images/20220126/1e5a1a765e694472ad215c8eb9374b19.png
[class6_002]: /images/20220126/ef57cde0749741f7908152fd10759a31.png
[class6_003]: /images/20220126/49aa42c3ca4544679fc4db7809034ac9.png
[class6_004]: /images/20220126/9b5bd5baaa4146438cc38b99984b67a1.png
[class6_005]: /images/20220126/9eab845b23654924b1205a8ea2acd44a.png
[class6_006]: /images/20220126/1012dec6910844298b0cbc6b347c6f5d.png
[class6_007]: /images/20220126/929be85b1f95411db980caced299442f.png
[class6_008]: /images/20220126/d14e0ee499d145c09795a93e8dde46f2.png