python 学习day9

# 生成器只有在调用时才会生成相应的数据
# 生成器保存的是算法，每次调用next()函数就会计算出下一个元素的值
# 当计算到最后一个元素的时候，会抛出StopIteration的错误。
# 生成器表达式来源于迭代和列表解析的组合，生成器和列表解析类似，但是它使用尖括号而不是方括号

import time
# 列表生成式
a=[i*2 for i in range(10)]
print(a)

def fun(i):
    return i*2
b=[fun(i) for i in range(10)]
print(b)

# 作用等于
c=[]
for i in range(10):
    c.append(i*2)
print(c)

# 生成器
d=(i*2 for i in range(10))
print(d)
print(next(d))
print(d.__next__())
print('--------')
for i in d:
    print(i)

# 两者之间的转换
e=list(i*2 for i in range(10))
print(e)

print('*********')
# 如果推算的算法比较复杂，用类似列表生成式的
# for循环无法实现的时候，还可以用函数来实现。

# 斐波那契数列
def fib(max):
    n,a,b=0,1,1
    while n<max:
        print(a)
        a,b=b,a+b #相当于t = (b, a + b) ,a = t[0],b = t[1]
        n=n+1
    return 'done'
fib(5)
# fib函数实际上是定义了斐波拉契数列的推算规则，
# 也就是说上面的函数，也可以用generator来实现。
# generator和函数的执行流程:函数是顺序执行的，遇到return语句或者最后一行函数语句就返回。
# 而变成generator的函数，在每次调用next()的时候执行，遇到yield语句返回。
# 再次被next（）调用时候从上次的返回yield语句处继续执行，也就是用多少，取多少，不占内存。
# 函数有了yield之后，函数名+（）就变成了生成器
def fib(max):
    n, a, b = 0, 1, 1
    while n < max:
        yield a
        a, b = b, a + b
        n = n + 1
    return 'done' # return在生成器中代表生成器的中止，直接报错
a = fib(5)
print(a)
for i in fib(5):
    print(i)
print('---------')
# 但是用for循环调用generator时，发现拿不到generator的return语句的返回值。
# 如果拿不到返回值，那么就会报错，所以为了不让报错，就要进行异常处理，拿到返回值.
# 如果想要拿到返回值，必须捕获StopIteration错误，返回值包含在StopIteration的value中：

while True:
    try:
        x = next(a)
        print(x)
    except StopIteration as e:
        print("生成器返回值：",e.value)
        break
print('----------')

# 通过yield实现在单线程的情况下实现并发运算的效果
def consumer(name):
    print("%s 来消费啦!" % name)
    while True:
        goods = yield
        print("[%s]产品生产出来了,被[%s]消费了!" % (goods, name))

def producer(name):
    c = consumer('刘备')
    c2 = consumer('关羽')
    next(c)  # next的作用是唤醒并继续执行
    next(c2)
    print("生产开始了!")
    for i in range(5):
        time.sleep(1)
        print("[%s]生产了两件产品!"%(name))
        c.send(i)   # send的作用是唤醒并继续执行，发送一个信息到生成器内部
        c2.send(i+5)
producer('张飞')
print('**************')
# 综上所述：
# 生成器函数：也是用def定义的，利用关键字yield一次性返回一个结果，阻塞，重新开始。
# 生成器表达式：返回一个对象，这个对象只有在需要的时候才产生结果。
# 之所以叫生成器函数，因为它随着时间的推移生成了一个数值队列。
# 一般的函数在执行完毕之后会返回一个值然后退出，但是生成器函数会自动挂起，然后重新拾起继续执行，
# 他会利用yield关键字关起函数，给调用者返回一个值，同时保留了当前的足够多的状态，可以使函数继续执行。
# 生成器和迭代协议是密切相关的，迭代器都有一个__next__()__成员方法，这个方法要么返回迭代的下一项，要买引起异常结束迭代。



def create_counter(n):
    print("create_counter")
    while True:
        yield n
        print("increment n")
        n += 1

gen = create_counter(2)
print(gen)
print(gen.__next__())
print(next(gen))

