Python里的迭代器

迭代器（iterator）协议

·　在Python中，支持迭代器协议就是实现对象的__iter__()和__next__()方法。

　　１．__iter__()方法：返回迭代器对象本身；

2．__next__()方法：返回容器中的下一个元素，在结尾时引发Stoplteration异常终止迭代器。

可迭代对象（iterable）

·  实现了迭代器协议的对象，就是可迭代对象。

·  如何实现迭代器协议：对象内部定义了一个__iter__()方法。

·  在Python中，字符串、tuple、list、dict、set、文件都是可迭代对象。总之能用Python内置函数调用出__iter__()方法的，都是可迭代对象。

如下：

1. # str1='hello'
2. # list1=[1,2,3]
3. # tup1=(1,2,3)
4. # dic={'x':1}
5. # s1={'a','b','c'}
6. # f=open('a.txt','w',encoding='utf-8')

都能用__iter__()调试出来。

迭代器对象

· 迭代器对象：

指的是既内置有__iter__方法，又内置有__next__方法的对象。仅有文件才是迭代器对象
如下：

1. # f=open('db.txt','rt',encoding='utf-8')
2. # print(f.__next__())
3. # print(f.__next__())
4. # print(next(f))

迭代器的缺点

1.迭代器的取值不如按照索引的方式更灵活，因为它只能往后取不能往前退
2.无法预测迭代器值的个数
如下：

1. name=['egon','alex_sb','wxx_sb']
2. res=name.__iter__()
3. print(res.__next__())
4. print(name[0])

迭代器优点

• 对于支持随机访问的数据结构：list、tuple等，迭代器和经典的for循环（索引访问）相比，并无优势，反而失去了索引值。不过可以使用内置函数enumerate（）找回这个索引值。但对于无法随机访问的数据结构：set（），迭代器是唯一的访问元素的方式。
• 省内存：迭代器不需要事先准备好整个迭代过程中的所有元素，仅仅在迭代到某个元素时才计算该元素，而在这之前或之后，元素可以不存在或销毁。这也是迭代器的一大优点：适合用于遍历一个巨大的或无限的集合，比如几个G的文件。下面用斐波那契数列为例： 
  • 代码一直接在fab（max）中用print打印会导致函数的可复用性变差，因此fab返回None。其他函数无法获得fab函数返回的数列；
  • 代码二满足了可复用性的需求，但是占用了内存空间；
  • 代码三Fabs类通过next（）不断返回数列的下一个，内存占用始终为常数。

    #代码一：
    def fab(max):
        L = []
        n, a, b = 0, 0, 1
        while n < max:
            L.append(b)
            a, b = b, a + b
            n = n + 1
        return L
    
    #代码二：
    def fab(max):
        n, a, b = 0, 0, 1
        while n < max:
            print b
            a, b = b, a + b
            n = n + 1
    #代码三：
    class Fab(object):
        def __init__(self, max):
            self.max = max
            self.n, self.a, self.b = 0, 0, 1 
    
        def __iter__(self):
            return self 
    
        def next(self):
            if self.n < self.max:
                r = self.b
                self.a, self.b = self.b, self.a + self.b
                self.n = self.n + 1
                return r
            raise StopIteration()