python 重载

重载是面向对象的一个重要概念，在很多程序实现中都会用到。最常见的是运算重载，比如+、-、x、÷等。python可以重载的方法一共有118个，有些是常用的，有些是不常用的。本文总结了所有的重载方法并提供实现实例以及说明供大家参考。为了便于阅读，本文分为常用的重载方法、其余重载方法以及重载方法列表。

一、重载的概念

重载的概念及时重新编写python类中的方法，以实现特定的算法或者处理。比如自定义的类的相加。

二、常用的重载方法

1. 运算符号

python支持运算符如下：

运算类型	对象在左侧	对象在右侧	复合赋值
加法	__add__	__radd__	__iadd__
减法	__sub__	__rsub__	__isub__
乘法	__mul__	__rmul__	__imul__
除法	__truediv__	__rdiv__	__idiv__
求余	__mod__	__rmod__	__imod_

运算符+

代码如下：

```python
class op(object):
    def __init__(self,x=0,y=0):
        self.x = x
        self.y = y

    def __str__(self): #重载__str__
        return ("x={} y={}".format(self.x,self.y))

    def __add__(self,other):
        print("对象在左侧")
        return op(self.x+other.x,self.y+other.y)

    def __radd__(self,other):
        print("对象在右侧")
        return op(self.x + other[0], self.y + other[1])

    def __iadd__(self, other):
        print("+=运算")
        self.x += other.x
        self.y += other.y
        return self

a = op(10,2)
c = a + op(5,9)
print("左侧:",c) #10+5,2+9
c = [1,2]+a
print("右侧",c) #1+10,2+2
c += a 
print("+=",c) #11+10,4+2

结果如下：

对象在左侧
左侧: x=15 y=11
对象在右侧
右侧 x=11 y=4
+=运算
+= x=21 y=6

不仅可以编写里2个对象的相加，也可以通过重载编写对象与数组，数字等方式的相加。不过这一点python不如C++方便。比如上面的例子中定义了对象+对象，就不能定义对象+数组。在右侧相加的方法中，定义了数组+对象。二者之间是有区别的。
其他的-、x、÷运算可以参考运算符+。
此外还有其他的运算，比如divmod(a//b,a%b)。
下面的示例是divmod

import math

class v(object):
    def __init__(self,x=0.,y=0.):
        self.x = x
        self.y = y

        self.xmod = None
        self.ymod = None
    def __divmod__(self, other):
        return divmod(self.x,other.x),divmod(self.y,other.y)

x,y = divmod(v(100,200),v(20,30))
print(x,y)

结果：

(5, 0) (6, 20)

2. 位运算

python对象的位运算有：&、|、^、~、>>、<<，含义如下：

位运算	含义	示例	方法
&	按位与	4&2=0	__and__
|	按位或	4&2=6	__or__
^	按位异或	3^2=1	__xor__
~	按位取反	~2=-3	__invert__
>>	右移	8>>1=4	__rshift__
<<	左移	8<<1=16	__lshift__

位运算符也有赋值位运算，|=、&=、^=、>>=、<<=

#coding:utf8

class v(object):
    def __init__(self,x=0,y=0):
        self.x = x
        self.y = y

    def __or__(self, other):
        return v(self.x|other.x,self.y|other.y)

    def __and__(self,other):
        return v(self.x&other.x,self.y&other.y)

    def __ior__(self, other):
        print("ior",end=" ")
        self.x |= other.x
        self.y |= other.y
        return self

    def __iand__(self, other):
        print("iand",end=" ")
        self.x &= other.x
        self.y &= other.y
        return self

    def __xor__(self, other):
        return v(self.x^other.x,self.y^other.y)

    def __ixor__(self, other):
        print("ixor",end=" ")
        self.x ^= other.x
        self.y ^= other.y
        return self

    def __invert__(self