python摸爬滚打之day12----生成器, 各种生成式

1、生成器

　生成器的本质就是迭代器.

　1.1  获取生成器

　　1:  生成器函数

　　　函数中出现 "yield" 的函数就是一个生成器函数, 再次执行函数时就不是运行函数而是获取生成器.

　　2: 生成器推导式

　　　( i for i in range( 20) )  ----> 不是元组生成式, 而是生成器推导式, 它获取的是一个生成器.

　　　　    gen = ( i for i in range( 20) ), gen就是一个生成器

　1.2  生成器取值方式: 　

　　　　1,  通过__next__()取值.     2 , 通过send(" ")取值并传值.

 def func():
     print("黄焖鸡")                #
     yield "黄焖鸡yield"            #
     print("烧鸭")            #
     yield "烧鸭yield"            #
     print("蒸鹿茸")            #
     yield "蒸鹿茸yield"            #
     print("蒸熊掌")

 gen = func()     # 函数中出现"yield" 时,表示该函数为生成器,获取生成器.
 print(gen)     #  结果是一个生成器地址. <generator object func at 0x000002798C873C78>
 gen.__next__()        # 取到函数体中yield的那行就停止(第1,2行),并将yield后面的内容返回给调用者
 print(gen.__next__())       # 再次调用就从上次停止的yield下行(第3行)开始运行,截止到第四行.
 print(gen.__next__())
 print(gen.__next__())     # 如果yield内容结束,还继续调用,则报错,但是print("蒸熊掌")还是会继续执行的

生成器__next__()取值

　1.2  生成器本质就是迭代器, 如何满足迭代器的三个特点呢?

 def buy():
     lst = []
     for i in range(1000):
         lst.append("帽子%s" %(i))             # 把多有的帽子放在内存的列表里,占得内存大
     return lst
 print(buy())

 def buy_gen():
     for i in range(1000):
         yield "帽子%s" %(i)           # 不是一次性全部把帽子0.......帽子999放在内存,
                                       # 而是通过__next__()一个一个取,比较省内存,但是不能往前执行,
                                       # 满足迭代器的三个特点
 gen = buy_gen()
 print(gen.__next__())
 print(gen.__next__())
 print(gen.__next__())
 print(gen.__next__())

如何满足迭代器的三个特点

 def baocaiming():
     print("蒸鹿茸")
     a = yield "蒸鹿茸yield"
     print("a=",a)
     print("蒸熊掌")
     b = yield "蒸熊掌yield"
     print("b=", b)
     print("烧花鸭")
     c = yield "烧花鸭yield"
     print("c=", c)
     print("烧子鹅")

 gen = baocaiming()
 print(gen.__next__())       # 第一次只能用__next__()取值
 print(gen.send("a++"))      # 从上一次停止的yield开始执行,并将"a++"传给上次yield之前的变量a, a == "a++"
 print(gen.send("b++"))
 print(gen.send("c++"))      # 函数里没有yield了,还继续调用,则报错,但是print("蒸熊掌")还是会继续执行的

生成器send()取值

　　send()取值方式机理?

2、各种推导式

　2.1  列表推导式

　　[ 结果  for循环  if条件 ]

 # 1到20 所有奇数的平方
 lst = [i**2 for i in range(20) if i % 2 == 1]
 print(lst)

 # 将 a = [3,6,9]   转化成---->   [(1,2,3),[4,5,6],[7,8,9]]
 print([(ele-2,ele-1,ele-0) for ele in a])

 # 查找名字里面有两个"e"的名字
 names = [
     ['Tom', 'Billy', 'Jefferson', 'Andrew', 'Wesley', 'Steven', 'Joe'],
     ['Alice', 'Jill', 'Ana', 'Wendy', 'Jennifer', 'Sherry', 'Eva'],
 ]
 print([r for i in names for r in i if r.count("e") == 2])

列表推导式

　2.2  字典、集合推导式

　　{结果  for循环  if条件}

 dic = {"张无忌":"赵敏", "杨过":"小龙女", "郭靖":"黄蓉"}   # 将键,值换成值,键
 new_dic = {v:k for k,v in dic.items()}
 print(new_dic)

 # lst = [11, 22, 33]  #  => {0:11, 1:22, 2:33}
 lst = [11, 22, 33]
 dic = {i:lst[i] for i in range(len(lst))}
 print(dic)

字典推导式

　2.3  生成器推导式

　　(结果  for循环  if条件)    注意: 不是元组推导式, 元组是没有推导式!

　　生成器表达式和列表推导式有什么不同?

　　　　1: 列表推导式是一次性加载完, 耗内存; 生成器表达式几乎不占内存, 只有取值时候才分配和使用内存;

　　　　2: 列表推导式得到的是一个列表, 生成器表达式得到的是一个生成器.

　2.4  生成器的惰性机制?

 def func():
     print(111)
     yield(222)
 g = func()                  #  生成器 g
 g1 = (i for i in g)         #  生成器 g1, g1数据来源于g
 g2 = (i for i in g1)        #  生成器 g2, g2数据来源于g1
 # --------------------------------截至到此,还没有生成器拿过值
                             # 惰性机制----只要不访问就永远拿不到值
 print(list(g))     # ----> [222]  获取到g中的数据,此时才执行func()函数,将222返回给g.
 print(list(g1))    # ----> []   list(g)已经将生成器g中的数据拿完了,所以g1拿不到数据,只能为[]
 print(list(g2))    # ----> []   g2和g1一样,拿不到值.

 # list() 的机理?  (list()包含了for循环的机理)
 #  list() ----> 包含了for循环 ----> 通过__iter__()将可迭代对象转化成了
 #         迭代器 ----> 通过__next__()从迭代器里取值 ----> 将拿到的值添加进列表里

生成器惰性机制

　2.5  yield from

　　　把可迭代对象中的每一个元素作为生成器的结果返回.

 def gen():
     lst = ["⿇花藤", "胡辣汤", "微星牌饼铛", "Mac牌锅铲"]
     lst2 = ["饼铛还是微星的好", "联想不能煮鸡蛋", "微星就可以", "还可以烙饼"]
     yield from lst          # 把 lst中的每一个元素作为生成器的结果返回给调用者.
     yield from lst2       # 两个yield不会产生交替的效果.

 g = gen()
 for el in g:
     print(el)

yield from