# 迭代器与生成器

## 迭代器

字符串、列表、元组、字典、集合都可以被for循环，说明他们都是可迭代的

```python
from collections import Iterable
l = [1, 2, 3, 4]
t = (1, 2, 3, 4)
d = {1: 2, 3: 4}
s = {1, 2, 3, 4}
print(isinstance(l, Iterable))
print(isinstance(t, Iterable))
print(isinstance(d, Iterable))
print(isinstance(s, Iterable))
```

### 可迭代协议

可以被迭代要满足的要求就叫做可迭代协议。可迭代协议的定义非常简单，就是内部实现了iter方法。

```python
l = [1, 2, 3, 4]
t = (1, 2, 3, 4)
d = {1: 2, 3: 4}
s = {1, 2, 3, 4}
print(dir(l))
print(dir(t))
print(dir(d))
print(dir(s))
```

可迭代的：内部必须含有一个iter方法。

### 迭代器

```python
l = [1, 2, 3, 4]
l_iter = l.__iter__()
item = l_iter.__next__()
print(item)
item = l_iter.__next__()
print(item)
item = l_iter.__next__()
print(item)
item = l_iter.__next__()
print(item)
item = l_iter.__next__()
print(item)
```

迭代器遵循迭代器协议：必须拥有iter方法和next方法。
for循环，能遍历一个可迭代对象，他的内部到底进行了什么？

将可迭代对象转化成迭代器。（可迭代对象.iter()）

内部使用next方法，一个一个取值。

加了异常处理功能，取值到底后自动停止。

```python
l = [1, 2, 3, 4]
l_iter = l.__iter__()
while True:
    try:
        item = l_iter.__next__()
        print(item)
    except StopIteration:
        break
```

### 为什么要有for循环

for循环就是基于迭代器协议提供了一个统一的可以遍历所有对象的方法，即在遍历之前，先调用对象的iter方法将其转换成一个迭代器，然后使用迭代器协议去实现循环访问，这样所有的对象就都可以通过for循环来遍历了

最重要的一点，转化成迭代器，在循环时，同一时刻在内存中只出现一条数据，极大限度的节省了内存

## 生成器

### 初识生成器

**Python中提供的生成器**

1. 生成器函数：常规函数定义，但是，使用yield语句而不是return语句返回结果。yield语句一次返回一个结果，在每个结果中间，挂起函数的状态，以便下次重它离开的地方继续执行
2. 生成器表达式：类似于列表推导，但是，生成器返回按需产生结果的一个对象，而不是一次构建一个结果列表

**生成器Generator**

* 本质：迭代器(所以自带了iter方法和next方法，不需要我们去实现)
* 特点：惰性运算,开发者自定义

### 生成器函数

一个包含yield关键字的函数就是一个生成器函数。yield可以为我们从函数中返回值，但是yield又不同于return，return的执行意味着程序的结束，调用生成器函数不会得到返回的具体的值，而是得到一个可迭代的对象。每一次获取这个可迭代对象的值，就能推动函数的执行，获取新的返回值。直到函数执行结束。

```python
import time
def genrator_func1():
    a = 1
    print('将a赋值')
    yield a
    b = 2
    print('将b赋值')
    yield b
g1 = genrator_func1()
print(g1,next(g1))
print(next(g1))
```

生成器不会一下子在内存中生成太多数据
比如我想卖包子，让包子工厂开始加工10000个包子，但是如果一下子全部生产好，没地方放，而且容易坏。

那么可以让包子工厂在我需要的时候再生产

```python
def produce():
    '''生产包子'''
    for i in range(10000):
        yield '生产了第%s个包子'%i
produce_g = produce()
print(produce_g.__next__())
print(produce_g.__next__())
print(produce_g.__next__())

# 需要一批包子
num = 0
for i in produce_g:
    print(i)
    num += 1
    if num == 5:
        break
```

### send

send 获取下一个值的效果和next基本一致

只是在获取下一个值的时候，给上一yield的位置传递一个数据

使用send的注意事项

* 第一次使用生成器的时候 是用next获取下一个值
* 最后一个yield不能接受外部的值

```python
def generator():
    print(123)
    content = yield 1
    print('=========',content)
    print(456)
    yield 2
g = generator()
ret = g.__next__()
print('***',ret)
ret = g.send('hello')
print('***',ret)
```

- 生产包子的send版本

```python
# produce函数，实现生成器获取包子数组，使用send()函数，指定获取的数量，比如produce.send(2)，得到['包子1','包子2']
# 反复使用send()可以获得包子序号是和前面连续的
def produce(prefix="包子", start=1):
    cur = start
    qty = yield  # 预激活用的第一个 yield（接收第一次 send 的数量）
    while True:
        if qty is None:
            qty = 1  # 如果传 None，就默认取 1 个
        if qty < 0:
            raise ValueError("数量必须是非负整数") # 主动抛出异常，直接让程序报错退出
        res = [f"{prefix}{i}" for i in range(cur, cur + qty)]
        cur += qty
        qty = yield res


produce = produce()
next(produce)
print(produce.send(20))
print(produce.send(10))
```

## 列表推导式和生成器表达式

```python
l = [i for i in range(10)]
print(l)
l1 = ['项目%s'%i for i in range(10)]
print(l1)
```

1. 把列表解析的[]换成()得到的就是生成器表达式
2. 列表解析与生成器表达式都是一种便利的编程方式，只不过生成器表达式更节省内存
3. Python不但使用迭代器协议，让for循环变得更加通用。大部分内置函数，也是使用迭代器协议访问对象的。例如， sum函数是Python的内置函数，该函数使用迭代器协议访问对象，而生成器实现了迭代器协议，所以，我们可以直接这样计算一系列值的和：

```python
ret = sum(x for x in range(101))
print(ret)
```

