Python中类的特殊属性与魔术方法

向右看齐 2022-01-27 10:21 379阅读 0赞

### 文章目录 ###

*  Python中类的特殊属性与魔术方法
 *   *  特殊的属性
     *   *  查看属性
         *  特殊函数
     *  魔术方法
     *   *  实例化
         *  可视化
         *  可哈希(hash)与等等运算符(==)
         *  bool
         *  运算符重载
         *   *  1.比较运算符重载
             *  2.算术运算符重载
             *  3.反向运算符
             *  4.赋值运算符的重载
             *  运算符重载的应用场景
             *  functools.total\_ordering装饰器
         *  容器相关方法
         *  可调用对象

# Python中类的特殊属性与魔术方法 #

## 特殊的属性 ##

<table> 
 <thead> 
  <tr> 
   <th align="left">属性</th> 
   <th align="left">含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">__name__</td> 
   <td align="left">类，函数，方法等效的名字。即名称</td> 
  </tr> 
  <tr> 
   <td align="left">__module__</td> 
   <td align="left">类定义所在的模块名称</td> 
  </tr> 
  <tr> 
   <td align="left">__class__</td> 
   <td align="left">对象或类所属的类</td> 
  </tr> 
  <tr> 
   <td align="left">__bases__</td> 
   <td align="left">类的基类(父类)的元组，顺序为他们在基类列表中出现的顺序</td> 
  </tr> 
  <tr> 
   <td align="left">__doc__</td> 
   <td align="left">类、函数的文档字符串，如果没有定义则为None</td> 
  </tr> 
  <tr> 
   <td align="left">__mro__</td> 
   <td align="left">类的mro,class.mro()返回的结果都保存在__mro__中。C3算法帮忙保证类的mro唯一性</td> 
  </tr> 
  <tr> 
   <td align="left">__dict__</td> 
   <td align="left">类或实例的属性，可写的字典</td> 
  </tr> 
 </tbody> 
</table>

### 查看属性 ###

<table> 
 <thead> 
  <tr> 
   <th align="left">方法</th> 
   <th align="left">含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">__dir__(self)</td> 
   <td align="left">返回类或者对象的所有成员<strong>名称列表</strong><br>dir()函数操作实例就是调用__dir()__</td> 
  </tr> 
 </tbody> 
</table>

如果dir(\[obj\])参数obj包含方法 \_\_dir\_\_() ，该方法将被调用。如果参数obj不包含 \_\_dir\_\_() ，该方法将最大限 度地收集属性信息。

*  dir(obj) \#如果没有参数，返回当前局部作用域中的名称列表。使用参数时，尝试返回该对象的有效属性列表。
    
     *  **dir(obj)相当于调用obj.\_\_dir\_\_()的方法**
     *  对于不同类型的对象obj具有不同的行为：
    
    1.  如果对象是**模块对象**，返回的列表包含模块的属性名和变量名
    2.  如果对象是类型或者说是**类对象**，返回的列表包含类的属性名，及它祖先类的属性名。
    3.  如果是类的实例
        
         *  有\_\_dir\_\_方法，返回可迭代对象的返回值
         *  没有\_\_dir\_\_方法，尽可能收集实例的属性名、类的属性和祖先类的属性名
    4.  如果obj不写，返回列表包含内容不同
        
         *  在模块中，返回模块的属性和变量名
         *  在类中，返回类本地作用域的属性和变量名
         *  在函数中，返回本地作用域的变量名
         *  在方法中，返回本地作用域的变量名

1.  示例1，不同作用域中的dir返回值 **返回局部作用域中的名称列表**
    
     *  animal.py文件信息如下：
    
        #animal.py文件信息如下：
        class Animal:
        x = 123
        def __init__(self,name):
            self._name = name
            self.__age = 18
            self.weight = 20
        
        print("animal.py names = {}".format(dir()))
    
     *  cat.py文件信息如下：
    
        #cat.py文件信息如下：
        import animal
        from animal import Animal
        
        class Cat(Animal):
            x = "cat"
            y = "abcd"
            print("Cat class 类中 names = {}".format(dir()))
        
            z = "xyz"
        
            def show(self):
                a = self
                b = 10
                print("show方法中 names = {}".format(dir()))
        
        print("cat.py names = {}".format(dir()))
        cat = Cat("苗")
        cat.show()
    
    执行cat.py文件输出结果如下：  
    ![class4\_001][class4_001]
2.  示例2：类型中的\_\_dir\_\_
    
     *  如果对象是类型或者说是**类对象，返回的列表包含类的属性名，及它祖先类的属性名。**
     *  dir(类) 等价于调用type.\_\_dir\_\_(类)方法。应为**类**的**类型**是**type**
    
        class Animal:
            x = 123
            def __init__(self,name):
                self._name = name
                self.__age = 18
                self.weight = 20
        
        class Cat(Animal):
            x = "cat"
            z = "xyz"
        
            def show(self):
                a = self
                b = 10
                print("show方法中 names = {}".format(dir()))
        
        class Dog(Animal):
            def __dir__(self):
                return ["dog"]  #__dir__方法必須返回可迭代对象
        
        #Cat类的dir 会调用type中的__dir__方法返回类Cat的dir,应为Cat是类
        print(type(Cat))
        print("Cat 类的 names = {}".format(dir(Cat)))
        #相当于排序后的集合
        print("Cat 类的 names = {}".format(sorted((Cat.__dict__.keys()| Animal.__dict__.keys() | object.__dict__.keys()))))
        print("Dog 类的 names = {}".format(dir(Dog)))
    
    ![class4\_003][class4_003]
