这篇文章主要介绍了Python运算符重载详解及实例代码的相关资料,需要的朋友可以参考下
Python运算符重载
Python语言提供了运算符重载功能，增强了语言的灵活性，这一点与C++有点类似又有些不同。鉴于它的特殊性，今天就来讨论一下Python运算符重载。
Python语言本身提供了很多魔法方法，它的运算符重载就是通过重写这些Python内置魔法方法实现的。这些魔法方法都是以双下划线开头和结尾的，类似于X的形式，python通过这种特殊的命名方式来拦截操作符，以实现重载。当Python的内置操作运用于类对象时，Python会去搜索并调用对象中指定的方法完成操作。
类可以重载加减运算、打印、函数调用、索引等内置运算，运算符重载使我们的对象的行为与内置对象的一样。Python在调用操作符时会自动调用这样的方法，例如，如果类实现了add方法，当类的对象出现在+运算符中时会调用这个方法。
常见运算符重载方法方法名重载说明运算符调用方式
init构造函数对象创建: X = Class(args)
del析构函数X对象收回
add/sub加减运算X+Y， X+=Y/X-Y， X-=Y
or运算符|X|Y, X|=Y
_repr／str打印／转换print(X)、repr(X)／str(X)
call函数调用X(*args, **kwargs)
getattr属性引用X.undefined
setattr属性赋值X.any=value
delattr属性删除del X.any
getattribute属性获取X.any
getitem索引运算X[key]，X[i:j]
setitem索引赋值X[key]，X[i:j]=sequence
delitem索引和分片删除del X[key]，del X[i:j]
len长度len(X)
bool布尔测试bool(X)
lt, gt,
le, ge,
eq, ne特定的比较依次为XY，X<=Y，X>=Y，
X==Y，X!=Y
注释：
(lt: less than, gt: greater than,
le: less equal, ge: greater equal,
eq: equal, ne: not equal
)radd右侧加法other+X
iadd实地(增强的)加法X+=Y(or else add)
iter, next迭代I=iter(X), next()
contains成员关系测试item in X(X为任何可迭代对象)
index整数值hex(X), bin(X), oct(X)
enter, exit环境管理器with obj as var:
get, set,
delete描述符属性X.attr, X.attr=value, del X.attr
new创建在init之前创建对象
下面对常用的运算符方法的使用进行一下介绍。
构造函数和析构函数：init和del
它们的主要作用是进行对象的创建和回收，当实例创建时，就会调用init构造方法。当实例对象被收回时，析构函数del会自动执行。>>> class Human():
... def init(self, n):
... self.name = n
... print("init ",self.name)
... def del(self):
... print("del")
...
>>> h = Human('Tim')
init Tim
>>> h = 'a'
del加减运算：add和sub
重载这两个方法就可以在普通的对象上添加＋－运算符操作。下面的代码演示了如何使用＋－运算符，如果将代码中的sub方法去掉，再调用减号运算符就会出错。
>>> class Computation():
... def init(self,value):
... self.value = value
... def add(self,other):
... return self.value + other
... def sub(self,other):
... return self.value - other
...
>>> c = Computation(5)
>>> c + 5
10
>>> c - 3
2对象的字符串表达形式：repr和str
这两个方法都是用来表示对象的字符串表达形式：print()、str()方法会调用到str方法，print()、str()和repr()方法会调用repr方法。从下面的例子可以看出，当两个方法同时定义时，Python会优先搜索并调用str方法。
>>> class Str(object):
... def str(self):
... return "str called"
... def repr(self):
... return "repr called"
...
>>> s = Str()
>>> print(s)
str called
>>> repr(s)
'repr called'
>>> str(s)
'str called'索引取值和赋值：getitem, setitem
通过实现这两个方法，可以通过诸如 X[i] 的形式对对象进行取值和赋值，还可以对对象使用切片操作。
>>> class Indexer:
data = [1,2,3,4,5,6]
def getitem(self,index):
return self.data[index]
def setitem(self,k,v):
self.data[k] = v
print(self.data)
>>> i = Indexer()
>>> i[0]
1
>>> i[1:4]
[2, 3, 4]
>>> i[0]=10
[10, 2, 3, 4, 5, 6]设置和访问属性：getattr、setattr
我们可以通过重载getattr和setattr来拦截对对象成员的访问。getattr在访问对象中不存在的成员时会自动调用。setattr方法用于在初始化对象成员的时候调用，即在设置dict的item时就会调用setattr方法。具体例子如下：
class A():
def init(self,ax,bx):
self.a = ax
self.b = bx
def f(self):
print (self.dict)
def getattr(self,name):
print ("getattr")
def setattr(self,name,value):
print ("setattr")
self.dict[name] = value
a = A(1,2)
a.f()
a.x
a.x = 3
a.f()上面代码的运行结果如下，从结果可以看出，访问不存在的变量x时会调用getattr方法；当init被调用的时候，赋值运算也会调用setattr方法。
setattr
setattr
{'a': 1, 'b': 2}
getattr
setattr
{'a': 1, 'x': 3, 'b': 2}迭代器对象: iter, next
Python中的迭代，可以直接通过重载getitem方法来实现，看下面的例子。
>>> class Indexer:
... data = [1,2,3,4,5,6]
... def getitem(self,index):
... return self.data[index]
...
>>> x = Indexer()
>>> for item in x:
... print(item)
...
1
2
3
4
5
6通过上面的方法是可以实现迭代，但并不是最好的方式。Python的迭代操作会优先尝试调用iter方法，再尝试getitem。迭代环境是通过iter去尝试寻找iter方法来实现，而这种方法返回一个迭代器对象。如果这个方法已经提供，Python会重复调用迭代器对象的next()方法，直到发生StopIteration异常。如果没有找到iter，Python才会尝试使用getitem机制。下面看一下迭代器的例子。
class Next(object):
def init(self, data=1):
self.data = data
def iter(self):
return self
def next(self):
print("next called")
if self.data > 5:
raise StopIteration
else:
self.data += 1
return self.data
for i in Next(3):
print(i)
print("-----------")
n = Next(3)
i = iter(n)
while True:
try:
print(next(i))
except Exception as e:
break
程序的运行结果如下：next called
4
next called
5
next called
6
next called
-----------
next called
4
next called
5
next called
6
next called可见实现了iter和next方法后，可以通过for in的方式迭代遍历对象，也可以通过iter()和next()方法迭代遍历对象。
