Python

__add__

定义加号的操作，即当使用+操作时，将会触发__add__()方法。举个栗子：

class Student(object):
def __init__(self, name, age):
self.name = name
self.age = age
def __add__(self, other):
print("__add__", self.age, other.age)
return self.age + other.age
s1 = Student("laowang", 18)
s2 = Student("laozhang", 20)
print(s1 + s2)
############## 打印结果如下 ##############
__add__ 18 20
38

__radd__

__radd__()与__add__()方法一样，都是定义加号的操作时才会触发！但是__add__()方法的“优先级较高”，比如说x + y，x与y是两个类的不同的实例，如果x未重写__add__()方法，那么将会调用y的__radd__()方法。举个栗子：

class Student(object):
def __init__(self, name, age):
self.name = name
self.age = age
def __radd__(self, other):
print("student __radd__", self.age, other.age)
return self.age + other.age
class Teacher(object):
def __init__(self, name, age):
self.name = name
self.age = age
def __radd__(self, other):
print("teacher __radd__", self.age, other.age)
return self.age + other.age
s = Student("laozhang", 18)
t = Teacher("laowang", 20)
print(s + t)
print(t + s)
############## 打印结果如下 ##############
teacher __radd__ 20 18
38
student __radd__ 18 20
38

值得注意的是，所有的二元运算符都有右侧重载方法(例如，__radd__、__rsub__等)，只有满足以下两种条件时，才会触发：

• 两个操作数类型不同
• 左侧操作方法没有重写

举个栗子：

class Student(object):
def __init__(self, name, age):
self.name = name
self.age = age
def __radd__(self, other):
print("student __radd__", self.age, other.age)
return self.age + other.age
s1 = Student("laowang", 18)
s2 = Student("laozhang", 20)
print(s1 + s2)
############## 打印结果如下 ##############
Traceback (most recent call last):
...
TypeError: unsupported operand type(s) for +: 'Student' and 'Student'

s1与s2属于同一个类型的实例，并且左侧操作方法没有重写，所以是不允许的！

__sub__

定义减号的操作，即当使用-操作时，将会触发__sub__()方法。举个栗子：

class Student(object):
def __init__(self, name, age):
self.name = name
self.age = age
def __sub__(self, other):
print("__sub__", self.age, other.age)
return self.age - other.age
s1 = Student("laowang", 18)
s2 = Student("laozhang", 20)
print(s1 - s2)
############## 打印结果如下 ##############
__sub__ 18 20
-2

__rsub__

__sub__()的右侧重载方法

__mul__

定义乘号的操作，即当使用*操作时，将会触发__mul__()方法。举个栗子：

class Student(object):
def __init__(self, name, age):
self.name = name
self.age = age
def __mul__(self, other):
print("__mul__", self.age, other.age)
return self.age * other.age
s1 = Student("laowang", 3)
s2 = Student("laozhang", 6)
print(s1 * s2)
############## 打印结果如下 ##############
__mul__ 3 6
18

__rmul__

__mul__()的右侧重载方法

__truediv__

定义除号的操作，即当使用/操作时，将会触发__truediv__()方法。举个栗子：

class Student(object):
def __init__(self, name, age):
self.name = name
self.age = age
def __truediv__(self, other):
print("__truediv__", self.age, other.age)
return self.age / other.age
s1 = Student("laowang", 3)
s2 = Student("laozhang", 6)
print(s1 / s2)
############## 打印结果如下 ##############
__truediv__ 3 6
0.5

__rtruediv__

__truediv__()的右侧重载方法

__floordiv__

定义整数除法的操作，即当使用//操作时，将会触发__floordiv__()方法。举个栗子：