3.  示例3：示例属性中的\_\_dir\_\_ (**尽可能的最大收集实例属性的属性名**)
    
     *  dir(self) 等价于 self.\_\_dir\_\_ \#self为实例对象
     *  如果类中重写了\_\_dir\_\_方法，那么dir(self)调用的返回值是重写的\_\_dir\_\_方法的返回值
     *  \_\_dir\_\_方法的返回值必须是一个可迭代对象
    
        class Animal:
            x = 123
            def __init__(self,name):
                self._name = name
                self.__age = 18
                self.weight = 20
        
        class Cat(Animal):
            x = "cat"
            z = "xyz"
        
            def show(self):
                a = self
                b = 10
                print("show方法中 names = {}".format(dir()))
        
        class Dog(Animal):
            def __dir__(self):
                return ["dog"]  #__dir__方法必須返回可迭代对象
        
        cat = Cat("苗")
        dog = Dog("旺旺")
        
        #注意：dir(cat) 等价于cat.__dir__()
        print("cat 实例属性,dir() = {}".format(dir(cat)))
        print("cat 的内建函数__dir__ = {}".format(sorted(cat.__dir__())))
        print("dog 实例的实例属性 dir() = {}".format(dir(dog)))
        print("dog 实例的实例属性 __dir__() = {}".format(dog.__dir__()))
    
    ![class4\_002][class4_002]

### 特殊函数 ###

*  locals() 返回**当前作用域**中的变量字典
 *  globals() 当前**模块全局变量**的字典

class Animal:
        x = 123
        def __init__(self,name):
            self._name = name
            self.__age = 18
            self.weight = 20
    
    class Cat(Animal):
        x = "cat"
        z = "xyz"
        print("Cat 类中 globals = {}".format(sorted(globals().keys())))
        print("Cat 类中 dir = {}".format(dir()))
        print("Cat 类中 locals = {}".format(sorted(locals().keys())))
        def show(self):
            a = self
            b = 10
            print("show方法中 globals = {}".format(sorted(globals().keys())))
            print("show方法中 dir = {}".format(dir()))
            print("show方法中 locals = {}".format(sorted(locals().keys())))
    
    class Dog(Animal):
        def __dir__(self):
            return ["dog"]  #__dir__方法必須返回可迭代对象
        print("Dog 类中 globals = {}".format(sorted(globals().keys())))
        print("Dog 类中 dir = {}".format(dir()))
        print("Dog 类中 locals = {}".format(sorted(locals().keys())))
    
    
    print("cat.py 模块中 globals = {}".format(sorted(globals().keys())))
    print("cat.py 模块中 locals = {}".format(sorted(locals().keys())))
    print("cat.py 模块中 dir = {}".format(dir()))
    cat = Cat("苗")
    cat.show()

![class4\_004][class4_004]

## 魔术方法 ##

### 实例化 ###

<table> 
 <thead> 
  <tr> 
   <th align="left">方法</th> 
   <th align="left">意义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">__new__(self,*args,**kwargs)</td> 
   <td align="left">示例化一个对象<br>该方法需要返回一个值，如果该值不少cls的实例，则会调用__init__<br>该方法永远都是静态方法<br>调用new方法前还没有实例对象，正常调用完成后会生成实例对象。</td> 
  </tr> 
  <tr> 
   <td align="left">__init__(self)</td> 
   <td align="left">对实例进行初始化，通常用来设置实例属性，基本配置信息等。<br>调用init方法前已经存在实例对象</td> 
  </tr> 
  <tr> 
   <td align="left">__del__(self)</td> 
   <td align="left">实例的引用次数为0时调用。即删除实例时调用。<br>当系统自动调用del方法后实例已经没有对象记录，等着垃圾回收gc来清理。</td> 
  </tr> 
 </tbody> 
</table>

*  new的简单示例(init和del方法在前面文章中已经讲到，这里不做演示)

class A:
        def __new__(cls,*args,**kwargs):
            print(cls)
            print(args)
            print(kwargs)
            # return super().__new__(cls)
            # return 1
            return None
    
        def __init__(self,name):
            self.name = name
    
    a = A()
    print(a)

![class4\_005][class4_005]  
\_\_new\_\_ 方法很少使用，即使创建了该方法，也会使用 return super().\_\_new\_\_(cls) 基类object的 \_\_new\_\_ 方 法来创建实例并返回。

### 可视化 ###

<table> 
 <thead> 
  <tr> 
   <th align="left">方法</th> 
   <th align="left">等效的内建函数</th> 
   <th align="left">含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">__str__(self)</td> 
   <td align="left">str()</td> 
   <td align="left">str()函数、format()函数、print()函数调用，需要返回对象的字符串表达式。如果没有定义，就去调用__repr__方法返回字符串的表达。如果__repr__没有定义，就直接返回对象的内存地址信息</td> 
  </tr> 
  <tr> 
   <td align="left"><code>__repr__(self)</code></td> 
   <td align="left">repr()</td> 
   <td align="left">内建函数repr()对一个对象获取字符串表达。<br>调用<code>__repr__</code>方法返回字符串表达，如果<code>__repr__</code>也没有定义，就直接返回object的定义，显示内存地址信息。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>__bytes__(self)</code></td> 
   <td align="left">bytes()</td> 
   <td align="left">bytes()函数调用，返回一个对象的bytes表达，即返回bytes对象</td> 
  </tr> 
 </tbody> 
</table>

*  简单示例：

class A:
        def __init__(self,name,age=18):
            self.name = name
            self.age = age
            
        def __repr__(self):
            return "repr:{},{}".format(self.name,self.age)
        
        def __str__(self):
            return "str:{},{}".format(self.name,self.age)
        
        def __bytes__(self)->bytes:
            import json
            return json.dumps(self.__dict__).encode()
        
    a = A("tom")
    print(a) #print函数会默认调用对象的__str__ 等价于a.__str__
    print([a]) #等价于[a].__str__ 但[]里面会默认调用a的__repr__即等价于[a.__repr__()].__str__()
    print([a.__repr__()].__str__())
    print(bytes(a)) #等价于str(bytes(a)) 等价于 a.__bytes__().__str__()
    print( a.__bytes__().__str__())

