• for x in iter(iterable)
• 迭代器 （Iterator）： Python 中 for 循环实际操作的对象
• 可迭代对象 （Iterable）：可以直接作用于 for 循环的对象
• 生成器（generator）：迭代器的一种，只能用于迭代操作

Reproduce from

• python 生成器和迭代器有这篇就够了
• The Iterator Protocol: How "For Loops" Work in Python
• python 迭代器和生成器详解
• python 生成器和迭代器有这篇就够了
• python 迭代器和生成器详解
• Python3 迭代器与生成器
• python itertools 模块讲解
• python itertools模块实现排列组合
• itertools --- 为高效循环而创建迭代器的函数

可迭代对象 Iterable

list，dict，str 都是 iterable（可迭代对象），而不是 Iterator（迭代器）。

定义了 __iter__()，该对象就是可迭代对象。

通过调用 iter()，iter(iterable) 将返回迭代器 Iterator。

>>> iter(b)
>>> b.__iter__()

>>> isinstance(iter(['some', 'list']), Iterator) 
True 
>>> isinstance(iter({'some', 'set'}), Iterator) 
True
>>> isinstance(iter('some string'), Iterator) 
True

可迭代对象的缺点：所有数据都在内存中，如果有海量的数据，将会非常耗内存。

可以直接作用于 for 循环的对象就是可迭代对象：Iterable。
迭代器 Iterator 是 for loops 实际操作的对象。

迭代器 Iterator

__iter__() 方法返回一个特殊的迭代器对象， 这个迭代器对象实现了 __next__() 方法并通过 StopIteration 异常标识迭代的完成。

Python 的 Iterator 对象表示的是一个数据流，Iterabot 对象可以被 next() 函数调用并不断返回下一个数据，直到没有数据时抛出 StopIteration 错误。可以把这个数据流看作是一个有序序列。Iterator 的计算是惰性的，只有在需要返回下一个数据时它才会计算。

>>>iterator = iter('hi')
>>> next(iterator)
'h'
>>> next(iterator)
'i'
>>> next(iterator)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

Python "for" syntactic sugar

Python 提供的 for x in xx 语法糖为迭代提供了方便的使用方法。在 for 循环中，Python 将自动调用 iter() 获得迭代器，自动调用 next() 获取元素，还完成了检查 StopIteration 异常工作。

Looping over iterables works via getting an iterator from an iterable and then repeatedly asking the iterator for the next item.

for x in [1, 2, 3, 4, 5]:
    pass

等价于

# Get Iterator object
it = iter([1, 2, 3, 4, 5])

# looping
while True:
    try:
        # Get next value
        x = next(it)
    except StopIteration:
        # Stop looping with StopIteration
        break

迭代器也是可迭代对象

你可以将 iterators 传进内建 iter() 来得到他们本身。这就是说 iterators 也是 iterables。（You can pass iterators to the built-in iter function to get themselves back. That means that iterators are also iterables.）

>>> iterator = iter('hi')
>>> iterator2 = iter(iterator)
>>> iterator is iterator2
True

生成器 Generator

Python 中，使用了 yield 的函数被称为生成器（generator）。
Generator 是 Iterator 的一种。

为什么需要 Generator

如果需要函数生成 Fibonacci number，可以直接这样写：

def fab(max):
    L = []
    n, a, b = 0, 0, 1
    while n < max:
        L.append(b)
        a, b = b, a + b
        n += 1
    return L

但是这样可能占用大量内存，试着使用刚讲到的 Iterator：

class Fab:
    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:
            raise StopIteration
        else:
            r = self.b
            self.a, self.b = self.b, self.a + self.b
            self.n += 1
            return r

for key in Fab(5):
    print(key)

看上去已经不错了，但是使用 yield 的 generator 可以保持 iterator 的效果的同时，写出更简洁的代码：

def fab(max):
    n, a, b = 0, 0, 1
    while n < max:
        yield b
        a, b = b, a + b
        n += 1

是不是简洁很多！

说明

yield 会把一个函数变为一个 generator；即带有 yield 的函数不再是一个普通的函数，Python 解释起会将其视为 generator，调用 fab(5) 不会执行 fab()，而是返回一个 iterable object。

调用 generator，返回的是一个 iterable object，因此 generator 只能用于迭代操作。

