python基础6 迭代器 生成器

迭代器

可迭代的或迭代对象

可迭代的：内部含有__iter__方法的数据类型叫可迭代的，也叫迭代对象 ， range是一个迭代对象，内部含有iter（）方法。为什么可迭代对象能被for 循环，因为可迭代对象含有iter方法，只要函数iter方法的对象就可以被for循环。这也是可迭代协议。

运用dir()方法来测试一个数据类型是不是可迭代的的。如果含有iter的，就是可迭代对象、

迭代器协议

迭代器协议是指：对象必须提供一个next方法，执行该方法要么返回迭代中的下一项，要么就引起一个StopIteration异常，以终止迭代 （只能往后走不能往前退）。

迭代器：可以被next()函数调用并不断返回下一个值的对象称为迭代器，迭代器是一个实现了迭代器协议的对象。也可以这样说包含next方法的可迭代对象叫迭代器

迭代器和列表的区别?

区别在于节省内存和惰性运算

如果我有一个列表中有500个数据，那么这个列表就非常占用内存，如果把列表变为迭代器，就占用很少的内存，为什么会占用内存少呢，因为迭代器只记录当前这元素和下一个元素，当你找我要的时候我才在内存中生成数据，不找我要，就不生成数据，也就不占用内存，这就是迭代器的惰性运算。

如何区分迭代器和可迭代对象？这个在我们时间长了后会混淆。

可迭代对象最简单的定义：可以使用for in 语句进行循环的对象。比如字符串、列表、元组、字典以及迭代器、生成器都是可迭代对象。而迭代器是可以使用next()进行回调的对象，迭代器比可迭代对象多一个__next__方法。可迭代对象和迭代器的联系是：可以对迭代对象使用iter()方法来生成迭代器。

判断一个变量是不是迭代器或者可迭代对象？

from collections import Iterator
from collections import  Iterable
print(isinstance([1,2,3,4],Iterable))
str_iter="abc".__iter__()
print(isinstance(str_iter,Iterator))

结果：

True
True

注意！！！文件和enumerate含有next和iter方法所以是迭代器，例如：

enumerate范例：

from collections import Iterator
l=[1,3,4]
print(isinstance(enumerate(l),Iterator))

结果：

True

文件范例：

with open("产品",encoding="utf-8") as f:
    print("__next__" in dir(f))

结果：

True

迭代器的特点：

1.节省内存

2.惰性运算（什么时候用到，什么时候运行）

3.从前到后一次取值，过程不可逆，不可重复。

如果把迭代对象转变为迭代器？

可迭代对象调用自己的__iter__().方法就会返回一个迭代器