![class4\_006][class4_006]

### 可哈希(hash)与等等运算符(==) ###

<table> 
 <thead> 
  <tr> 
   <th align="left">方法</th> 
   <th align="left">等效的内建函数</th> 
   <th align="left">意义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><code>__hash__(self)</code></td> 
   <td align="left">hash()</td> 
   <td align="left">内建函数hash()调用的返回值，返回一个整数。如果定义这个方法该类的实例就可hash。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>__eq__(self)</code></td> 
   <td align="left">==</td> 
   <td align="left">对等等操作符，判断2个对象是否相等，返回值bool值<br>定义了这个方法，如果不提供<code>__hash__</code>方法，那么实例对象将不可hash了。</td> 
  </tr> 
 </tbody> 
</table>

*  `__hash__` 方法只是返回一个hash值作为set的key，但是 去重 ，还需要 `__eq__` 来判断2个对象是否相等。 hash值相等，只是hash冲突，不能说明两个对象是相等的。
 *  因此，一般来说提供 `__hash__` 方法是为了作为set或者dict的key，如果 去重 要同时提供 `__eq__` 方法。
 *  判断对象是否可哈希isinstance(obj, collections.Hashable),obj为需要判断的对象。

1.  示例1:
    
     *  对象的hash值取决于对象的`__hash__`函数的返回值
     *  如果使用"=="运算符，其结果为`__eq__`函数的返回值
    
        class A:
            def __init__(self,name,age=18):
                self.name = name
                self.age = age
        
            def __hash__(self):
                return hash("{},{}".format(self.name,self.age))
        
            def __repr__(self):
                return "repr {} {}".format(self.name,self.age)
        
            def __eq__(self,other):
                # return "abc" #如果返回字符串，那么print(b==a)的结果就是返回的字符串
                return True
        
            __str__ = __repr__
        
        a = A("旺旺")
        b = A("哈哈")
        print(a)
        print(hash(a),a.__hash__())
        print(hash(b),b.__hash__())
        print(b==a) #等价于 b.__eq__(a)
    
    ![class4\_007][class4_007]
2.  示例2:
    
     *  set字典中唯一性先判断对象是否可hash，在判断hash值是否相等以及是否“==”来判断新增加的值是否已经存在
    
        class stt:
            def __repr__(self):
                return "("+",".join("{}:{}".format(x,y) for x,y in self.__dict__.items())+")"
        
        class Point(stt):
            def __init__(self,x,y):
                self.x = x
                self.y = y
        
        class Point2(stt):
            def __init__(self,x,y):
                self.x = x
                self.y = y
        
            def __hash__(self):
                return hash("{},{}".format(self.x,self.y))
        
            def __eq__(self,other):
                return self.x==self.x and self.y==self.y
        
        print(set([Point(1,2),Point(1,2)]))
        print(set([Point2(1,2),Point2(1,2)]))
    
    ![class4\_008][class4_008]
3.  示例3：
    
     *  扩展
     *  hash值对int类型求值是用一个大整数取摸(%)计算得到的结果
     *  hash值的整数为：【2305843009213693951】
     *  下面示例求出hash值对应的大整数是多少
    
        # %%timeit
        def getHashbigInt():
            i = 0
            ii = 2 #增量
        
            while ii >1:
                i = i+ii
                if hash(i)==i:
                    ii = ii*2 #增量加大
                else: #调整增量
                    i = i-ii  #i值还原
                    ii = ii//2 #增量缩小
            return i+1
        
        hig = getHashbigInt()
        print(hig)
        print(hash(hig-1),hash(hig),hash(hig+1))
    
    ![class4\_009][class4_009]

### bool ###

<table> 
 <thead> 
  <tr> 
   <th align="left">方法</th> 
   <th>对应的内建函数</th> 
   <th>意义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><code>__bool__(self)</code></td> 
   <td>bool()</td> 
   <td>内建函数bool()，或者对象放在逻辑表达式的位置，调整这个函数返回布尔值。<br>如果对象没有定义<code>__bool__()</code>，就找<code>__len__()</code>返回长度，非0为真<br>如果<code>__len__()</code>也没有定义，那么所有实例都返回真</td> 
  </tr> 
 </tbody> 
</table>

*  `if obj`等价于 `if obj.__bool__()`
 *  `bool(obj)`等价于 `obj.__bool__()`

class A:pass
    
    class B:
        def __bool__(self)->bool:
            #注意：bool函数的返回值必须是bool类型，否则会报错
            return False
    
    class C:
        def __len__(self):
            return 1
    
    class D:
        def __len__(self):
            return 0
    
    a = A()
    b = B()
    c = C()
    d = D()
    print(bool(a),bool(b),bool(c),bool(d))
    if a: #if a等价于 if a.__bool__()
        print("this is a = true")
    if b:
        print("this is b = true")
    if c:
        print("this is c = true")
    if d:
        print("this is d = true")

![class4\_0010][class4_0010]

### 运算符重载 ###

operator模块提供以下的特殊方法，可以将类的实例使用下面的操作符来操作

#### 1.比较运算符重载 ####

