python运算符重载是在类方法中拦截内置操作-当类的实例使用内置操作时，pytho自动调用对应方法，并且返回操作结果。

1.1 常见运算符重载

1.2 init

python类调用小括号()创建实例时，会自动调用实例的构造函数init()。

 >>> class A:
     def __init__(self):
         print('A.__init__')
 
         
 >>> class B(A):
     def __init__(self):
         print('B.__init__')
 
         
 >>> class C(A):pass
 
 >>> a=A()
 A.__init__
 # 子类和父类有init，自动调用子类init
 >>> b=B()
 B.__init__
 # 子类无init，自动调用父类init
 >>> c=C()
 A.__init__

1.3 sub

python实例使用减法-表达式，会自动调用实例的sub()方法。

 >>> class MyNumber:
     def __init__(self,begin):
         self.data=begin
     def __sub__(self,other):# 拦截减法(-)表达式
         return MyNumber(self.data-other)
 
     
 >>> n1=MyNumber(5)
 >>> n2=n1-3
 >>> n2.data
 2

1.4 getitem和setitem

python实例使用索引和分片获取值时，会自动调用实例的getitem()方法；

设置值时，会自动调用__setitem方法；

迭代环境会自动调用getitem()方法；

 >>> class MyIndex:
     def __getitem__(self,index):# []索引获取值时调用getitem
         return index*2
 >>> mi=MyIndex()
 >>> mi[2]
 4
 >>> for i in range(5):
     print(mi[i],end=' ')
 0 2 4 6 8 
 >>> class MySlice:
     data=[9,7,5,2,6,8]
     def __getitem__(self,index):# [:]分片获取值时调用getitem
         print('索引:',index)
         return self.data[index]
 
     
 >>> ms=MySlice()
 >>> ms[0]
 索引: 0
 9
 >>> ms[1]
 索引: 1
 7
 >>> ms[-1]
 索引: -1
 8
 >>> ms[3:6]
 索引: slice(3, 6, None)
 [2, 6, 8]
 >>> ms[1:]
 索引: slice(1, None, None)
 [7, 5, 2, 6, 8]
 >>> ms[:-1]
 索引: slice(None, -1, None)
 [9, 7, 5, 2, 6]
 >>> ms[::2]
 索引: slice(None, None, 2)
 [9, 5, 6]
 
 >>> class MySetitem:
     def __init__(self):
         self.changed={}
     def __setitem__(self,key,value):# 索引[]设置值时调用setitem
         self.changed[key]=value
     def __getitem__(self,key):
         return self.changed[key]
 >>> ms=MySetitem()
 >>> ms['s']='梯阅线条'
 >>> ms['s']
 '梯阅线条'
 
 >>> class MyStep:
     def __getitem__(self,i):# for循环迭代时调用getitem
         print(i,end = ' ')
         return self.data[i]
 >>> ms=MyStep()
 >>> ms.data='梯阅线条'
 >>> ms[0]
 0 '梯'
 >>> for item in ms:
     print(item,end=' ')
 0 梯 1 阅 2 线 3 条 4 

1.5 iter和next

python迭代环境先调用iter()方法，不存在时再调用getitem()方法进行索引操作。

iter()方法返回迭代对象，迭代对象循环调用next()方法，直到发生StopIteration异常。

迭代环境循环调用getitem()方法，直到发生IndexError异常。

迭代器对象：具有next方法的对象；

可迭代对象：具有iter方法的对象；

可迭代对象调用iter方法，返回迭代器对象，再调用next方法；

1.5.1 单迭代器对象

iter()方法返回实例对象本身，为单迭代器对象，生成器函数和表达式、map、zip等；

 >>> class MyIter:
     def __init__(self,start,stop):
         self.value=start-1
         self.stop=stop
     # 可迭代迭代对象拥有__iter__方法，返回迭代器对象    
     def __iter__(self):
         return self
     def __next__(self):# 迭代器对象拥有__next__方法
         if self.value==self.stop:
             raise StopIteration
         self.value+=1
         return self.value*2
 
 >>> for i in MyIter(1,5):
     # for迭代环境循环调用迭代器对象的next方法
     print(i,end=' ')
 2 4 6 8 10 
 >>> mi=MyIter(1,5)
 >>> i=iter(mi)#等效于mi.__iter__()
 >>> i
 <__main__.myiter object at 0x01269a50>
 # 等效于 i.__next__()
 >>> next(i)
 2
 >>> next(i)
 4
 >>> next(i)
 6
 >>> next(i)
 8
 >>> next(i)
 10
 >>> next(i)
 Traceback (most recent call last):
   File "", line 1, in 
     next(i)
   File "", line 9, in __next__
     raise StopIteration
 StopIteration
 
 
 >>> [i for i in MyIter(1,5)]
 [2, 4, 6, 8, 10]
 >>> [i for i in MyIter(1,5)]
 [2, 4, 6, 8, 10]
 # mi的__iter__()返回实例本身，为单次迭代器
 # 类似的有生成器函数和表达式、map、zip
 >>> mi=MyIter(1,5)
 >>> [i for i in mi]
 [2, 4, 6, 8, 10]
 >>> [i for i in mi]
 []
 >>> mi=MyIter(1,5)
 >>> for x in mi:
     for y in mi:
         print(x+y,end=' ')   
 6 8 10 12 
 >>> def mygenerate(start,stop):
     for i in range(start,stop+1):
         yield i*2
 
 >>> for i in mygenerate(1,5):
     print(i,end=' ')
 
 2 4 6 8 10 

1.5.2 多迭代器对象

iter()方法返回新迭代器对象，为多迭代器对象，比如range、列表等；

 class MySkipIterator:
     def __init__(self,wrapped):
         self.wrapped=wrapped
         self.offset=0
     # 迭代器对象拥有__next__方法
     def __next__(self):
         print('__next__')# 证明 __next__ 被调用
         if self.offset>=len(self.wrapped):
             print('StopIteration')
             raise StopIteration
         else:
             item=self.wrapped[self.offset]
             self.offset+=2
             return item
 class MySkipObject:
     def __init__(self,wrapped):
         self.wrapped=wrapped
     # 可迭代迭代对象拥有__iter__方法，
     # 返回拥有__next__方法的迭代器对象
     def __iter__(self):
         # __iter__返回新的迭代器对象，为多个迭代器对象
         # 类似的有range、列表等
         print('__iter__')# 证明 __iter__ 被调用
         return MySkipIterator(self.wrapped)
         
 if __name__ == '__main__':
     s1='abcdef'
     mso=MySkipObject(s1)
     i=iter(mso)
     print(next(i),next(i),next(i))
     print('================')
     #for循环先调用iter生成迭代器，再一直调用next方法只到报错
     for x in mso:
         print(x,end=' ')
     print('================')
     for x in mso:
         for y in mso:
             print(x+y,end=' ')
 '''
 C:\Users\Administrator\Desktop>python "新文件 1.py"
 __iter__
 __next__
 __next__
 __next__
 a c e
 ================
 __iter__
 __next__
 a __next__
 c __next__
 e __next__
 StopIteration
 ================
 __iter__
 __next__
 __iter__
 __next__
 aa __next__
 ac __next__
 ae __next__
 StopIteration
 __next__
 __iter__
 __next__
 ca __next__
 cc __next__
 ce __next__
 StopIteration
 __next__
 __iter__
 __next__
 ea __next__
 ec __next__
 ee __next__
 StopIteration
 __next__
 StopIteration
 '''

2 END

本文首发微信公众号：梯阅线条，

更多内容参考python知识分享或软件测试开发目录。