迭代器=iter(迭代对象） 注意：iter(迭代对象)=迭代对象.__iter__() next 和它的用法一样

迭代器的方法：

1.__next__方法：返回迭代器的下一个 元素。

2.__iter__方法：返回迭代器对象本身。

l=["ha","hei","he"]
ret=l.__iter__()       #这个步骤生成迭代器，ret就称为了一个迭代器。

print(ret.__next__())
print(ret.__next__())

迭代器比可迭代对象多一个__next__方法

包含__next__方法的可迭代对象就是迭代器

for循环原理

1.先判断对象是不是可迭代对象，如果不是直接报错，如果是的话，调用__iter__()返回一个迭代器。
2.然后不断的调用生成的迭代器的next()方法，每次返回一个值。
3.迭代到最后，没有更多元素了，就抛出异常 StopIteration，这个异常 python 自己会处理，不会暴露给开发者

这也就是用for循环取值节省内存的原因。

模拟for循环，解释for循环的内部原理。

不加try ....except 的情况下：

范例一：

l=[1,2,3,4,5]
ite=l.__iter__()
while True:
print(ite.__next__())

结果：
1
2
3
4
5

StopIteration 出现这种原因是while 循环不可以自动停止，然而迭代器从前到后一次取值，
过程不可逆，不可重复，所以就出现了这种情况。

如何避免这种错误？

范例二：

l=[1,2,3,4,5]
ite=l.__iter__()
while True:
    try:
        print(ite.__next__())
    except StopIteration:
            break

结果：

1
2
3
4
5

总结：for循环是让我们更简单的使用迭代器，用迭代器取值不需要关心索引或者key.

我们来完整的看看迭代过程是怎么实现的：当任何可迭代对象传入到for循环或其他迭代工具中进行遍历时，迭代工具都是先通过iter函数获得与可迭代对象对应的迭代器，然后再对迭代器调用next函数，不断的依次获取元素，并在捕捉到StopIteration异常时确定完成迭代，这就是完整的迭代过程。这也称之为“迭代协议”。

作者：酱油哥

链接：https://www.zhihu.com/question/20829330/answer/286837159

生成器

为什么要有生成器？

迭代器是从集合中取数据，而生成器是创造数据，这点从斐波那契中就可以看出区别来了，我们知道斐波那契数是无穷的，在集合中放不下，那么我们如何生成所有的斐波那契呢，这就用到了生成器

例如

def f():
    a=0
    b=1
    while True:
        yield a
        yield b
        a = b + a
        b=b+a

for i in f():
    print(i)

含有有yield 的函数被称之为生成器（generator）函数。

生成器函数执行后会得到一个生成器(generator)

生成器本质：生成器是迭代器，它包含一切迭代器的方法。

生成器的作用是

• 延迟计算一次只产生一个数据项.
• 增加代码的可阅读性

yield关键字

yield的作用:

1. 记住上次执行的状态
2. 自动切换到不同任务
3. 1次只返回一个结果, 把返回值传递给next() 的调用方

调用生成器send方法传递数据时，必须先调用next(g)或者g.send(None)方法，执行到yield语句，等待接收数据。否则会报错。

def func():
    a = yield 5  # send中的值先找到上次暂停的位置,然后把yield 5 替换成world 这里就变成了 a="world
    print("a>>>", a)
    yield 22


g = func()
num = g.__next__()
print("num>>>",num)
foo = g.send('world')  # send相当于next(),但是他又和next又有不同,他可以传值给上次暂停的地方,但是send第一次不能先执行,必须先执行next()或者send(none)
print('foo>>', foo)

结果:

num>>> 5
a>>> world
foo>> 22

实现yield 的切换任务的例子,即实现协程的例子

import time
def consumer():
    r = "开始吃包子了~"
    while True:
        x = yield r     #r发给send的调用方，x 接收send的传的值
        print("我正在吃包子%s"%(x))
        r = "包子已经收到"
        time.sleep(1)


def producer(c):
    p = c.__next__()
    print(p)
    n = 0
    while n < 5:
        n = n + 1
        print("生产者生产包子%s" % n)
        nn = c.send(n)
        print("send****")
        print("收到消费者的消息为%s"%nn)
    c.close()

con = consumer()
producer(con)

结果:

开始吃包子了~
生产者生产包子1
我正在吃包子1

send****
收到消费者的消息为包子已经收到
生产者生产包子2
我正在吃包子2

send****
收到消费者的消息为包子已经收到
生产者生产包子3
我正在吃包子3

send****
收到消费者的消息为包子已经收到
生产者生产包子4
我正在吃包子4

send****
收到消费者的消息为包子已经收到
生产者生产包子5
我正在吃包子5

send****
收到消费者的消息为包子已经收到

yield能在两个任务之间保存状态和切换,实现了并发的效果.,但是这种并发没有什么意义,只有遇到io阻塞时切换并发才有意义

yield from 关键字

yield from 是在python3.3中出现的新语法.

如果一个生成器需要另一个生成器的值时,传统的方法就是用for循环，yield from就可以带起for循环

yield from 的主要功能是打开双向通道，把最外层的调用方与最内层的子生成器连接起

来，这样二者可以直接发送和产出值，还可以直接传入异常，而不用在位于中间的协程中

添加大量处理异常的样板代码

传统方式 for循环

def generator1():
    item = range(5)
    for i in item:
        yield i

def generator2():
    yield 'a'
    yield 'b'
    yield 'c'
    for i in  generator1(): 
        yield i
    yield  'd'
for i in generator2() :
    print(i)

使用yield from 语法

def generator1():
    item = range(5)
    for i in item:
        yield i

def generator2():
    yield 'a'
    yield 'b'
    yield 'c'
    yield from generator1() #yield from iterable本质上等于 for item in iterable: yield item的缩写版
    yield  'd'
for i in generator2() :
    print(i)

结果：

a
b
c
0
1
2
3
4
d

一个题目:

a="AB"

b="CD"

想要生成: A B C D

方法一:

def func():
    a="AB"
    b="CD"
    for i in a:
        yield i

    for i in b :
        yield i

f=func()
for i in f:
    print(i)

方法二

def func():
    a="AB"
    b="CD"
    yield from a
    yield from  b
f=func()
for i in f:
    print(i)

yield from 调用生成器

def htest():
    i = 1
    while i < 4:
        n = yield i
        print("nnn",n)
        if i == 3:
            return 100
        i += 1

def itest():
    val = yield from htest() #调用生成器接收,yield from可以接收return的返回值
    print("val>>>",val)

t = itest()
t.send(None)
j = 0
while j < 3:
    j += 1
    try:
        print('j',j)
        t.send(j) #当t.send(3)时,htest函数早已经return了结束了
    except StopIteration as e:
        print('异常了')

j 1
nnn 1
j 2
nnn 2
j 3
nnn 3
val>>> 100
异常了

创建生成器的两种方法

1.生成器函数。常规函数定义，但是使用yield语句而不是return语句返回结果，yield返回值并不会终止程序的运行,一次只返回一个结果，在每个结果中间它会记住函数状态，以便下次从它离开的地方开始。

2.生成器表达式：

要介绍生成器表达式前,要先介绍列表生成式,即列表推导式,说白了就是如何生成一个列表

常规的写法

egg_list=[]
for i in range(10):
    egg_list.append('鸡蛋%s' %i)


如果用列表推导式可以这么写 语法规则: for 左边是列表 中要存放的结果,for 右边是生成这个列表所需的条件.

ret=['鸡蛋%s'%i for i in range(10)]
print  (ret)  

优点：方便，改变了编程习惯，可称之为声明式编程

结果:

['鸡蛋0', '鸡蛋1', '鸡蛋2', '鸡蛋3', '鸡蛋4', '鸡蛋5', '鸡蛋6', '鸡蛋7', '鸡蛋8', '鸡蛋9']

#1、把列表推导式的[]换成()就是生成器表达式

#2、示例：生一筐鸡蛋变成给你一只老母鸡，用的时候就下蛋，这也是生成器的特性
>>> chicken=('鸡蛋%s' %i for i in range(5))
>>> chicken
<generator object <genexpr> at 0x10143f200>
>>> next(chicken)
'鸡蛋0'
>>> list(chicken) #因chicken可迭代，因而可以转成列表
['鸡蛋1', '鸡蛋2', '鸡蛋3', '鸡蛋4',]

#3、优点：省内存，一次只产生一个值在内存中

既然有了列表生成式,为什么还出现生成器生成式来生成列表,这样就不必创建完整的list，从而节省大量的空间。在Python中，这种一边循环一边计算的机制，称为生成器：generator。

生成器函数和普通函数之间的区别？

1.生成器函数中有yield关键字。

2.生成器函数执行后不会立即执行，而是返回一个生成器。

def func():
    print("你好")
    yield 1
    print("中国")
    yield 2
func()
print(func())

结果：

<generator object func at 0x000002DD23F698E0>    #直接执行生成器函数后形成了一个生成器

如何让它打印执行？

def func():
    print("你好")
    yield 1
    print("中国")
    yield 2
func()
g=func()
print(g.__next__()) #生成器就是迭代器。
print(g.__next__())

结果：

你好
1
中国
2