<table> 
 <thead> 
  <tr> 
   <th align="left">特殊方法</th> 
   <th align="left">运算符</th> 
   <th align="left">含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><code>__lt__(self,other)</code></td> 
   <td align="left"><code>&lt;</code></td> 
   <td align="left"><strong>小于运算符</strong>等效符调用的对应方法<br>在<code>obj1 &lt; obj2</code>时调用<code>obj1.__lt__(obj2)</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>__le__(self,other)</code></td> 
   <td align="left"><code>&lt;=</code></td> 
   <td align="left"><strong>小于等于运算符</strong>等效符调用的对应方法<br>在<code>obj1 &lt;= obj2</code>时调用<code>obj1.__le__(obj2)</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>__eq__(self,other)</code></td> 
   <td align="left"><code>==</code></td> 
   <td align="left"><strong>等等运算符</strong>等效调用的对应方法<br>在<code>obj1 == obj2</code>时调用<code>obj1.__eq__(obj2)</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>__gt__(self,other)</code></td> 
   <td align="left"><code>&gt;</code></td> 
   <td align="left"><strong>大于运算符</strong>等效调用的对应方法<br>在<code>obj1 &gt; obj2</code>时调用<code>obj1.__gt__(obj2)</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>__ge__(self,other)</code></td> 
   <td align="left"><code>&gt;=</code></td> 
   <td align="left"><strong>大于等于运算符</strong>等效调用的对应方法<br>在<code>obj1 &gt;= obj2</code>时调用<code>obj1.__ge__(obj2)</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>__ne__(self,other)</code></td> 
   <td align="left"><code>!=</code></td> 
   <td align="left"><strong>不等运算符</strong>等效调用的对应方法<br>在<code>obj1 != obj2</code>时调用<code>obj1.__ne__(obj2)</code></td> 
  </tr> 
 </tbody> 
</table>

**注意：**

*  完成小于方法，对应的大于方法可以不用重新也能使用。反之也一样。
 *  完成小于等于方法，对应的大于等于方法可以不用重写。反之也一样。
 *  简单示例：

class A:
        def __init__(self,age = 18):
            self.age = age
    
        def __lt__(self,other): #完成小于方法，大于方法也可以使用
            return self.age < other.age
    
        def __ge__(self,other): #完成大于等于方法，小于等于方法也可以使用
            return self.age >= other.age
    
        def __eq__(self,other): #完成
            return self.age == other.age
    
    a1 = A()
    a2 = A(20)
    a3 = A(10)
    a4 = A()
    print("a1 < a2 ,{}".format( a1 < a2 ))
    print("a1 > a2 ,{}".format( a1 > a2 ))
    print("a1 >= a2 ,{}".format( a1 >= a2 ))
    print("a1 <= a2 ,{}".format( a1 <= a2 ))
    print("a1 <= a4 ,{}".format( a1 <= a4 ))
    print("a1 == a4 ,{}".format( a1 == a4 ))

![class4\_0011][class4_0011]

#### 2.算术运算符重载 ####

<table> 
 <thead> 
  <tr> 
   <th align="left">特殊方法</th> 
   <th align="left">运算符</th> 
   <th align="left">含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><code>__add__(self,other)</code></td> 
   <td align="left"><code>+</code></td> 
   <td align="left"><strong>加法运算</strong>等效调用的对应方法<br>在<code>obj1 + obj2</code>时调用<code>obj1.__add__(obj2)</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>__sub__(self,other)</code></td> 
   <td align="left"><code>-</code></td> 
   <td align="left"><strong>减法运算</strong>等效调用的对应方法<br>在<code>obj1 - obj2</code>时调用<code>obj1.__sub__(obj2)</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>__mul__(self,other)</code></td> 
   <td align="left"><code>*</code></td> 
   <td align="left"><strong>乘法运算</strong>等效调用的对应方法<br>在<code>obj1 * obj2</code>时调用<code>obj1.__mul__(obj2)</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>__truediv__(self,other)</code></td> 
   <td align="left"><code>/</code></td> 
   <td align="left"><strong>除法运算</strong>等效调用的对应方法<br>在<code>obj1 / obj2</code>时调用<code>obj1.__truediv__(obj2)</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>__mod__(self,other)</code></td> 
   <td align="left"><code>%</code></td> 
   <td align="left">**取摸运算(取余数)**等效调用的对应方法<br>在<code>obj1 % obj2</code>时调用<code>obj1.__mod__(obj2)</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>__floordiv__(self,other)</code></td> 
   <td align="left"><code>//</code></td> 
   <td align="left"><strong>整除运算</strong>(向下取整)等效调用的对应方法<br>在<code>obj1 // obj2</code>时调用<code>obj1.__floordiv__(obj2)</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>__pow__(self,other)</code></td> 
   <td align="left"><code>**</code><br>pow(x,n)</td> 
   <td align="left"><strong>次幂运算</strong>等效调用的对应方法。也等价于pow(x,n)方法<br>在<code>obj1 ** obj2</code>时调用<code>obj1.__pow__(obj2)</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>__divmod__(self,other)</code></td> 
   <td align="left">divmod(obj1,obj2)</td> 
   <td align="left"><strong>获取数的商和余数组成的元组</strong>等效的对应方法<br>在<code>divmod(obj1,obj2)</code>时调用<code>obj1.__divmod__(obj2)</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>__matmul__(self,other)</code></td> 
   <td align="left"><code>@</code></td> 
   <td align="left"><strong>矩阵运算符</strong>等效调用的对应方法<br>在<code>obj1 @ obj2</code>时调用<code>obj1.__matmul__(obj2)</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>__and__(self,other)</code></td> 
   <td align="left"><code>&amp;</code></td> 
   <td align="left"><strong>与运算符</strong>等效的对应方法<br>在<code>obj1 &amp; obj2</code>时调用<code>obj1.__and__(obj2)</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>__or__(self,other)</code></td> 
   <td align="left"><code>|</code></td> 
   <td align="left"><strong>或运算符</strong>等效的对应方法<br>在<code>obj1 | obj2</code>时调用<code>obj1.__or__(obj2)</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>__xor__(self,other)</code></td> 
   <td align="left"><code>^</code></td> 
   <td align="left"><strong>异或运算符</strong>等效的对应方法<br>在<code>obj1 ^ obj2</code>时调用<code>obj1.__xor__(obj2)</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>__lshift__(self,other)</code></td> 
   <td align="left"><code>&lt;&lt;</code></td> 
   <td align="left"><strong>左移运算符</strong>等效的对应方法<br>在<code>obj1 &lt;&lt; obj2</code>时调用<code>obj1.__lshift__(obj2)</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>__rshift__(self,other)</code></td> 
   <td align="left"><code>&gt;&gt;</code></td> 
   <td align="left"><strong>右移运算符</strong>等效的对应方法。<br>在<code>obj1 &gt;&gt; obj2</code>时调用<code>obj1.__rshift__(obj2)</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>__invert__(self,other)</code></td> 
   <td align="left"><code>~</code></td> 
   <td align="left"><strong>按位取反运算符</strong>等效的对应方法<br>在~obj时调用<code>obj.__invert__()</code></td> 
  </tr> 
 </tbody> 
