python高级编程--生成器与迭代器

生成器

为什么使用生成器

通过列表⽣成式，我们可以直接创建⼀个列表。但是，受到内存限制，列表容量肯定是有限的。⽽且，创建⼀个包含100万个元素的列表，不仅占⽤很⼤的存储空间，如果我们仅仅需要访问前⾯⼏个元素，那后⾯绝⼤多数元素占⽤的空间都⽩⽩浪费了。所以，如果列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续的元素呢？这样就不必创建完整的list，从⽽节省⼤量的空间。在Python中，这种⼀边循环⼀边计算的机制，称为⽣成器：generator

怎么使用生成器

创建生成器，列表生成式，我们知道，只要将最外一层的中括号，改为小括号。

# python交互式环境
>>> y = [x + 1 for x in range(10) if x % 2 == 0]
>>> y
[1, 3, 5, 7, 9]
>>> g = (x + 1 for x in range(10) if x % 2 == 0)
>>> g
<generator object <genexpr> at 0x0000020EF13E79C8>

创建 y 和 g 的区别仅在于最外层的 [ ] 和 ( ) ， y 是⼀个列表，⽽ g 是⼀个⽣成器。我们可以直接打印出L的每⼀个元素，但我们怎么打印出g的每⼀个元素呢？如果要⼀个⼀个打印出来，可以通过 next() 函数获得⽣成器的下⼀个返回值。

>>> next(g)
1
>>> next(g)
3

但超出了生成器的最后一个元素还使用next会导致报错

Traceback (most recent call last):
File "<pyshell#13>", line 1, in <module>
next(g)
StopIteration

还可以使用循环打印

>>> g = (x + 1 for x in range(10) if x % 2 == 0)
>>> for i in g:
print(i)
...
1
3
5
7
9

怎么防止异常

正确的⽅法是使⽤ for 循环，因为⽣成器也是可迭代对象。所以，我们创建了⼀个⽣成器后，基本上永远不会调⽤next() ，⽽是通过 for 循环来迭代它，并且不需要关心StopIteration 异常。

函数生成器

generator非常强大。如果推算的算法比较复杂，用类似列表生成式的 for 循环无法实现的时候，还可以用函数来实现。比如，著名的斐波拉契数列（Fibonacci），除第一个和第二个数外，任意一个数都可由前两个数相加得到：1, 1, 2, 3, 5, 8, 13, 21, 34, …
斐波拉契数列用列表生成式写不出来，但是，用函数把它打印出来却很容易：

# -*- coding: UTF-8 -*-
# 文件名：class_c.py
# 定义一个斐波那契函数
def fib_a(times):
# 初始化
n = 0
a, b = 0, 1
while n < times:
print(b)
a, b = b, a + b
n += 1
return 'done'
z = fib_a(5)
print(z)
# 打印结果如下
1
1
2
3
5
done

仔细观察，可以看出，fib_a函数实际上是定义了斐波拉契数列的推算规则，可以从第一个元素开始，推算出后续任意的元素，这种逻辑其实非常类似generator。也就是说，上面的函数和generator仅一步之遥。要把 fib 函数变
成generator，只需要把 print(b) 改为 yield(b) 就可以了（yield没有返回值）

def fib_a(times):
# 初始化
n = 0
a, b = 0, 1
while n < times:
yield(b)
a, b = b, a + b
n += 1
return 'done

f = fib_a(5)
>>> next(f)
1
>>> next(f)
1
>>> next(f)
2

但是⽤for循环调⽤generator时，发现拿不到generator的return语句的返回值。如果想要拿到返回值，必须捕获
StopIteration错误，返回值包含在StopIteration的value中：
异常处理

def fib_d(times):
# 初始化
n = 0
a, b = 0, 1
while n < times:
yield (b)
a, b = b, a + b
n += 1
return 'done'
f = fib_d(5)
while True:
try:
x = next(f)
print("value:%d" % x)
except StopIteration as e:
print("⽣成器返回值:%s" % e.value)
break

我们执⾏到yield时，gen函数作⽤暂时保存，返回i的值next的函数，是基于实际对象的 next 方法
也可以使用print(f.__next__())

send()函数

send函数等价于next函数，但是第一个参数必须为send('None')。后续参数可以为空字符。
总结：

迭代器

迭代是访问集合元素的⼀种⽅式。迭代器是⼀个可以记住遍历的位置的对象。迭代器对象从集合的第⼀个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。我们已经知道，可以直接作用于 for 循环的数据类型有以下几种：一类是集合数据类型，如 list 、 tuple 、 dict 、 set 、 str 等；一类是 generator ，包括生成器和带 yield 的generator function。这些可以直接作用于 for 循环的对象统称为可迭代对象： Iterable 。那我们怎么判断一组数据或是一组数据对象是不是 Iterable 对象呢？可以使⽤ isinstance() 判断⼀个对象是否是 Iterable 对象

>>> from collections.abc import Iterable
>>> print(isinstance([], Iterable))
True
>>> isinstance({}, Iterable)
True
>>> isinstance('1', Iterable)
True
>>> isinstance((x for x in range(10) if x % 2 == 0), Iterable)
True
>>> isinstance(10, Iterable)
False
>>>

⽣成器不但可以作⽤于 for 循环，还可以被 next() 函数不断调⽤并返回下⼀个值，直到最后抛出 StopIteration 错
误表示⽆法继续返回下⼀个值了。可以被next()函数调⽤并不断返回下⼀个值的对象称为迭代器：Iterator。可以使⽤ isinstance() 判断⼀个对象是否是Iterator 对象，这里就产生一个疑问了，生成器都是 Iterator 对象， list 、 dict 、 str 是不是Iterator ？为什么？。list 、 dict 、 str 不是 Iterator ，因为Python的 Iterator 对象表示的是一个数据流，Iterator对象可以被 next() 函数调用并不断返回下一个数据，直到没有数据时抛出 StopIteration 错误。可以把这个数据流看做是一个有序序列，但我们却不能提前知道序列的长度，只能不断通过 next() 函数实现按需计算下一个数据，所以 Iterator 的计算是惰性的，只有在需要返回下一个数据时它才会计算。
Iterator 甚至可以表示一个无限大的数据流，例如全体自然数。而使用list是永远不可能存储全体自然数的
那我们还可以通过 isinstance() 来判断是否是 Iterator 对象。
注意 Iterator 对象和 Iterable 对象，一个是迭代器，一个是可迭代对象

>>> from collections.abc import Iterator
>>> isinstance((i for i in range(10) if i % 2 == 0), Iterator)
True
>>> isinstance([], Iterator)
False
>>> isinstance({}, Iterator)
False
>>> isinstance('abc', Iterator)
False
>>>

但是可以将 list 、 dict 、 str 等 Iterable 变成 Iterator，这里我们可以使用 iter() 函数
代码：

>>> isinstance(iter([]), Iterator)
True
>>> isinstance(iter('abc'), Iterator)
True
>>>

所以可作用于 for 循环的对象都是 Iterable 类型；可作用于 next() 函数的对象都是 Iterator 类型，它们表示一个惰性计算的序列；集合数据类型list 、 dict 、 str 等是 Iterable 但不是 Iterator ，不过可以通过 iter() 函数获得⼀个 Iterator 对象。