生成器 生成器表达式

 生成器 实质就是迭代器

有三种方式来获取生成器

1.通过生成器函数来获取生成器

def func():
    print("有yield的就是生成器")
    yield 111
ret = func()
print(ret)# 并不会执行func 函数 因为他有yield 打印的结果是一个生成器
ret.__next__() # 执行__next__()才会执行函数里面的代码
>>>>>>>>>>>>
<generator object func at 0x000000000201F750>
有yield的就是生成器

yield 和 return 的效果是一样的 yield是分段来执行的 而 return是直接终止函数

当程序运行完最后一个yield ,那么后面继续执行__next__()程序会报错.

def func():
    print("我是第一段")
    yield 111
    print("我是第二段")
    yield 222
    print("我是第三段")
    yield 333
ret = func()  # 拿到了生成器 并不会执行 func()函数
s1 = ret.__next__() # 使用生成器的next方法会执行 第一段代码 直到遇到yield会停止,并将结果返回给s1
print(s1)           #所以打印结果为 我是第一段 111
s2 = ret.__next__() 
print(s2)
s3 = ret.__next__()
print(s3)
>>>>>>>>>>>>
我是第一段
111
我是第二段
222
我是第三段
333

例子:现在有个需求:我打算跟某厂订购1000套衣服,厂子比较实在 一次性就给我干了1000套.

def cloth():
    lst = []
    for i in range(1, 101):
        lst.append(i)
    return lst
print(cloth())
>>>>>>
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100]

这么多我往哪放.现在也没那么多人,很尴尬,于是想到了 有没有一种 我要一套你给我一套的那种方法 ,

改进

这俩的区别是 第一种方法 很占内存 一次就都给拿出来  第二种 很好 用多少取多少.

send方法: send和__next__() 一样 都可以让生成器执行下一个yield.

send 和__next__的区别:

send 和 __next__一样都可以让生成器执行下一个yield

send 可以给上一个yield的位置传递值 不能给最后一个yield发送值,在第一次执行生成器代码的时候不能用send().

ef eat():
     print("我吃什么啊")
     a = yield "馒头"
     print("a=", a)
     b = yield "⼤饼"
     print("b=", b)
     c = yield "⾲菜盒⼦"
     print("c=", c)
     yield "GAME OVER"
gen = eat() # 获取⽣成器
ret1 = gen.__next__()
print(ret1)
ret2 = gen.send("胡辣汤")
print(ret2)
ret3 = gen.send("狗粮")
print(ret3)
ret4 = gen.send("猫粮")
print(ret4)
>>>>>>>>>>>>>>>>>>>>>
我吃什么啊
馒头
a= 胡辣汤
⼤饼
b= 狗粮
⾲菜盒⼦
c= 猫粮
GAME OVER

生成器也可以用for循环来获取内部元素:

def func():
 print(111)
 yield 222
 print(333)
 yield 444
 print(555)
 yield 666
gen = func()
for i in gen:
 print(i)
>>>>>>>>>>>>>
111
222
333
444
555
666

列表推导式, 生成器表达式以及其他推导式.

lst = []
for i in range(1,10):
    lst.append(i)
print(lst)
>>>>>>>>>>>>
lst = [i for i in range(1, 13)]
print(lst)
>>>>>>>>>>>>
lst = [i for i in range(1, 13) if i > 2]
print(lst)
>>>>>>>>>>>>>>>>>
[ 结果 for 变量 in 可迭代对象 if 条件 ]

生成器表达式和列表推导式的语法基本上是一样的. 只是把[]替换成()

gn = (i for i in range(1, 16))
print(gn)
>>>>>>>>>>>>>>
打印的结果是一个生成器,可以用for循环来遍历这个生成器得到生成器里面的各个元素
for c in gn:
    print(c)

生成器表达式与列表推导式的区别:

1.列表推导式比较耗内存,一次性加载,生成器表达式几乎不占内存,使用的时候才会分配内存和使用内存.

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

例子:比如同样是一篮子鸡蛋,列表推导式,直接拿到一篮子鸡蛋,生成器表达式,拿到一个母鸡,需要鸡蛋的时候才会给你鸡蛋

生成器惰性机制:生成器只有在访问的时候才会取值,说白了就是你找他要他才给你值,不找他要,他是不会执行的.

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)) # 获取g中的数据. 这时func()才会被执⾏. 打印111.获取到222. g完毕.
print(list(g1)) # 获取g1中的数据. g1的数据来源是g. 但是g已经取完了. g1 也就没有数据了
print(list(g2)) # 和g
>>>>>>>>
111
[222]
[]
[]

生成器=====> 要值得时候才拿值

k 跟 v 互换
dic = {'a': 1, 'b': '2'}
new_dic = {dic[key]: key for key in dic}
print(new_dic)
>>>>>>>>>>>>>>>>

推导式有  列表推导式 ,字典推导式 ,集合推导式, 没有元祖推导式.

生成器表达式: (结果 for 变量 in 可迭代对象 if 条件筛选)  

生成器表达式可以直接获取到生成器对象.生成器对象可以直接进行for循环.生成器有惰性机制.

def add(a, b):
  return a + b
def test():
 for r_i in range(4):
  yield r_i
g = test()
for n in [2, 10]:  # 不到最后不会拿值 ,所以最后拿的值是10  g 是 1,2,3
  g = (add(n, i) for i in g)
print(list(g))
print(list(g))