</table>

*  简单示例：

class A:
        def __init__(self,age=18):
            self.age = age
    
        def __repr__(self):
            return "(age = {})".format(self.age)
    
        def __add__(self,other):
            return A(self.age + other.age)
    
    a1 = A(15)
    a2 = A(18)
    print(a1,a2,a1+a2)

![class4\_0012][class4_0012]

#### 3.反向运算符 ####

*  在`obj1 + obj2`中如果obj1不支持`+`操作，那么`obj1.__add__(self,other)`的返回值应该是NotImplemented，此时系统会调用obj2中的`__radd__(self,other)`方法来实现运算。即执行`obj2.__radd__(obj1)`

<table> 
 <thead> 
  <tr> 
   <th align="left">特殊方法</th> 
   <th align="left">运算符</th> 
   <th align="left">含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"></td> 
   <td align="left"></td> 
   <td align="left">以下示例中。按照<code>__iadd__</code>方法来举例：<br>obj1中必须没有定义对应的方法<code>__add__</code>。或者返回值为NotImplemented。才会调用<code>obj2.__radd__(obj1)</code>来完成运算</td> 
  </tr> 
  <tr> 
   <td align="left"><code>__radd__(self,other)</code></td> 
   <td align="left"><code>+</code></td> 
   <td align="left"><strong>加法运算</strong>等效调用的对应方法<br>在<code>obj1 + obj2</code>时调用<code>obj2.__radd__(obj1)</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>__rsub__(self,other)</code></td> 
   <td align="left"><code>-</code></td> 
   <td align="left"><strong>减法运算</strong>等效调用的对应方法<br>在<code>obj1 - obj2</code>时调用<code>obj2.__rsub__(obj1)</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>__rmul__(self,other)</code></td> 
   <td align="left"><code>*</code></td> 
   <td align="left"><strong>乘法运算</strong>等效调用的对应方法<br>在<code>obj1 * obj2</code>时调用<code>obj2.__rmul__(obj1)</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>__rtruediv__(self,other)</code></td> 
   <td align="left"><code>/</code></td> 
   <td align="left"><strong>除法运算</strong>等效调用的对应方法<br>在<code>obj1 / obj2</code>时调用<code>obj2.__rtruediv__(obj1)</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>__rmod__(self,other)</code></td> 
   <td align="left"><code>%</code></td> 
   <td align="left">**取摸运算(取余数)**等效调用的对应方法<br>在<code>obj1 % obj2</code>时调用<code>obj2.__rmod__(obj1)</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>__rfloordiv__(self,other)</code></td> 
   <td align="left"><code>//</code></td> 
   <td align="left"><strong>整除运算</strong>(向下取整)等效调用的对应方法<br>在<code>obj1 // obj2</code>时调用<code>obj2.__rfloordiv__(obj1)</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>__rpow__(self,other)</code></td> 
   <td align="left"><code>**</code><br>pow(x,n)</td> 
   <td align="left"><strong>次幂运算</strong>等效调用的对应方法。也等价于pow(x,n)方法<br>在<code>obj1 ** obj2</code>时调用<code>obj2.__rpow__(obj1)</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>__rdivmod__(self,other)</code></td> 
   <td align="left">divmod(obj1,obj2)</td> 
   <td align="left"><strong>获取数的商和余数组成的元组</strong>等效的对应方法<br>如果obj1没有<code>__divmod__</code>方法，或者返回NotImplemented，则会调用<code>obj2.__rdivmod__(obj1)</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>__rmatmul__(self,other)</code></td> 
   <td align="left"><code>@</code></td> 
   <td align="left"><strong>矩阵运算符</strong>等效调用的对应方法<br>在<code>obj1 @ obj2</code>时调用<code>obj2.__rmatmul__(obj1)</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>__rand__(self,other)</code></td> 
   <td align="left"><code>&amp;</code></td> 
   <td align="left"><strong>与运算符</strong>等效的对应方法<br>在<code>obj1 &amp; obj2</code>时调用<code>obj2.__rand__(obj1)</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>__ror__(self,other)</code></td> 
   <td align="left"><code>|</code></td> 
   <td align="left"><strong>或运算符</strong>等效的对应方法<br>在<code>obj1 | obj2</code>时调用<code>obj2.__ror__(obj1)</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>__rxor__(self,other)</code></td> 
   <td align="left"><code>^</code></td> 
   <td align="left"><strong>异或运算符</strong>等效的对应方法<br>在<code>obj1 ^ obj2</code>时调用<code>obj2.__rxor__(obj1)</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>__rlshift__(self,other)</code></td> 
   <td align="left"><code>&lt;&lt;</code></td> 
   <td align="left"><strong>左移运算符</strong>等效的对应方法<br>在<code>obj1 &lt;&lt; obj2</code>时调用<code>obj2.__rlshift__(obj1)</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>__rrshift__(self,other)</code></td> 
   <td align="left"><code>&gt;&gt;</code></td> 
   <td align="left"><strong>右移运算符</strong>等效的对应方法。<br>在<code>obj1 &gt;&gt; obj2</code>时调用<code>obj2.__rrshift__(obj1)</code></td> 
  </tr> 
 </tbody> 
