Python运算符重载的简单实例代码

什么是运算符重载

让自定义的类生成的对象(实例)能够使用运算符进行操作

作用:

让自定义的实例像内建对象一样进行运算符操作

让程序简洁易读

对自定义对象将运算符赋予新的规则

算术运算符的重载:

            方法名                  运算符和表达式      说明
            __add__(self,rhs)        self + rhs        加法
            __sub__(self,rhs)        self - rhs         减法
            __mul__(self,rhs)        self * rhs         乘法
            __truediv__(self,rhs)   self / rhs          除法
            __floordiv__(self,rhs)  self //rhs          地板除
            __mod__(self,rhs)       self ％ rhs       取模(求余)
            __pow__(self,rhs)       self **rhs         幂运算

以__pow__为例

class Achievement(object):
   def __init__(self,achievement):
       self.achievement=achievement
   def __pow__(self,other):
       return self.achievement**other.achievement

achievement01=Achievement(20)
achievement02=Achievement(20)
print(pow(achievement01,achievement02))

打印输出的便是两个成绩的乘方104857600000000000000000000，其他运算符重载的基本步骤和__pow__大致相同。

python 3 的版本中已经没有cmp函数，被operator模块代替，在交互模式下使用时，需要导入模块。

import operator
operator.le(a, b)  
operator.eq(a, b)  
operator.ne(a, b)  
operator.ge(a, b)  
operator.gt(a, b)  
operator.__lt__(a, b)  
operator.__le__(a, b)  
operator.__eq__(a, b)  
operator.__ne__(a, b)  
operator.__ge__(a, b)  
operator.__gt__(a, b)

这几个函数就是用来替换之前的cmp的，先简单说下这几个函数的意思吧

lt(a,b) 相当于 a<b     数字或字母（ASCII）比大小 

le(a,b)相当于a<=b

eq(a,b)相当于a==b     字母完全一样，返回True,

ne(a,b)相当于a!=b

gt(a,b)相当于a>b

ge(a,b)相当于 a>=b
函数的返回值是布尔类型

但是我们可以用运算符重载来复现cmp的功能

例：

class Achievement(object):
   def __init__(self,achievement01,achievement02):
       self.achievement01=achievement01
       self.achievement02=achievement02
   def cmp(self):
       if self.achievement01>self.achievement02:
          print(self.achievement01,">",self.achievement02)
          return 1
       elif self.achievement01<self.achievement02:
           print(self.achievement01,"<",self.achievement02)
           return -1
       elif self.achievement01==self.achievement02:
           print(self.achievement01,"=",self.achievement02)
           return 0

 main.py:

from demo01 import *
def main():
   Achievement01=Achievement(100,50)
   Achievement01.cmp()

if __name__=="__main__":
   main()

上述例子中我在成绩类中写了一个cmp函数，因为python3中已经弃用了cmp函数，所以我们完全可以不按照标准的运算符重载写成__cmp__，直接函数名cmp即可，这样我们就又可以使用cmp函数了。

在主函数中传入成绩100和50，调用cmp函数，输出结果为100>50

反向运算符的重载

当运算符的左侧为内建类型时,右侧为自定义类型进行算术匀算符运算时会出现TypeError错误,因为无法修改内建类型的代码          实现运算符重载,此时需要使用反向运算符的重载

反向算术运算符的重载:

方法名                  运算符和表达式       说明
            __radd__(self,lhs)       lhs + self       加法
            __rsub__(self,lhs)       lhs - self       减法
            __rmul__(self,lhs)       lhs * self       乘法
            __rtruediv__(self,lhs)   lhs / self       除法
            __rfloordiv__(self,lhs)  lhs // self      地板除
            __rmod__(self,lhs)       lhs ％ self       取模(求余)
            __rpow__(self,lhs)       lhs ** self      幂运算

  示例:        

class Mylist:
   def __init__(self, iterable=()):
       self.data = list(iterable)

def __repr__(self):
       return 'Mylist(％s)' ％ self.data

def __add__(self, lst):
       print('__add__被调用')
       return Mylist(self.data + lst.data)

def __mul__(self, rhs):
       # rhs为int类型,不能用rhs.data
       print('__mul__被调用')
       return Mylist(self.data * rhs)

def __rmul__(self, lhs):
       print("__rmul__被调用")
       return Mylist(self.data * lhs)

L1 = Mylist([1, 2, 3])
L2 = Mylist([4, 5, 6])
L3 = 3 * L1
print(L3)
L1 += L2
print(L1)
L2 *= 3
print(L2)

来源：https://blog.csdn.net/weixin_51803729/article/details/122361880