【Python】面向对象的运算符重载

面向对象的编程中可以对运算符进行重载，使运算符可以对该类的实例进行操作。

重载方法的一般格式如下:

1 def __运算符名__(self, other):
2 　　运算符语句

比较常用的运算符重载有三类：二元算术运算符重载、反向算术运算符重载、比较运算符重载、一元运算符重载

二元算术运算符的重载:
方法名                  运算符和表达式      说明
__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       幂运算*rhs的含义是right hand side

反向算术运算符的重载:　　当运算符的左侧为Python的内建数据类型(如：int、float等)，右侧为自定义的对象类型时就需要对运算符进行反向重载。
 方法名                  运算符和表达式       说明
__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       幂运算*lhs的含义是left hand side*可见反向算术运算符的符号名就是普通运算符加上r(reverse)

比较算术运算符的重载:
方法名                  运算符和表达式      说明
__lt__(self,rhs)       self < rhs        小于
__le__(self,rhs)       self <= rhs       小于等于
__gt__(self,rhs)       self > rhs        大于
__ge__(self,rhs)       self >= rhs       大于等于
__eq__(self,rhs)       self == rhs       等于
__ne__(self,rhs)       self != rhs       不等于

一元运算符的重载
方法名              运算符和表达式        说明
__neg__(self)         - self           负号
__pos__(self)         + self           正号
__invert__(self)      ~ self           取反

例：　　　　以分数类为例对运算符进行重载。
class Fraction:  # 分数类
    def __init__(self, num, deno):
        if deno < 0:
            deno = -1 * deno
            num = -1 * num
        h = hcf(num, deno)
        self.num = int(num/h)
        self.deno = int(deno/h)

    def __add__(self, other):  # 加法
        temp_lcm = lcm(self.deno, other.deno)
        num = self.num*(temp_lcm/self.deno)+other.num*(temp_lcm/other.deno)
        deno = temp_lcm
        return Fraction(num, deno)

    def __sub__(self, other):  # 减法
        temp_lcm = lcm(self.deno, other.deno)
        num = self.num * (temp_lcm / self.deno) - other.num * (temp_lcm / other.deno)
        deno = temp_lcm
        return Fraction(num, deno)

    def __mul__(self, other):  # 乘法
        return Fraction(self.num*other.num, self.deno*other.deno)

    def __truediv__(self, other):  # 除法
        return Fraction(self.num*other.deno, self.deno*other.num)

    def __rtruediv__(self, lhs):  # 反向运算符重载
        return Fraction(lhs*self.deno, self.num)

    def reverse(self):  # 取倒数
        return Fraction(self.deno, self.num)

    def prtfloat(self):  # 以浮点数形式输出
        print(format(self.num/self.deno, ‘.1f‘))

    def prt(self):  # 以分数形式输出
        print(‘{}/{}‘.format(self.num, self.deno))

参考链接：

①https://blog.csdn.net/zhangshuaijun123/article/details/82149056