</table>

*  简单流程运行图：  
    ![a+b][a_b]
 *  简单示例：

class A:
        def __init__(self,age=18):
            self.age = age
    
        def __repr__(self):
            return "(age = {})".format(self.age)
    
        def __add__(self,other):
            return A(self.age + other.age)
    
        def __radd__(self,other):
            return A(self.age + other.age)
    
    class B:
        def __init__(self,age= 18):
            self.age = age
    
        def __repr__(self):
            return "(age = {})".format(self.age)
    
    a = A(10)
    b = B(15)
    print(a+b)
    print(b+a)

![class4\_0013][class4_0013]

#### 4.赋值运算符的重载 ####

<table> 
 <thead> 
  <tr> 
   <th align="left">特殊方法</th> 
   <th align="left">运算符</th> 
   <th align="left">含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><code>__iadd__(self,other)</code></td> 
   <td align="left"><code>+=</code></td> 
   <td align="left"><strong>加等赋值运算</strong>等效调用的对应方法<br>在<code>obj1 += obj2</code>时调用<code>obj1 = obj1.__iadd__(obj2)</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>__isub__(self,other)</code></td> 
   <td align="left"><code>-=</code></td> 
   <td align="left"><strong>减等赋值运算</strong>等效调用的对应方法<br>在<code>obj1 -= obj2</code>时调用<code>obj1 = obj1.__isub__(obj2)</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>__imul__(self,other)</code></td> 
   <td align="left"><code>*=</code></td> 
   <td align="left"><strong>乘等赋值运算</strong>等效调用的对应方法<br>在<code>obj1 *= obj2</code>时调用<code>obj1 = obj1.__imul__(obj2)</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>__itruediv__(self,other)</code></td> 
   <td align="left"><code>/=</code></td> 
   <td align="left"><strong>除等赋值运算</strong>等效调用的对应方法<br>在<code>obj1 /= obj2</code>时调用<code>obj1 = obj1.__itruediv__(obj2)</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>__imod__(self,other)</code></td> 
   <td align="left"><code>%=</code></td> 
   <td align="left"><strong>取模等赋值运算</strong>等效调用的对应方法<br>在<code>obj1 %= obj2</code>时调用<code>obj1 = obj1.__imod__(obj2)</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>__ifloordiv__(self,other)</code></td> 
   <td align="left"><code>//=</code></td> 
   <td align="left"><strong>整除等赋值运算符</strong>等效调用的对应方法<br>在<code>obj1 //= obj2</code>时调用<code>obj1 = obj1.__ifloordiv__(obj2)</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>__ipow__(self,other)</code></td> 
   <td align="left"><code>**=</code></td> 
   <td align="left"><strong>次幂等运算符</strong>等效调用的对应方法<br>在<code>obj1 **= obj2</code>时调用<code>obj1 = obj1.__ipow__(obj2)</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>__imatmul__(self,other)</code></td> 
   <td align="left"><code>@=</code></td> 
   <td align="left"><strong>矩阵等赋值运算</strong>等效调用的对应方法<br>在<code>obj1 @= obj2</code>时调用<code>obj1 = obj1.__imatmul__(obj2)</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>__iand__(self,other)</code></td> 
   <td align="left"><code>&amp;=</code></td> 
   <td align="left"><strong>与等赋值运算</strong>等效的对应方法<br>在<code>obj1 &amp;= obj2</code>时调用<code>obj1 = obj1.__iand__(obj2)</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>__ior__(self,other)</code></td> 
   <td align="left"><code>|=</code></td> 
   <td align="left"><strong>或等赋值运算</strong>等效的对应方法<br>在<code>obj1 |= obj2</code>时调用<code>obj1 = obj1.__ior__(obj2)</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>__ixor__(self,other)</code></td> 
   <td align="left"><code>^=</code></td> 
   <td align="left"><strong>异或等赋值运算</strong>等效的对应方法<br>在<code>obj1 ^= obj2</code>时调用<code>obj1 = obj1.__ixor__(obj2)</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>__ilshift__(self,other)</code></td> 
   <td align="left"><code>&lt;&lt;=</code></td> 
   <td align="left"><strong>左移等赋值运算</strong>等效的对应方法<br>在<code>obj1 &lt;&lt;= obj2</code>时调用<code>obj1 = obj1.__ilshift__(obj2)</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>__irshift__(self,other)</code></td> 
   <td align="left"><code>&gt;&gt;=</code></td> 
   <td align="left"><strong>右移等赋值运算</strong>等效的对应方法<br>在<code>obj1 &gt;&gt;= obj2</code>时调用<code>obj1 = obj1.__irshift__(obj2)</code></td> 
  </tr> 
 </tbody> 
</table>

*  **注意：例如：`obj1 += obj2`中，如果obj1没有**对应的**加法赋值**运算`__iadd__`那么等式会转换成`obj1 = obj1 + obj2`即`obj1 = obj1.__add__(obj2)`，其他赋值也同样适用。
 *  简单示例01：

