Python—迭代器与生成器

时间 2019-11-08

原文原文链接

迭代器与生成器html

生成器（generator）算法

先来了解一下列表生成器：yii

1 list = [i*2 for i in range(10)]   
2 print(list)
>>>>
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

经过列表生成式，咱们能够直接建立一个列表。可是，受到内存限制，列表容量确定是有限的。并且，建立一个包含100万个元素的列表，不只占用很大的存储空间，若是咱们仅仅须要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。ide

因此，若是列表元素能够按照某种算法推算出来，那咱们是否能够在循环的过程当中不断推算出后续的元素呢？这样就没必要建立完整的list，从而节省大量的空间。在Python中，这种一边循环一边计算的机制，称为生成器：generator。函数

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

gen1 = (i*2 for i in range(10))
print(gen1)
>>>>>
<generator object <genexpr> at 0x0000022419B21AF0>  #列表生成器打印出来只是一个内存地址

要注意的是：code

1.打印生成器，只是打印其内存地址，生成器只有在调用的时候，才会产生元素，只能一个个取值htm

2.生成器不能像列表同样访问某个元素，或者切片。只能经过for循环打印出来，或者经过【__next__()】，括号里不能给参数 2.7里是 next()对象

3.生成器只有一个 __next__() 方法，生成器只会记住当前的取值，能够用next方法调用下一个，可是不能往前，内置函数 next也能够调用，for循环也能够调用，还能够数据类型强制转换： list(generator)blog

>在一次运行过程当中，生成器遍历取值完就没有值了。迭代器也是遍历完就没有值了，一样也会有 StopIteration Error

>生成器是一类特殊的迭代器。在函数中用 yield

#for循环调用生成器，，yield不能和return共用，且要写在函数内部
>>> def generator():
    print(1)
    yield 33333      #能够把yield当作return一个值，可是不结束函数，只是暂时中断
    print(2)
    yield 44444
    
>>> g = generator()   #此时g就是一个生成器，generator就是iterator，因此能够用for循环 >>> for i in g:
    print(i)
---->
1
33333
2
44444
>>>

用函数生成生成器，以斐波那契数列进行举例（yield不能和return共用，且要写在函数内部）

 1 def fibo(max):
 2     n,a,b = 0,0,1
 3     while n<max:
 4         #print(b)
 5         yield  b       #生成器的建立 yield:（返回后暂停）保持当前状态并中断函数，下次运行时，从这里日后运行，由于保存了当前状态  6         a,b = b,a+b    #至关于 t =(b,a+b)   a = t[0]  b = [t1]
 7         n +=1
 8     return 'done'
 9 
10 f = fibo(10)
11 print(f.__next__())
12 print(f.__next__())
13 print('----作点别的事情----')   #生成器能够调用一下，而后停下来作别的事，其余函数会一口气打印出全部结果 14 print(f.__next__())
15 print(f.__next__())
16 print('----开始for循环----')   #__next__方法只记录当前位置 17 for i in f:
18     print(i)
19 
20 >>>>>#结果以下所示
21 1
22 1
23 ----作点别的事情----
24 2
25 3
26 ----开始for循环----
27 5
28 8
29 13
30 21
31 34
32 55

StopIteration异常：

def fibo(max):
    n,a,b = 0,0,1
    while n<max:
        #print(b)
        yield  b
        a,b = b,a+b    #至关于 t =(b,a+b)   a = t[0]  b = [t1]
        n +=1
    return '----done----'

f = fibo(3)             #只运行3次斐波那契数列
print(f.__next__())
print(f.__next__())
print(f.__next__())
print(f.__next__())   #此时调用了4次next方法  ，此时会报 StopIteration错误


>>>>>>
Traceback (most recent call last):
1
  File "C:/Users/15302/PycharmProjects/GKXXX/day3/斐波那契数列.py", line 20, in <module>
1
    print(f.__next__())
2
StopIteration: ----done----    #这个done是函数返回值

能够用【try—except】来抓住异常（for循环用的就是这种机制）

def fibo(max):
    ‘--snip--’

f = fibo(5)
while True:                #用 try—except 来抓住异常
    try:
        x = next(f)
        print('斐波那契数列:',x)   #打印每次运行generator的值
    except StopIteration as e:　　#抓住StopIteration异常
        print('Generator return value:',e.value)　　#输出返回值
        break

>>>>>
斐波那契数列: 1
斐波那契数列: 1
斐波那契数列: 2
斐波那契数列: 3
斐波那契数列: 5
Generator return value: ----done----

