迭代器（Iterators）和生成器（Generators）是 Python 语言中用处很大的工具，在某些情况下通过它们可以写出更加精简、清晰和高效的代码。
迭代器
迭代器是一种包含 __next__ 方法、用于处理数据流的对象。当使用 for 循环之类的方式遍历迭代器中的每一项数据时，__next__ 方法即被重复性地调用进而完成特定的动作。
以下代码即为一个不完整的迭代器类：
class MultiplyByTwo:
def __init__(self, number):
self.number = number
self.counter = 0
def __next__(self):
self.counter += 1
return self.number * self.counter
mul = MultiplyByTwo(5)
print(next(mul)) # => 5
print(next(mul)) # => 10
print(next(mul)) # => 15
print(next(mul)) # => 20
通过 next() 函数手动调用 MultiplyByTwo 类的 __next__ 方法，可以依次得到 number 变量与递增的 counter 变量的乘积。但是作为一个可被遍历的迭代器类，理论上也应该可以通过 for 语句直接以循环的方式逐次取出 __next__ 返回的乘积。
此时运行如下代码对 MultiplyByTwo 类进行迭代操作：
for num in MultiplyByTwo(5):
print(num)
则会报出 TypeError: 'MultiplyByTwo' object is not iterable 错误。即此时的“迭代器”对象还不支持遍历操作。
需要在 MultiplyByTwo 类中添加 __iter__ 方法表明其“可被遍历”，代码如下：
class MultiplyByTwo:
def __init__(self, number):
self.number = number
self.counter = 0
def __iter__(self):
return self
def __next__(self):
self.counter += 1
return self.number * self.counter
for num in MultiplyByTwo(5):
print(num)
# => 5
# => 10
# => 15
# => 20
# => ...
此时则可以使用 for 语句循环地调用 __next__ 方法获取 number 和递增的 counter 变量的乘积。
比较尴尬的是，以上面的方式遍历 MultiplyByTwo 迭代器，for 循环会一直运行下去。
可以通过以下代码为前面的迭代器添加终止点：
class MultiplyByTwo:
def __init__(self, number, limit):
self.number = number
self.limit = limit
self.counter = 0
def __iter__(self):
return self
def __next__(self):
self.counter += 1
value = self.number * self.counter
if value > self.limit:
raise StopIteration
else:
return value
for num in MultiplyByTwo(5, 20):
print(num)
# => 5
# => 10
# => 15
# => 20
所以一个实现了 __next__ 方法（用以不断返回下一个数据）、可进行迭代操作的对象即为迭代器。
对于前面实现的 MultiplyByTwo 迭代器类，在用 for 循环进行遍历操作时，
for num in MultiplyByTwo(5, 20): 的最终结果等同于 for 语句对以下列表的遍历：
for num in [5 * 1, 5 * 2, 5 * 3, 5 *4]: 。
实际上，迭代器对象表示的是一个数据流，其可以被 next() 函数调用并不断返回下一个数据，直到没有数据时抛出 StopIteration 异常。但这个“数据流”不是原本就完整地存在的，只能通过 next() 函数逐次地计算下一个值。
即迭代器的计算是惰性的，只有在需要返回下一个数据时才会被动地进行计算。
生成器
生成器可以理解为一种实现了迭代器协议的数据结构。前面提到迭代器是“懒惰”的，一次只计算一个数据。对于项目体量非常庞大的数据集合（比如全体自然数？没有任何一个列表能装下）或文件，生成器相比于其他数据结构，能够更加高效地使用内存资源。
生成器代码示例：
def multiple_generator(num, limit):
counter = 1
value = num * counter
while value <= limit:
yield value
counter += 1
value = num * counter
for num in multiple_generator(5, 20):
print(num)
# => 5
# => 10
# => 15
# => 20
不同于前面的 MultiplyByTwo 类，此次的 multiple_generator 生成器函数并不需要实现 __next__ 和 __iter__ 方法，也不用检查内部状态确认是否发起异常。而是使用了 yield 关键字。
yield 关键字类似于 return，只不过它并不会终止函数的运行。而是暂时中断函数的执行，直到下一个数据被请求（就继续返回下一个值）。
因此生成器相对于一般的迭代器更加易读和高效。
以下是一个经典的生成器在现实中的应用，通过生成器以数据块的方式读取文件：
def read_in_chunks(file_handler, chunk_size=1024):
""" Lazy function (generator) to read a file piece by piece."""
while True:
data = file_handler.read(chunk_size)
if not data:
break
yield data
f = open('large_number_of_data.dat')
for piece in read_in_chunks(f):
print(piece)
通过生成器每次只读取 1k 大小的数据块，循环遍历直到整个文件被处理。而不是将所有文件数据一次性地读入到内存中。
当需要读取的文件非常大时，此种方式相对于常规手段更加节省内存的使用。
yield from
yield from 关键字可以用来从其他生成器中获取数据。参考如下代码：
def flat_list(iter_values):
"""flatten a multi list or something"""
for item in iter_values:
if hasattr(item, '__iter__'):
yield from flat_list(item)
else:
yield item
print(list(flat_list([1, 2, [3, 4, [5]], 6])))
# => [1, 2, 3, 4, 5, 6]
上面的短短 6 行代码可以将包含任意层次的可迭代对象（如列表等）转换成单层的列表结构。
个人感觉，这代码非常漂亮，有点层层递进、环环相扣的感觉了。值得好好观赏。
PS：可以对比下阶乘的实现代码：
def factorial(n):
if n != 1:
return n * factorial(n-1)
else:
return 1
