Python中实现运算符重载机制，涉及在类定义中定义特定的方法——这些方法会在实例调用内置操作时被自动触发，随后系统将执行这些方法并输出相应的操作结果。
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中，当运用减法运算符时kaiyun全站网页版登录，系统会自动触发实例的sub()函数。
>>> class MyNumber:
def __init__(self,begin):
self.data=begin
定义一个方法用于拦截减法运算符（减号）的执行
返回(self.data减去other)的结果
>>> n1=MyNumber(5)
>>> n2=n1-3
>>> n2.data
21.4 getitem和setitem
在Python中，当通过索引或分片方式访问实例以获取数据时，系统会自动执行实例的getitem()函数。
设置值时，会自动调用__setitem方法；
迭代环境会自动调用getitem()方法；
>>> class MyIndex:
在索引操作中，当需要通过索引获取值时，会自动调用此方法。
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]
在实现分片操作以获取数据时，该方法会被触发执行，用于处理索引参数。
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={}
当使用索引操作符[]对对象进行赋值时，将触发此方法__setitem__的执行。
self.changed[key]=value
def __getitem__(self,key):
return self.changed[key]
>>> ms=MySetitem()
ms['s'] 被设定为“梯阅线条”。
>>> ms['s']
'梯阅线条'
>>> class MyStep:
在for循环迭代过程中，该方法被调用以获取指定索引的元素。
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操作，产出迭代器实体开yun体育app官网网页登录入口，随后通过调用next函数进行访问。
1.5.1 单迭代器对象
iter()方法能够返回实例对象自身，这构成了一个单独的迭代器对象。它可以应用于生成器函数、表达式、map函数以及zip函数等。
>>> class MyIter:
初始化时需传入起始值和终止值。
self.value=start-1
self.stop=stop
# 可迭代迭代对象拥有__iter__方法，返回迭代器对象
def __iter__(self):
return 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)
通过使用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)
回溯至（最近一次调用）结束：
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
定义一个名为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()函数能够生成一个新的迭代器实体，适用于多种类型的迭代器云开·全站体育app登录，例如range函数、列表等。
class MySkipIterator:
def __init__(self,wrapped):
self.wrapped=wrapped
self.offset=0
# 迭代器对象拥有__next__方法
def __next__(self):
输出“__next__”以表明__next__函数已被执行调用。
若self.offset的值已超出self.wrapped的长度范围。
输出“迭代停止”信息。
raise StopIteration
else:
该元素等于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、列表等
输出“__iter__”，以此表明__iter__函数已被执行。
返回 MySkipIterator(self.wrapped) 实例
若当前模块名等于主模块标识符：
s1='abcdef'
mso=MySkipObject(s1)
i=iter(mso)
输出下一个索引对应的值，紧接着输出下一个索引对应的值，然后再次输出下一个索引对应的值。
输出：“================”
在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目录下，运行名为"新文件 1.py"的Python脚本程序。
__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
'''
