迭代器与生成器

用一种方法，最好是只有一种方法来做一件事

迭代器的用途:

for ... in 循环
遍历文件等
列表推导，字典推导，集合推导
元组拆包
调用函数时，使用* 拆包实参

可迭代对象

首先我们来分析一下序列可迭代的原因：iter函数
解释器需要迭代对象x时，会自动调用iter(x),内置的iter有如下作用

检查对象是否实现了__iter__方法，如果实现了就调用他，获取一个迭代器

 def __iter__(self):
        return iter(self._components)

如果没有实现，但是实现了__getitem__,Python会创建一个迭代器，尝试依次获取元素

    def __getitem__(self, index):
        cls = type(self)
        if isinstance(index, slice):
            return cls(self._components[index])
        elif isinstance(index, numbers.Integral):
            return self._components[index]
        else:
            msg = '{.__name__} indices must be integers'
            raise TypeError(msg.format(cls))

如果失败了，就会抛出TypeError异常

从 Python 3.4 开始，检查对象 x 能否可迭代，最准确的方法是：调用 iter(x) 函数，如果不可迭代，再处理 TypeError 异常。这比使用 isinstance(x, abc.Iterable) 更准确，因为 iter(x) 函数会考虑到遗留的 getitem 方法，而 abc.Iterable 类则不考虑。

只要实现了上述任意一个方法，我们就可以说该对象是可迭代对象

迭代器

若一个类想成为迭代器需实现

方法 __next__
__iter__

使用：

it = iter(obj)
while True:
       try:
           print(next(it))
         except StopIteration:
            del it
            break

检查对象 x 是否为迭代器最好的方式是调用 isinstance(x, abc.Iterator)。得益于 Iterator.subclasshook 方法，即使对象 x 所属的类不是 Iterator 类的真实子类或虚拟子类，也能这样检查。

有同学看到这里就不禁疑问，迭代器和可迭代对象，到底有啥区别 ???

可迭代的对象有个 iter 方法，每次都实例化一个新的迭代器；而迭代器要实现 next 方法，返回单个元素，此外还要实现 iter 方法，返回迭代器本身。因此，迭代器可以迭代，但是可迭代的对象不是迭代器。

那我能不能将一个类实现为即是可迭代对象又是迭代器呢？可能我们都不会意识到这叫反模式

迭代器模式的适用性总结：

访问一个聚合对象的内容而无需暴露它的内部表示
支持对聚合对象的多种遍历
为遍历不同的聚合结构提供一个统一的接口（即支持多态迭代）

为了“支持多种遍历”，必须能从同一个可迭代的实例中获取多个独立的迭代器，而且各个迭代器要能维护自身的内部状态，因此这一模式正确的实现方式是，每次调用 iter(my_iterable) 都新建一个独立的迭代器。这就是为什么需要定义迭代器类。

import re
import reprlib

RE_WORD = re.compile('\w+')


class Sentence:

    def __init__(self, text):
        self.text = text
        self.words = RE_WORD.findall(text)

    def __repr__(self):
        return 'Sentence(%s)' % reprlib.repr(self.text)

    def __iter__(self):  
        return SentenceIterator(self.words)  


class SentenceIterator:

    def __init__(self, words):
        self.words = words  
        self.index = 0  

    def __next__(self):
        try:
            word = self.words[self.index]  
        except IndexError:
            raise StopIteration() 
        self.index += 1  
        return word  

    def __iter__(self):  
        return self

在很多情况下，迭代器的遍历实现可以使用生成器来实现

生成器

生成器函数的工作原理
由一个生成器函数返回一个生成器对象，该函数使用yield关键字产出数据元素，一般情况下，一个生成器函数包含一个不断yield的循环，每次迭代都会访问下一个yield的产出数据

    def __iter__(self):
        for match in RE_WORD.finditer(self.text):  # <2>
            yield match.group()

def geb_AB():
    print("start")
    yield "A"
    print("continue")
    yield "B"
    print("end")

列表推导

[x*3 for x  in gen_AB()]

生成器表达式

res = (x*3 for x in gen_AB()) # 仅仅返回一个生成器

只有在for 循环迭代的时候，才会真正执行gen_AB的函数体，每次执行一个yield

yield from

如果生成器函数需要产出另外一个生成器的值，一般会使用嵌套的for循环解决

def chain(*iterable):
    for it  in iterable:
          for v in it:
                 yield v

s = "abcde"
t = tuple(2,4,5,6,6,7,)
list(chain(s,t))

如果是使用yield from

def chain(*iterable):
       for it in iterable:
              yield from it

iter 函数

iter函数有个极少使用的方式：接收两个入参，第一个是可调用对象或者函数，第二个为哨兵符，遇到到哨兵符就会抛出StopIteration.

def random_s():
     return randint(1,6)

d_it = iter(random_s, 1) # 当遇到1时停止
for roll in d_it:
     print(roll)

with open('mydata.txt') as fp:
        for line in iter(fp.reandline, "\n"):
               process_line(line)

下面贴几张标准库生成器函数

返回单个结果-归约

合并

映射

过滤

扩展

重排