class A:
        def __init__(self,age=18):
            self.age = age
    
        def __repr__(self):
            return "(age = {})".format(self.age)
    
        def __add__(self,other):
            return A(self.age + other.age)
    
        def __iadd__(self,other):
            self.age = self.age + other.age
            return self
    
    a1 = A(15)
    a2 = A(18)
    print(a1,a2,a1+a2)
    a1 += a2
    print(a1)

![class4\_0014][class4_0014]

*  简单示例02：

![class4\_015][class4_015]

*  综合示例：完成Point类设计，实现判断点相等的方法，并完成向量的加法
    
    1.  在直角坐标系里面，定义原点为向量的起点。两个向量和与差的坐标分别等于这两个向量相应坐标的和与差若向量 的表示为(x,y)形式。
    2.  `A(X1,Y1) B(X2,Y2)，则A+B=（X1+X2，Y1+Y2），A-B=（X1-X2，Y1-Y2）`

class Point:
        def __init__(self,x:int,y:int):
            self.x = x
            self.y = y
    
        def __add__(self,other):
            return Point(self.x+other.x,self.y+other.y)
    
        # def __iadd__(self,other):
        # self.x += other.x
        # self.y += other.y
        # return self
    
        def __sub__(self,other):
            return Point(self.x-other.x,self.y-other.y)
    
        # def __isub__(self,other):
        # self.x -= other.x
        # self.y -= other.y
        # return self
    
        def __repr__(self):
            return "<Point {},{}>".format(self.x,self.y)
    
    p1 = Point(5,6)
    p2 = Point(1,2)
    print(p1+p2,p1-p2)
    p1-=p2
    print(p1)

![class4\_0016][class4_0016]

#### 运算符重载的应用场景 ####

往往是用面向对象实现的类，需要做大量的运算，而运算符是这种运算在数学上最常见的表达方式。例如，上例中 的对+进行了运算符重载，实现了Point类的二元操作，重新定义为Point + Point。提供运算符重载，比直接提供加法方法要更加适合该领域内使用者的习惯。  
int类，几乎实现了所有操作符，可以作为参考。

#### functools.total\_ordering装饰器 ####

`__lt__ , __le__ , __eq__ , __gt__ , __ge__` 是比较大小必须实现的方法，但是全部写完太麻烦，使用 @functools.total\_ordering 装饰器就可以大大简化代码。  
但是要求 `__eq__` 必须实现，其它方法 `__lt__ , __le__ , __gt__ , __ge__` 实现其一

from functools import total_ordering
    
    @total_ordering
    class Person:
        def __init__(self,name,age):
            self.name = name
            self.age = age
            
        def __eq__(self,other):
            return self.age == other.age
        
        def __gt__(self,other):
            return self.age > other.age
        
    tom = Person("tom",20)
    jerry = Person("jerry",16)
    print(tom > jerry)
    print(tom < jerry)
    print(tom >= jerry)
    print(tom <= jerry)

![class4\_0017][class4_0017]

上例中大大简化代码，但是一般来说比较实现等于或者小于方法也就够了，其它可以不实现，所以这个装饰器只是 看着很美好，且可能会带来性能问题，建议需要什么方法就自己创建，少用这个装饰器。

class Person:
        def __init__(self,name,age):
            self.name = name
            self.age = age
            
        def __eq__(self,other):
            return self.age == other.age
        
        def __gt__(self,other):
            return self.age >other.age
        
        def __ge__(self,other):
            return self.age >= other.age
        
    tom = Person("tom",20)
    jerry = Person("jerry",16)
    print(tom > jerry)
    print(tom < jerry)
    print(tom >= jerry)
    print(tom <= jerry)
    print(tom == jerry)
    print(tom != jerry)

![class4\_0018][class4_0018]

*  `__eq__`等于可以推断不等于
 *  `__gt__`大于可以推断小于
 *  `__ge__`大于等于可以推断小于等于  
    也就是用3个方法，就可以把所有比较解决了。

### 容器相关方法 ###

<table> 
 <thead> 
  <tr> 
   <th align="left">方法</th> 
   <th align="left">对应的操作</th> 
   <th align="left">意义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><code>__len__(self)</code></td> 
   <td align="left">len(obj)</td> 
   <td align="left">内建函数len()，返回对象的长度(&gt;=0的整数)，如果把对象当做容器类型看，就如同list或者dict。<br>bool()函数调用的时候，如果没有<code>__bool__()</code>方法，则会看<code>__len__()</code>方法是否存在，存在返回非0为真。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>__iter__(self)</code></td> 
   <td align="left"><code>for i in obj</code></td> 
   <td align="left">迭代容器时，调用，返回一个<strong>新的可迭代对象</strong></td> 
  </tr> 
  <tr> 
   <td align="left"><code>__contains__(self,item)</code></td> 
   <td align="left"><code>x in obj</code></td> 
   <td align="left">in 成员运算符，没有实现，就默认调用<code>__iter__</code>方法遍历</td> 
  </tr> 
  <tr> 
   <td align="left"><code>__getitem__(self,key)</code></td> 
   <td align="left"><code>obj[key]</code></td> 
   <td align="left">实现self[key]访问。序列对象，key接受整数为索引，或者切片。对于set和dict,key为可以hashable(即可哈希)。key不存在引发KeyError异常</td> 
  </tr> 
  <tr> 
   <td align="left"><code>__setitem__(self,key)</code></td> 
   <td align="left"><code>obj[key] = value</code></td> 
   <td align="left">和<code>__getitem__</code>的访问类似，是设置值的方法</td> 
  </tr> 
  <tr> 
   <td align="left"><code>__missing__(self,key)</code></td> 
   <td align="left"></td> 
   <td align="left">字典或其子类使用<code>__getitem__()</code>调用时，key不存在执行该方法</td> 
  </tr> 
 </tbody> 
</table>

*  `__missing__(self,key)`例子：

