迭代器 & 生成器

列表生成式

需求：把列表 [0,1,2,3,4,5,6,7,8,9] 里面每个值加 1

a = [i+1 for i in range(10)]
print(a)

# 输出
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

生成器

通过列表生成式，我们可以直接创建列表，但是因为内存容量有限，列表容量肯定是有限的。所以如果列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续的元素呢？这样就不必创建完整的 list，从而节省大量的空间，这种一边循环一边计算的机制，成为生成器：generator。

要创建一个 generator，有很多种方法。第一种方法很简单，只要把一个列表生成式的 [] 改成 ()，就创建了一个 generator：

>>> L = [x * x for x in range(10)]
>>> L
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> g = (x * x for x in range(10))
>>> g
<generator object <genexpr> at 0x1022ef630>

创建 L 和 g 的区别仅在于最外层的 [] 和 ()，L 是一个 list，而 g 是一个 generator。

我们可以直接打印出 list 的每一个元素，但我们怎么打印出 generator 的每一个元素呢？

如果要一个一个打印出来，可以通过 next() 函数获得 generator 的下一个返回值：

>>> next(g)
0
>>> next(g)
1
>>> next(g)
4
>>> next(g)
9
>>> next(g)
16

我们讲过，generator 保存的是算法，每次调用 next(g)，就计算出 g 的下一个元素的值，直到计算到最后一个元素，没有更多的元素时，抛出 StopIteration 的错误。

当然，没有人会使用 next() 去调用，正确的方法是使用 for 循环，因为 generator 也是可迭代对象，而且这样不用担心会出现 StopIteration 的错误：

g = (x * x for x in range(10))
for n in g:
	print(n)

generator 非常强大。如果推算的算法比较复杂，用 for 循环无法实现时，还可以用函数来实现。

def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        # print(b)
        yield b  # 用yield替换print，就变为了生成器
        a, b = (
            b,
            a + b,
        )  # 赋值过程是同时进行的
        n = n + 1
    return 'done'  # 异常时打印

这就是定义 generator 的另一种方法。如果一个函数定义中包含 yield 关键字，那么这个函数就不再是一个普通函数，而是一个 generator。但是，需要注意，generator 和函数的执行流程不一样。函数是顺序执行，遇到 return 语句或者最后一行函数语句就返回。而变为 generator 的函数，在每次调用 next() 的时候执行，遇到 yield() 语句返回，再次执行时从上次返回的 yield 语句初继续执行。

data = fib(10)
print(data)
 
print(data.__next__())
print(data.__next__())
print("干点别的事")
print(data.__next__())
print(data.__next__())
print(data.__next__())
print(data.__next__())
print(data.__next__())
 
# 输出
<generator object fib at 0x101be02b0>
1
干点别的事
3
8

我们在循环中不断调用 yield，就会不断中断。同样，把函数改成 generator 后，我们基本上从来不会用 next() 来获取下一个值，而是用 for 循环来不断迭代：

for n in fib(6):
	print(n)

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

g = fib(6)
while True:
    try:
        print(next(g))
    except StopIteration as e:
        print('Generator return value:', e.value)
        break

还可以用过 yield 实现在单线程的情况下实现并发运算的效果

# 典型的生产者消费者模型
import time

# 消费者
def consumer(name):
    print("%s 准备吃包子啦!" % name)
    while True:
        baozi = yield
        print("包子[%s]来了,被[%s]吃了!" % (baozi, name))

# 生产者
def producer(name):
    c = consumer('A')
    c2 = consumer('B')
    c.__next__()
    c2.__next__()
    print("我开始准备做包子啦!")
    for i in range(10):
        time.sleep(1)
        print("做了2个包子!")
        c.send(i)
        c2.send(i)

producer("LK")

迭代器

1. 可直接作用于 for 循环的对象统称为可迭代对象：Iterable
2. 可使用 isinstance() 判断一个对象是否为可迭代对象
3. 可以被 next() 函数调用并不断返回下一个值的对象称为迭代器：Iterator
4. 生成器都是 Iterator 对象，但 list、dict、str 虽然是 Iterable， 却不是 Iterator

小结：

1. 凡是可作用于 for 循环的对象都是 Iterable 类型
2. 但是可作用于 next() 函数的对象都是 Iterator 类型，他们表示一个惰性计算的序列

from collections import Iterable
print(isinstance([], Iterable))
 
a = [1, 2, 3]
b = iter(a)   #将普通列表变为迭代器
print(b)
print(b.__next__())

你可能会问，为什么 list/dict/str 等数据类型不是 Iterator ？

这是因为 Python 的 Iterator 对象表示的是一个数据流，Iterator 对象可以被 next() 函数调用并不断返回下一个数据，直到没有数据时抛出 StopIteration 错误。可以把这个数据流看做是一个有序序列，但我们却不能提前知道序列的长度，只能不断通过 next() 函数实现按需计算下一个数据，所以 Iterator 的计算是惰性的，只有在需要返回下一个数据时它才会计算。

Iterator 甚至可以表示一个无限大的数据流，例如全体自然数，而使用 list 是永远不可能存储全体自然数的。