在调用 generator 的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值，并在下一次执行 next() 时从当前位置继续运行。

return in generator

在一个 generator 中，如果没有 return，则默认执行到函数完毕；如果遇到 return，则直接抛出 StopIteration 终止迭代。

def read_file(fpath):
    BLOCK_SIZE = 1024
    with open(fpath, 'rb') as f:
        while True:
            block = f.read(BLOCK_SIZE)
            if block:
                yield block
            else:
                return

如果直接对文件对象调用 read()，会导致不可预测的内存占用。好的方法是利用固定长度的缓冲区来不断读取文件内容。用过 yield，我们不再需要编写读文件的迭代类，就可以轻松实现文件读取。

创建 generator 方法

要创建 generator 有很多方法，除了使用 def，还有一种简单的方法，就是把一个列表生成式中的 [] 改为 ()，就创建了一个 generator。

# 列表生成式
lis = [x * x for x in range(10)]

# 生成器
gen = (x * x for x in range(10))

itertools

itertools 是 Python 的迭代器模块，标准化了一个快速，高效利用内存的核心工具集。

无穷迭代器

迭代器	实参	结果	实例
count()	start, [step]	start, start + step, start + 2 * step, ... 重复无限次或 step 次	count(10) --> 10, 11, 12, 13, 14...
cycle()	p	p0, p1, p_last, p0, p1...	cycle('ABCD') --> A B C D A B C D...
repeat()	elem [, n]	elem, elem, elem ... 重复无限次或 n 次	repeat(10, 3) --> 10 10 10

有穷迭代器

迭代器	实参	结果	实例
accumulate	p [, func]	p0, p0 + p1, p0 + p1 + p2, ...	accumulate([1,2,3,4,5]) --> 1 3 6 10 15
chain()	p, q, ...	p0, p1, ... p_last, q0, q1, ...	chain('ABC', 'DEF') --> A B C D E F
chain.from_iterable()	iterable	p0, p1, ... p_last, q0, q1, ...	chain.from_iterable(['ABC', 'DEF']) --> A B C D E F
compress()	data, selectors	(d[0] if s[0]), (d1 if s[1]), ...	compress('ABCDEF', [1,0,1,0,1,1]) --> A C E F
dropwhile()	pred, seq	seq[0], seq[1],... 从 pred 首次真值测试失败开始	dropwhile(lambda x: x<5, [1,4,6,4,1]) --> 6 4 1
filterfalse()	pred, seq	seq 中 pred[x] 为假值的元素，x 是 seq 中的元素	filterfalse(lambda x: x % 2, range(10)) --> 0, 2, 4, 6, 8
groupby()	iterable [, key]	根据 key(v) 值分组的迭代器
islice()	seq, [start, ] stop [, step]	seq[start: stop: step] 中的元素	islice('ABCDEFG', 2, None) --> C D E F G
startmap()	func, seq	func(seq[0]), func(seq[1]), ...	startmap(pow, [(2, 5), (3,2), (10,3)]) --> 32 9 1000
takewhile()	pred, seq	seq[0], seq[1], ... 直到 pred 真值测试失败	takewhile(lambda x: x < 5, [1, 4, 6, 4, 1]) -- >1 4
tee	it, n	it1, it2, ..., itn	将一个迭代器拆分为 n 个迭代器
zip_longest()	p, q, ...	(p[0], q[0]), (p[1], q[1]), ...	zip_longest('ABCD', 'xy', fillvalue='-') --> Ax By C- D-

排列组合迭代器

迭代器	实参	结果 / 实例
product()	p, q, ... [, repeat]	笛卡尔积，相当于嵌套的 for 循环
permutations()	p [, r]	长度 r 元组，所有可能的排列，无重复元素
combinations()	p, r	长度 r 元组，有序，无重复元素
combinations_with_replacement()	p, r	长度 r 元组，有序，元素可重复
product('ABCD', repeat=2)		AA AB AC AD BA BB BC BD CA CB CC CD DA DB DC DD
premutations('ABCD', 2)		AB AC AD BA BC BD CA CB CD DA DB DC
combinations('ABCD', 2)		AB AC AD BC BD CD
combinations_with_replacement('ABCD', 2)		AA AB AC AD BB BC BD CC CD DD