class A(dict):
        def __missing__(self,key):
            print("键值对不存在。。{}".format(key))
            return 0
    
    a = A()
    a["a"] = 10
    print(a["a"])
    print(a["b"])

![class4\_0019][class4_0019]

*  简单综合示例：不使用继承，实现一个容器

class Goods:
        def __init__(self,name):
            self.name = name
    
        def __repr__(self):
            return "<Goods name = {}>".format(self.name)
    
    class Cart:
    
        def __init__(self):
            self.__goods = list()
    
        def __len__(self):
            return len(self.__goods)
    
        def add(self,good:Goods):
            self.__goods.append(good)
    
        def __add__(self, other):
            self.add(other)
            return self
    
        def __iter__(self):
            # yield from self.__goods
            return iter(self.__goods)
    
        def __getitem__(self, item):
            return self.__goods[item]
    
        def __setitem__(self, key, value):
            self.__goods[key] = value
    
        def __repr__(self):
            return str(self.__goods)
    
    gd = Goods("棒棒糖")
    gd2 = Goods("宫保鸡丁")
    cat = Cart() + gd + gd2
    cat.add(Goods("火爆鸡精"))
    print(cat)

![class4\_0020][class4_0020]

### 可调用对象 ###

Python中一切皆对象，函数也不例外。

def foo():
        print(foo.__module__,foo.__name__)
    
    foo()
    #等价于
    foo.__call__()

![class4\_0021][class4_0021]

函数即对象，对象foo加上()，就是调用此函数对象的 `__call__()` 方法

<table> 
 <thead> 
  <tr> 
   <th align="left">方法</th> 
   <th align="left">等效</th> 
   <th align="left">意义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><code>__call__(self)</code></td> 
   <td align="left">obj()</td> 
   <td align="left">类中定义一个该方法，<strong>类的实例</strong>就可以像函数一样调用</td> 
  </tr> 
 </tbody> 
</table>

*  示例1：可调用对象，定义一个类，并实例化得到其实例，将实例像函数一样调用。

class Adder:
        def __call__(self,*args):
            self.sum = sum(args)
            return self.sum
    
    adder = Adder()
    print(adder(4,5,6,3,2))
    print(adder.sum)

![class4\_0022][class4_0022]

*  示例2:定义一个斐波拉契数列，方便调用，计算第n项。
    
    1.  增加迭代的方法、返回容器长度、支持索引的方法。

class Xdd_Fib:
        """ 斐波拉契数列类，获取第num个位置的斐波拉契数列。 """
        def __init__(self):
            self.fib = [0,1,1]
    
        def __len__(self):
            return len(self.fib)
    
        #类的实例可调用
        def __call__(self,num:int):
            if not isinstance(num,int):
                raise TypeError("num必须是int类型")
            if num<0:
                raise KeyError("选项错误，必须大于0")
            elif num<3:
                return self.fib[num]
            else:
                for i in range(len(self),num + 1):
                    self.fib.append(self.fib[i-1]+self.fib[i-2])
            return self.fib[num]
    
        #类可迭代
        def __iter__(self):
            return iter(self.fib)
    
        def __repr__(self):
            return ",".join(map(str,self.fib))
    
        __str__ = __repr__
        __getitem__ = __call__ #类可以像数组一样访问
    
    fib = Xdd_Fib()
    print(fib(5),fib(6),fib(8))
    print(fib)

![class4\_0023][class4_0023]

[class4_001]: /images/20220127/a293e18be41749b0927eee02b1da04d4.png
[class4_003]: /images/20220127/4a5e4a0147aa468b86fff9f1f980a663.png
[class4_002]: /images/20220127/2d07de90a29f4364ae0571057f6cb49d.png
[class4_004]: /images/20220127/457c3d2b9c834bb0b13e9ab19694b4a5.png
[class4_005]: /images/20220127/5fcf9d7bb0ef45cb8fdd8b83085957da.png
[class4_006]: /images/20220127/05d3f66d04d2489485b0bcd3a330ac57.png
[class4_007]: /images/20220127/377f26c86d4d4ae5b46b4753995eba69.png
[class4_008]: /images/20220127/81a6e71cc8e34e04ac1412ced38cd057.png
[class4_009]: /images/20220127/472a0445b9c04d238337fa34a3c2a9a5.png
[class4_0010]: /images/20220127/40db1978fa2e4694b392e0c8a0d696f1.png
[class4_0011]: /images/20220127/b1d66fbd108245eb85842c20a27546ff.png
[class4_0012]: /images/20220127/68134551f2e14684ab4491816a5e665a.png
[a_b]: https://raw.githubusercontent.com/1263351411/xdd.github.io/master/img/python/a+b.png
[class4_0013]: /images/20220127/414a219b630a43a0909678b06944eca1.png
[class4_0014]: /images/20220127/b61efdb10c494a2eb332b55cf688d8d7.png
[class4_015]: /images/20220127/23e303cf9d6346ec83755607166fd29b.png
[class4_0016]: /images/20220127/90126061ce1e425d9f6699697cb801ef.png
[class4_0017]: /images/20220127/5983cfd1e7f74ed4b9e9f5e852717c1d.png
[class4_0018]: /images/20220127/13a8315050d7407f991dba2e310b8513.png
[class4_0019]: /images/20220127/9c6a93ab58fc49379433a69f69f04ba8.png
[class4_0020]: /images/20220127/ed250f2a9f8446f8976e92e8e6108b25.png
[class4_0021]: /images/20220127/40a16a972d6e4da0a6b1ac853bb05a71.png
[class4_0022]: /images/20220127/69e49b42f0554a82abe880868c61fefe.png
[class4_0023]: /images/20220127/80172b953f6344628a58186cd3183047.png