关于yield（yield相似return，若是不打印是不显示yield的值的，只会执行程序）

def gen():
    print('start')
    m = yield 2  # 能够看做yield返回值为2，send(3)把3传递给m，并调用，m变成3了，同下
    print(m)
    n = yield 3
    print(n)

try:
    g = gen()     #此时不运行gen()函数，若print(g) 会打印该生成器的内存地址
    g.send(None)  # 至关于 g.__next__() 此处若 print(g.send(None)) 则先执行 打印start，而后执行 打印 yiled的返回值 2，而后函数暂停
    g.send(3333)　　　#此处若 print(g.send(3333))　　首先函数继续往下走，先把send里的3333赋值给m，而后打印m，接下来执行 yield 3的返回值，打印3
    g.send(6666)　　　　
except StopIteration as e:
    print(e.value)

>>>>
start
3333
6666
None

yield ：（返回并暂停）保持当前状态并中断，下次运行从这个状态开始

send(): 给yiield传值并调用 .__next__() 至关于 .send(None)

next：调用yield，唤醒它

作包子练习

 1 import time
 2 def consumer(name):
 3     print("%s 准备吃包子啦!" %name)
 4     while True:
 5        baozi = yield
 6 
 7        print("包子[%s]来了,被[%s]吃了!" %(baozi,name))
 8 
 9 # c = consumer('gkx') #此时不运行程序，即当函数中有yield时候，必定要用 __next__,send()方法调用才会运行,这句话至关于把函数变成生成器而已
10 # c.__next__()        #第一次运行到 yield，而后保存当前状态，中止
11 # b1 = 'jiucai'
12 # c.send(b1)
13 #c.__next__()        #运行yield日后的语句，即第二句 print处
14 def producer(name):
15     c = consumer('A')
16     c2 = consumer('B')
17     c.__next__()
18     c2.__next__()
19     print("开始准备作包子啦!")
20     for i in range(10):
21         time.sleep(1)
22         print("作了2个包子!")
23         c.send(i)
24         c2.send(i)
25 
26 producer("gkx")

View Code

迭代器

1.凡是可做用于for循环的对象都是Iterable类型；可迭代协议— 只要含有 __iter__方法的都是可迭代的

 1 >>> from collections import Iterable  
 2 >>> isinstance([],Iterable)
 3 True
 4 >>> isinstance((),Iterable)
 5 True
 6 >>> isinstance({},Iterable)
 7 True
 8 >>> isinstance(‘abc’,Iterable)
 9 True
10 >>> isinstance((x for x in range(10)),Iterable)
11 True
12 >>> isinstance(100,Iterable)
13 False
14 
15 #list,set,dict,str,generatior都是可迭代的，数字不可迭代

print('__iter__' in dir([])) >>>>>简单粗暴的判断方法

2.凡是可做用于next()函数的对象都是Iterator(迭代器)类型，它们表示一个惰性计算的序列；（生成器必定是迭代器，迭代器不必定是生成器）

迭代器协议：含有 __next__ 和 __iter__方法的，就是迭代器

 1 >>> from collections import Iterator  2 >>> isinstance((x for x in range(10)),Iterator)
 3 True
 4 >>> isinstance([],Iterator)
 5 False
 6 >>> isinstance({},Iterator)
 7 False
 8 >>> isinstance('abc',Iterator)
 9 False
10 >>> 
11 
12 #在dict,set,list,str,generator中，只有generator才是迭代器

3.集合数据类型如list、dict、str等是Iterable但不是Iterator，不过能够经过iter()函数得到一个Iterator对象。

from collections import Iterator
1 >>> isinstance(iter([]),Iterator)
2 True
3 >>> isinstance(iter({}),Iterator)
4 True

>>> a = ['1','2']
>>> iter(a)
<list_iterator object at 0x00000262D6E85F60>
>>> iter(a).__next__() #把列表a转换为迭代器，可使用__next__()函数
'1'
>>>

咱们在文件操做中，用 for line in f: 其中文件句柄 f 就是迭代器

for循环等价于：

 1 >>> it = iter(range(10))
 2 >>> while True:
 3     try:
 4         x = next(it)
 5         print(x)
 6     except StopIteration:
 7         break
 8 
 9     
10 0
11 1
12 2
13 3
14 4
15 5
16 6
17 7
18 8
19 9
20 >>>

View Code

【你可能会问，为何list、dict、str等数据类型不是Iterator？

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

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

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　—https://www.cnblogs.com/alex3714/articles/5765046.html