#p46456y1 类中 __iter__重载实现同时保有多个独立迭代器

一
关键__iter__中直接返回 实例self 导致其只能同时保有唯一一个 有活性的迭代器 申请新的该对象的迭代变量也路由到唯一一个迭代器上
'''
目的：检验类中 __iter__  可以自定义保持一个活性的迭代器即不能嵌套循环
                                  以及保持多个活性的迭代器的实现
'''

'''
目的：检验类中 __iter__  可以自定义保持一个活性的迭代器即不能嵌套循环
                                  以及保持多个活性的迭代器的实现
'''

class Iterop:
    def __init__(self,value):
        self.data=value
    def __iter__(self):
        self.x=0
        return self
    def __next__(self):
        if self.x==len(self.data):
            return StopIteration
        temp=self.x
        self.x+=1
        return self.data[temp]
if __name__=='__main__':
    a=Iterop([1,2,3,4])
    i1=iter(a)
    i2=iter(a)
    print(next(i1),end=' i1|\n')
    print(next(i2),end=' i2|\n')
    print(next(i1),end=' i1|\n')
    print(next(i2),end=' i2|\n')
    print(next(i1),end=' i1|\n')
    i3=iter(a)
    print(next(i3),end=' i3|\n')
    print(next(i3),end=' i3|\n')
    print(next(i3),end=' i3|\n')
    print(next(i3),end=' i3|\n')

'''
输出：
1 i1|
2 i2|
3 i1|
4 i2|
<class 'StopIteration'> i1|
1 i3|
结论：
1、在同一时间__iter__中返回self的只会维持唯一一个有活性的迭代器  因此不支持嵌套循环
2、在一轮迭代完成后，原申请的唯一迭代器耗尽，再次申请一个新迭代器变量又是一个新的活性迭代器  又可以进行唯一迭代
'''

二

目的：改进类中__iter__函数使其支持同一时间维持多个有活性的独立的迭代器

关键定义一个新的附加累  同时注意初始的计数器变量不能在__next__中出现

'''
目的：改进类中__iter__函数使其支持同一时间维持多个有活性的独立的迭代器
'''
class Iterop:
    def __init__(self,value):
        self.data=value
    def __iter__(self):
        return Iterop1(self.data)
class Iterop1:
    def __init__(self, value):
        self.data = value
        self.x=0
    def __next__(self):
        if self.x==len(self.data):
            return StopIteration
        temp=self.x
        self.x+=1
        return self.data[temp]
if __name__=='__main__':
    a=Iterop([1,2,3,4])
    i1=iter(a)
    i2=iter(a)
    print(next(i1),end=' i1|\n')
    print(next(i2),end=' i2|\n')
    print(next(i1),end=' i1|\n')
    print(next(i2),end=' i2|\n')
    print(next(i1),end=' i1|\n')
    print(next(i1), end=' i1|\n')
    print(next(i2), end=' i2|\n')
    print(next(i1), end=' i1|\n')
    print(next(i2), end=' i2|\n')
    print(next(i2), end=' i2|\n')
    i3=iter(a)
    print(next(i3),end=' i3|\n')
    print(next(i3),end=' i3|\n')
    print(next(i3),end=' i3|\n')
    print(next(i3),end=' i3|\n')
    print(next(i3), end=' i3|\n')

'''
输出：
1 i1|
1 i2|
2 i1|
2 i2|
3 i1|
4 i1|
3 i2|
<class 'StopIteration'> i1|
4 i2|
<class 'StopIteration'> i2|
1 i3|
2 i3|
3 i3|
4 i3|
<class 'StopIteration'> i3|
结论：同时维持多个独立的新活性的迭代器  所以可以对同一对象进行嵌套循环
对于迭代行为  先取对象的迭代器 之后执行其中的__next__方法
'''

三

目的：使用__iter__+yield实现同时 多个独立迭代器保活
优点：代码量少  不用定义两个类   不需要计数变量 不需要定义__next__
yield 相当于免费送一套__next__

 

'''
目的：使用__iter__+yield实现同时 多个独立迭代器保活
优点：代码量少  不用定义两个类   不需要计数变量 不需要定义__next__
yield 相当于免费送一套__next__
'''
class Iterop:
    def __init__(self,value):
        self.data=value
    def __iter__(self):
        for i in self.data:
            yield i

if __name__=='__main__':
   '''
    a=Iterop([1,2,3,4])
    i1=iter(a)
    i2=iter(a)
    print(next(i1),end=' i1|\n')
    print(next(i2),end=' i2|\n')
    print(next(i1),end=' i1|\n')
    print(next(i2),end=' i2|\n')
    print(next(i1),end=' i1|\n')
    print(next(i1), end=' i1|\n')
    print(next(i2), end=' i2|\n')
    print(next(i2), end=' i2|\n')
    i3=iter(a)
    print(next(i3),end=' i3|\n')
    print(next(i3),end=' i3|\n')
    print(next(i3),end=' i3|\n')
    print(next(i3),end=' i3|\n')
'''
   for i in Iterop([1,2,3,4,5]):
       for j in Iterop([6,7,8,9]):
            print("(%d,%d)"%(i,j),end=' |')

'''
输出 ：
(1,6) |(1,7) |(1,8) |(1,9) |(2,6) |(2,7) |(2,8) |(2,9) |(3,6) |(3,7) |(3,8) |(3,9) |(4,6) |(4,7) |(4,8) |(4,9) |(5,6) |(5,7) |(5,8) |(5,9) |
__iter__+yield  成功实现嵌套循环
可以证明同时有多个独立有活性的迭代器存在
'''

此部分与自定义类的迭代操作息息相关  如for   

想要实现多重嵌套循环务必搞懂