class Student(object):
def __init__(self, name, age):
self.name = name
self.age = age
def __floordiv__(self, other):
print("__floordiv__", self.age, other.age)
return self.age // other.age
s1 = Student("laowang", 3)
s2 = Student("laozhang", 6)
print(s1 // s2)
############## 打印结果如下 ##############
__floordiv__ 3 6
0

__rfloordiv__

__floordiv__()的右侧重载方法

__mod__

定义取模的操作，即当使用%操作时，将会触发__mod__()方法。举个栗子：

class Student(object):
def __init__(self, name, age):
self.name = name
self.age = age
def __mod__(self, other):
print("__mod__", self.age, other.age)
return self.age % other.age
s1 = Student("laowang", 3)
s2 = Student("laozhang", 6)
print(s1 % s2)
############## 打印结果如下 ##############
__mod__ 3 6
3

__rmod__

__mod__()的右侧重载方法

__divmod__

当divmod()函数被调用时，将会触发__divmod__()方法。举个栗子：

class Student():
def __init__(self, name, age):
self.name = name
self.age = age
def __divmod__(self, other):
print("__divmod__", self.age, other.age)
return self.age // other.age, self.age - (self.age // other.age) * other.age
s1 = Student("laowang", 3)
s2 = Student("laozhang", 6)
print(divmod(s1, s2))
############## 打印结果如下 ##############
__divmod__ 3 6
(0, 3)

__rdivmod__

__divmod__()的右侧重载方法

__pow__

当pow()函数被调用，或使用幂运算**时，将会触发__pow__()方法。举个栗子：

class Student(int):
def __pow__(self, power, modulo=None):
print("__pow__", self, power, modulo)
return 0
s1 = Student(3)
s2 = Student(2)
print(pow(s1, s2))
print(s1 ** s2)
############## 打印结果如下 ##############
__pow__ 3 2 None
0
__pow__ 3 2 None
0

__rpow__

__pow__()的右侧重载方法

__lshift__

定义左位移的操作时，即当使用<<操作时，将会触发__lshift__()方法。

__rlshift__

__lshift__()的右侧重载方法

__rshift__

定义右位移的操作时，即当使用>>操作时，将会触发__rshift__()方法。

__rrshift__

__rshift__()的右侧重载方法

__and__

定义按位与的操作时，即当使用&操作时，将会触发__and__()方法。

__or__

定义按位或的操作时，即当使用|操作时，将会触发__or__()方法。

__ror__

__or__()的右侧重载方法

__xor__

定义按位异或的操作时，即当使用^操作时，将会触发__xor__()方法。

__rxor__

__xor__()的右侧重载方法

__iadd__

定义赋值加法的操作，即当使用+=操作时，将会触发__iadd__()方法。举个栗子：

class Student(int):
def __iadd__(self, other):
print("__iadd__", self, other)
return self + other
s1 = Student(1)
s2 = Student(2)
s1 += s2
############## 打印结果如下 ##############
__iadd__ 1 2

__isub__

定义赋值减法的操作，即当使用-=操作时，将会触发__isub__()方法。举个栗子：

class Student(int):
def __isub__(self, other):
print("__isub__", self, other)
return self + other
s1 = Student(1)
s2 = Student(2)
s1 -= s2
############## 打印结果如下 ##############
__isub__ 1 2

__imul__

定义赋值乘法的操作，即当使用*=操作时，将会触发__imul__()方法。举个栗子：

class Student(int):
def __imul__(self, other):
print("__imul__", self, other)
return self * other
s1 = Student(3)
s2 = Student(2)
s1 *= s2
############## 打印结果如下 ##############
__imul__ 3 2

__itruediv__

定义赋值除法的操作，即当使用/=操作时，将会触发__itruediv__()方法。举个栗子：

class Student(int):
def __itruediv__(self, other):
print("__itruediv__", self, other)
return self / other
s1 = Student(4)
s2 = Student(2)
s1 /= s2
############## 打印结果如下 ##############
__itruediv__ 4 2

__ifloordiv__

定义赋值整数除法的操作，即当使用//=操作时，将会触发__ifloordiv__()方法。举个栗子：

class Student(int):
def __ifloordiv__(self, other):
print("__ifloordiv__", self, other)
return self // other
s1 = Student(4)
s2 = Student(2)
s1 //= s2
############## 打印结果如下 ##############
__ifloordiv__ 4 2

__imod__

定义赋值取模的操作，即当使用%=操作时，将会触发__imod__()方法。举个栗子：

class Student(int):
def __imod__(self, other):
print("__imod__", self, other)
return self % other
s1 = Student(3)
s2 = Student(4)
s1 %= s2
############## 打印结果如下 ##############
__imod__ 3 4

__ipow__

定义赋值幂运算的操作，即当使用**=操作时，将会触发__ipow__()方法。举个栗子：

class Student(int):
def __ipow__(self, other):
print("__ipow__", self, other)
return 0
s1 = Student(3)
s2 = Student(2)
s1 **= s2
############## 打印结果如下 ##############
__ipow__ 3 2

__ilshift__

定义赋值左位移的操作，即当使用<<=操作时，将会触发__ilshift__()方法。

__irshift__

定义赋值右位移的操作，即当使用>>=操作时，将会触发__rshift__()方法。

__iand__

定义赋值按位与的操作，即当使用&=操作时，将会触发__iand__()方法。

__ior__

定义赋值按位或的操作，即当使用|=操作时，将会触发__ior__()方法。

__ixor__

定义赋值按位异或的操作，即当使用^=操作时，将会触发__ixor__()方法。

__neg__

定义使用负号的操作，即当使用-操作时，将会触发__neg__()方法。举个栗子：

class Student(int):
def __neg__(self):
print("__neg__")
return 0
s = Student(3)
print(-s)
############## 打印结果如下 ##############
__neg__
0

__pos__

定义使用正号的操作，即当使用+操作时，将会触发__pos__()方法。举个栗子：

class Student(int):
def __pos__(self):
print("__pos__")
return 0
s = Student(3)
print(+s)
############## 打印结果如下 ##############
__pos__
0

值得注意的是，当我们使用双负号操作即--时，虽然我们常说负负得正，但是最终触发的是__neg__()方法。如下：

class Student(int):
def __neg__(self):
print("__neg__")
return 0
def __pos__(self):
print("__pos__")
return 0
s = Student(2)
print(--s)
############## 打印结果如下 ##############
__neg__
0

__abs__

当我们使用绝对值操作，即调用abs()函数时，将会触发__abs__()方法。举个栗子：

class Student(int):
def __abs__(self):
print("__abs__")
return 0
s = Student(3)
print(abs(s))
############## 打印结果如下 ##############
__abs__
0

invert

当我们使用取反运算(所谓取反运算就是将每个二进制位取反，即将1变为0，将0变为1)时，即使用~操作的时候，将会触发__invert__()方法。举个栗子：

class Student(int):
def __invert__(self):
print("__invert__")
return 0
s = Student(3)
print(~s)
############## 打印结果如下 ##############
__invert__
0

__complex__

当调用complex()函数时，将会触发__complex__()方法。

__int__

当调用int()函数时，将会触发__int__()方法。举个栗子：

class Student(str):
def __int__(self):
print("__int__")
return 0
s = Student("3")
print(int(s))
############## 打印结果如下 ##############
__int__
0

值得注意的是，重写了该方法后需返回一个对应类型的值！

__float__

当调用float()函数时，将会触发__float__()方法。举个栗子：

class Student(str):
def __float__(self):
print("__float__")
return 0.1
s = Student("3")
print(float(s))
############## 打印结果如下 ##############
__float__
0.1

值得注意的是，重写了该方法后需返回一个对应类型的值！

__round__

当调用round()函数时，将会触发__round__()方法。举个栗子：

class Student(float):
def __round__(self, n=None):
print("__round__", n)
return 0.1
s = Student(0.035)
print(round(s))
print(round(s, 2))
############## 打印结果如下 ##############
__round__ None
0.1
__round__ 2
0.1

__index__

当对象用于切片的下标时，将会触发对象的__index__()方法。举个栗子：

class Student(float):
num = 1
def __index__(self):
print("__index__")
return self.num
l = [1, 2, 3, 4]
s = Student(3.33)
print(l[:s])
############## 打印结果如下 ##############
__index__
[1]

值得注意的是，__index__()方法必须返回的是一个整形数据！

__enter__

当使用with操作的时候，将会触发__enter__()方法，表示进入一段代码块，as紧挨着的变量为__enter__()方法返回的值。举个栗子：

class Student(object):
def __enter__(self):
print("__enter__")
def __exit__(self, exc_type, exc_val, exc_tb):
print("__exit__")
with Student() as s:
print(s)
############## 打印结果如下 ##############
__enter__
None
__exit__

我们修改一下上面的代码，使__enter__()方法返回当前对象，如下：

class Student(object):
def __enter__(self):
print("__enter__")
return self
def __exit__(self, exc_type, exc_val, exc_tb):
print("__exit__")
with Student() as s:
print(s)
############## 打印结果如下 ##############
__enter__
<__main__.Student object at 0x109d9b588>
__exit__

值得注意的是，如果你重写了__enter__()方法，那么就一定要重写__exit__()方法，它们俩是成双成对出现的！

__exit__

当一段代码块执行完毕时，将会触发__exit__()方法，通常用于处理对代码块的收尾工作！举个栗子：

class MyFile(object):
def __enter__(self):
print("__enter__")
self.f = open("my_file.txt", "w")
return self.f
def __exit__(self, exc_type, exc_val, exc_tb):
print("__exit__")
self.f.close()
with MyFile() as mf:
mf.write("hhhhh")
############## 打印结果如下 ##############
__enter__
__exit__

__getitem__

当获取一个容器元素的操作时，将会触发__getitem__()方法。举个栗子：

class Student(list):
def __getitem__(self, item):
print("__getitem__", self, item)
return item
s = Student([1, 2, 3, 4])
print(s[0])
############## 打印结果如下 ##############
__getitem__ [1, 2, 3, 4] 0
0

__setitem__

当修改容器元素的值时，将会触发__setitem__()方法。举个栗子：

class Student(list):
def __setitem__(self, key, value):
print("__setitem__", self, key, value)
s = Student([1, 2, 3, 4])
s[0] = 11
############## 打印结果如下 ##############
__setitem__ [1, 2, 3, 4] 0 11

__delitem__

当删除容器元素时，将会触发__delitem__()方法。举个栗子：

class Student(list):
def __delitem__(self, key):
print("__delitem__", self, key)
s = Student([1, 2, 3, 4])
del s[0]
############## 打印结果如下 ##############
__delitem__ [1, 2, 3, 4] 0

__iter__

当迭代容器元素时，将会触发__iter__()方法。举个栗子：

class Student(list):
def __iter__(self):
print("__iter__")
return super(Student, self).__iter__()
s = Student([1, 2, 3, 4])
for i in s:
print(i)
############## 打印结果如下 ##############
__iter__
1
2
3
4

__reversed__

当调用reversed()函数时，将会触发__reversed__()方法。举个栗子：

class Student(list):
def __reversed__(self):
print("__reversed__")
return super(Student, self).__reversed__()
s = Student([1, 2, 3, 4])
reversed(s)
############## 打印结果如下 ##############
__reversed__

__contains__

当使用in来判断元素是否存在于容器中的操作时，将会触发__contains__()方法。举个栗子：

class Student(list):
def __contains__(self, item):
print("__contains__", self, item)
return super(Student, self).__contains__(item)
s = Student([1, 2, 3, 4])
print(1 in s)
############## 打印结果如下 ##############
__contains__ [1, 2, 3, 4] 1
True

至此Over~~~~