迭代器

迭代器

可迭代对象：

list, str, tuple, etc. ---->for … in … 遍历 —> 遍历(迭代)

迭代器协议：对象必须提供一个next方法，执行该方法要么返回迭代中的下一项，要么引起StepIeration异常，以终止迭代(只能往下走，不可以回退)

现在 ，我们就可以说，实现了迭代器协议的对象就是可迭代对象。

如何实现

• 通过在对象内部定义一个__iter__方法

li = [1, 2, 3]
sr = 'abc'
li_iter = li.__iter__()   #首先转换为迭代器
print(li_iter.__next__()) #迭代取值
print(li_iter.__next__())
print(li_iter.__next__())
# print(li_iter.__next__())    #一级迭代完了 继续next会报错
sr_iter = sr.__iter__()
print(sr_iter.__next__())
print(next(sr_iter))
print(sr_iter.__next__())

1
2
3
a
b
c

for i in 100:
    print(i)  #报错
#不可迭代

可迭代对象测试

使用isinstance()来判断一个对象是否可迭代

collections 导入 Iterable

from collections import Iterable   #使用isinstance()来判断一个对象是否可迭代
print(isinstance([], Iterable))
print(isinstance((), Iterable))
print(isinstance({}, Iterable))
print(isinstance(set(), Iterable))
print(isinstance(123, Iterable))
print(isinstance(True, Iterable))
True
True
True
True
False
False

测试：自定义一个类，其可以容纳数据，测试该类的可迭代性

from collections import  Iterable
class It:
    def __init__(self):
        self.name = []
    def __add__(self, other):
        self.name.append(other)

it = It()
it.__add__('Tom')
it.__add__('Jack')
it.__add__('Alice')
print('是否为可迭代对象:', isinstance(it, Iterable))   #False
print(type(it))           #<class '__main__.It'>
for i in it: #   报错 不可迭代
    print(i, end=' ')

内部定义一个__iter__方法，提供一个迭代器

在迭代一个可迭代对象的时候，实际上就是获取该对象提供的一个迭代器。然后通过该迭代器一次获取对象的每一个数据。

#加入     def __iter__(self):
        return self.name.__iter__()
#加入迭代器

通过for 循环迭代，

print('是否为可迭代对象:', isinstance(it, Iterable))   #True
for i in it:             #Tom Jack Alice 
    print(i, end=' ')  

通过迭代器,迭代

a = it.__iter__()
print(next(a))   # Tom
print(next(a))   # Jack
print(next(a))   # Alice

for … in …循环的本质：就是i通过iter()函数获取可迭代对象的Iterable的迭代器，然后获取到的迭代器不断调用Next（）方法来获取下一个值并赋值给item，当遇到StopIteration的异常后，退出。

class test:
    def __init__(self, data=1):
        self.dara = data
    def __iter__(self):
        return self
    def __next__(self):
        if self.dara > 5:
            raise StopIteration
        else:
            self.dara += 1
            return self.dara
for i in test(2):
    print(i)

应用场景

迭代器的核心就是通过next()函数调用返回下一个数据值。如果每次返回的数据值不是在一个已有的数据集合中读取的，而是通过程序按照一定规律计算生成。那么也就意味着可以不用依赖一个已有的数据集合，namely。无需将所有的迭代对象数据一次性缓存下来供后续使用。这样，可以 节省大量存储空间。

demo:

斐波那契数列

现在我们希望通过for in的方式来遍历斐波那契数列中的前n个数。

通过迭代来实现，每次迭代都可以通过数学计算来生成下一个数据。

#两个初始值
#n ，不大于n的类似索引的值
class Fib:
    '''斐波那契数列迭代器'''
    def __init__(self, n):
        #记录生成的斐波那契数列的个数
        self.n = n
        #记录当前记录的索引
        self.current_index = 0
        #记录两个初始值
        self.num1 = 0
        self.num2 = 1
        self.name = []
    def __next__(self):
        '''调用next()函数获取下一个数'''
        if self.current_index < self.n:
            num = self.num1
            self.num1, self.num2 = self.num2, self.num1+self.num2
            self.current_index += 1
            self.name.append(num)
            return num
        else:
            raise StopIteration

    def __iter__(self):
        return self
fib = Fib(10)
for num in fib:
    print(num, end=' ')
a = fib.__iter__()
print(next(a))
print(next(a))
print(next(a))