# 一个迭代既可以被写成生成器函数，也可以被写成生成器表达式，均支持自动和手动迭代。
# 而且这些生成器只支持一个active迭代，也就是说生成器的迭代器就是生成器本身。

# 迭代器（迭代就是循环）
# 迭代器包含有next方法的实现，在正确的范围内返回期待的数据以及超出范围后能够抛出StopIteration的错误停止迭代。
# 我们已经知道，可以直接作用于for循环的数据类型有以下几种：
# 一类是集合数据类型，如list,tuple,dict,set,str等
# 一类是generator，包括生成器和带yield的generator function
# 这些可以直接作用于for 循环的对象统称为可迭代对象：Iterable
# 可以使用isinstance()判断一个对象是否为可Iterable对象
from collections import Iterable
from collections import Iterator

print(isinstance([], Iterable))
print(isinstance({}, Iterable))
print(isinstance('abc', Iterable))
print(isinstance((x for x in range(10)), Iterable))
print(isinstance(100, Iterable))

# 生成器不但可以作用于for循环，还可以被next()函数不断调用并返回下一个值
# 直到最后抛出StopIteration错误表示无法继续返回下一个值了。
print("*******")
# 可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator。
# 可以使用isinstance()判断一个对象是否是Iterator对象
print(isinstance((x for x in range(10)), Iterator))
print(isinstance([], Iterator))
print(isinstance({}, Iterator))
print(isinstance('abc', Iterator))

# 生成器都是Iterator对象，但list、dict、str虽然是Iterable，却不是Iterator。
# 把list、dict、str等Iterable变成Iterator可以使用iter()函数：
print("----------")
print(isinstance(iter([]), Iterator))
print(isinstance(iter('abc'), Iterator))


# list、dict、str等数据类型不是Iterator,这是因为Python的Iterator对象表示的是一个数据流.
# Iterator对象可以被next()函数调用并不断返回下一个数据，直到没有数据时抛出StopIteration错误。
# 可以把这个数据流看做是一个有序序列，但我们却不能提前知道序列的长度，只能不断通过next()函数实现按需计算下一个数据，
# 所以Iterator的计算是惰性的，只有在需要返回下一个数据时它才会计算。
# Iterator甚至可以表示一个无限大的数据流，例如全体自然数。而使用list是永远不可能存储全体自然数的。

yield函数总结

　　（1）通常的for..in...循环中，in后面是一个数组，这个数组就是一个可迭代对象，类似的还有链表，字符串，文件。他可以是a = [1,2,3]，也可以是a = [x*x for x in range(3)]。

它的缺点也很明显，就是所有数据都在内存里面，如果有海量的数据，将会非常耗内存。

　　（2）生成器是可以迭代的，但是只可以读取它一次。因为用的时候才生成，比如a = (x*x for x in range(3))。!!!!注意这里是小括号而不是方括号。

　　（3）生成器（generator）能够迭代的关键是他有next()方法，工作原理就是通过重复调用next()方法，直到捕获一个异常。

　　（4）带有yield的函数不再是一个普通的函数，而是一个生成器generator，可用于迭代

　　（5）yield是一个类似return 的关键字，迭代一次遇到yield的时候就返回yield后面或者右面的值。而且下一次迭代的时候，从上一次迭代遇到的yield后面的代码开始执行

　　（6）yield就是return返回的一个值，并且记住这个返回的位置。下一次迭代就从这个位置开始。

　　（7）带有yield的函数不仅仅是只用于for循环，而且可用于某个函数的参数，只要这个函数的参数也允许迭代参数。

　　（8）send()和next()的区别就在于send可传递参数给yield表达式，这时候传递的参数就会作为yield表达式的值，而yield的参数是返回给调用者的值，也就是说send可以强行修改上一个yield表达式值。

　　（9）send()和next()都有返回值，他们的返回值是当前迭代遇到的yield的时候，yield后面表达式的值，其实就是当前迭代yield后面的参数。

　　（10）第一次调用时候必须先next（）或send（）,否则会报错，send后之所以为None是因为这时候没有上一个yield，所以也可以认为next（）等同于send(None)