python中的迭代器和生成器

生成器

1.通过列表生成式，可以直接创建一个列表，但是它的容量是有限的，在创建一个包含1000万甚至更多元素的列表时，不仅会占用很大的内存空间，而且浪费空间（因为有时只需要列表的部分元素）。
2.所以我们可以通过一种算法来推算出列表的元素，一边循环一边计算，这样的机制被称为生成器（generator）
3.创建生成器的方法：

#法一，将列表生成式的[]变成()
>>> L = [x * x for x in range(10)]
>>> L
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
#它等价于：
L = []
for i in range(10):
	L.append(i * i)

#[func(i) for i in range(10)]

>>> g = (x * x for x in range(10))
>>> g
<generator object <genexpr> at 0x000001FFD8FE9390>
for i in g:
	print(i)
#在生成器中，通过next()函数获得生成器的下一个返回值，不能以切片的方式去取，只能一个一个的取
#生成器只有在调用时生成相应的数据
#next(g)或者g.__next__()
#当生成下一个元素时，上一个元素就被内存释放了，无法去访问了，生成器就是通过这样的机制去减少内存占用的


#法二，通过函数实现，例：斐波那契数列
def fib(max): 
    n, a, b = 0, 0, 1
    while n < max: 
        #print(b)
        yield b #想把什么返回到外面，就在它的前面加yield
        a, b = b, a + b
        #a = b     a =1, b=2, a=b , a=2,
        # b = a +b b = 2+2 = 4	
		#这里的赋值语句相当于：
		t = (b,a+b) #t是一个元组
		a = t[0]
		b = t[1]

        n = n + 1
    return '---done---'

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

#print("---------dddd")
# print(f.__next__())
#生成器和函数相比的优点，若以上代码把yield改为print，那么函数一调用就只能等着他结束，才能执行后续的语句。而生成器可以让函数中断在某处，执行完后续语句再回来继续执行，而这里可以插入一个print，而不用等函数执行结束。
# print("======")
# print(f.__next__())
# print(f.__next__())
# print(f.__next__())
# print(f.__next__())
# print(f.__next__())
# print(f.__next__())
# print(f.__next__())
# print(f.__next__())
# print(f.__next__())
# print(f.__next__())
# print(f.__next__())
#当调用next()方法超出了生成器所包含的最大元素数，就会报错
#每执行完一次next()就会回到上一次函数中断的位置(yield)，执行完yield函数就会中断，跳到外面去
#所以说yield就是保存了函数当前中断时的状态值

print("====start loop======")
#使用了几次next后，开始循环，打印出的就从最后一次next之后的元素值
for i in f:
   print(i)

#用for循环且不超出生成器最大元素数就不会打印done。。
#若超出就会打印done（即打印return之后的值），如果想要拿到返回值，就必须捕获StopIteration错误，返回值包含在StopIteration的value中。
#这里不是一个函数了，return的作用就是打印出现异常时的消息

4.使用yield达到在单线程的情况下完成并行运算的效果（即函数执行过程中可以中断执行别的代码）
nginx为什么运行速率高，它在epoll单线程下，所承载的并发量比多线程下还要多。

#典型的生产者和消费者模型

import time
def consumer(name):
    print("%s 准备吃馅饼啦!" %name)
    while True:
       xianbing = yield

       print("馅饼[%s]来了,被[%s]吃了!" %(xianbing,name))

c = consumer("lc")
c.__next__()  #上面是一个生成器要执行一次next，走到yield，打印准备吃馅饼这句话

# b1= "肉馅"
# c.send(b1)
#把b1传进去，被yield接收，传给馅饼
#单纯的使用next()不会给yield传值，只会唤醒yield
#send()也是唤醒yield但是同时传值
# c.__next__()

def producer(name):
    c = consumer('A')
    c2 = consumer('B')
    c.__next__()  #上面是一个生成器要执行一次next，走到yield，打印准备吃馅饼这句话
    c2.__next__()
    print("%s开始准备做馅饼啦!"%name)
    for i in range(10):
        time.sleep(1)
        print("做了1个馅饼,分两半!")
        c.send(i)
        c2.send(i)

producer("cay")

迭代器

1.可迭代对象：可以直接作用于for循环的对象统称为可迭代对象：Iterable
其中一类为集合数据类型，如：list、tuple、dict、set、str等
还有一类是generater,包括生成器和带yield的generator function
可以使用isinstance()方法来判断一个对象是否为Iterable对象

In [2]: import collections

In [3]: isinstance([],Iterable)
Out[3]: True

In [4]: isinstance({},Iterable)
Out[4]: True

In [5]: isinstance('',Iterable)
Out[5]: True

In [6]: isinstance((),Iterable)
Out[6]: True

In [8]: isinstance(set([]),Iterable)
Out[8]: True

In [9]: isinstance(100,Iterable)
Out[9]: False

In [10]: isinstance((x for x in range(10)),Iterable)
Out[10]: True

#注意：可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator
#注意可迭代对象和迭代器的不同，可迭代对象不一定是迭代器，但是迭代器一定是一个可迭代对象
In [13]: from collections import Iterator

In [14]: isinstance([],Iterator)
Out[14]: False

In [15]: isinstance({},Iterator)
Out[15]: False

In [16]: isinstance('',Iterator)
Out[16]: False

In [17]: isinstance((),Iterator)
Out[17]: False

In [18]: isinstance((x for x in range(10)),Iterator)
Out[18]: True

In [19]: isinstance(set([]),Iterator)
Out[19]: False

#把list、dict、str等可迭代对象变成迭代器可以使用iter()函数
In [20]: isinstance(iter([]),Iterator)
Out[20]: True

In [21]: isinstance(iter('abc'),Iterator)
Out[21]: True

#打开文件时
f.xreadlines()   #该方法以迭代器的形式读取文件，使用f.__next__()方法进行读取

2.为什么list、dict、str、等数据类型不是Iterator?

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

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

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

4.python的for循环的本质就是通过不断调用next()函数实现的。

for x in [1,2,3,4,5]:
	print(i)

#完全等价于
it = iter([1,2,3,4,5])
while True:
	try:
		x = next(it)
	except StopIteration:
		break