生成器函数 推导式

一,生成器的实质就是迭代器 

有三种方法获得生成器

1,通过生成器函数

2,通过各种推导式来实现生成器

3,通过数据的转换

def func():
　　print("111")
　　yield 222  #只要有yield 就是生成器函数
ret = func()#获取生成器  不再是普通的函数调用
print(ret)#得到  生成器的地址<generator object func at 0x10567ff68

def func():
　　print("111")
　　yield 222
gener = func() # 这个时候函数不会执行. 而是获取到生成器器
ret = gener.__next__() # 这个时候函数才会执行. yield的作用和return一样. 也是返回
数据
print(ret)
结果:
111
222

return和yield函数的作用是一样的,但是yield函数是分段来执行的.return是直接停止函数

def func():
　　print("111")
　　yield 222
　　print("333")
　　yield 444
gener = func()  #获取生成器
ret = gener.__next__() #调用第一个值
print(ret)
ret2 = gener.__next__()#调用第二个值
print(ret2)
ret3 = gener.__next__() # 最后⼀一个yield执行完毕. 再次__next__()程序报错, 也就是
说. 和return无关了了.
print(ret3)
结果:
111
Traceback (most recent call last):
222
333
File "/Users/sylar/PycharmProjects/oldboy/iterator.py", line 55, in
<module>
444
ret3 = gener.__next__() # 最后⼀一个yield执⾏行行完毕. 再次__next__()程序报错, 也
就是说. 和return⽆无关了了.
StopIteratio

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

send
当程序运行完最后一个yield. 那么后面继续进行__next__()程序会报错.
区别是send可以向上一个yield进行传值

def 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

send和__next__()区别:
1. send和next()都是让⽣生成器向下走⼀一次
2. send可以给上一个yield的位置传递值, 不能给最后一个yield发送值. 在第一次执行生成器代码的时候不能使用send()

生成器可以用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

二,各种推导式

简单的列表推导式  公式是 [结果,for循环,条件]
lst= [i for i in range(5)]
print(lst)  

lst= [i for i in range(5) if i %2 = 0]

lst = ['python%s' % i for i in range(1,15)]
print(lst)

集合推导式

lst = [1,1,2,2,34,5,5]
s = {i for i in lst}
print(s)


lst1 = [1,-1,2,2,-34,5,5]
s = {abs(i) for i in lst}
print(s)

字典推导式

dic = {'a': 1, 'b': '2'}
new_dic = {dic[key]: key for key in dic}
print(new_dic)
# 在以下list中. 从lst1中获取的数据和lst2中相对应的位置的数据组成⼀一个新字典
lst1 = ['jay', 'jj', 'sylar']
lst2 = ['周杰伦', '林林俊杰', '邱彦涛']
dic = {lst1[i]: lst2[i] for i in range(len(lst1))}
print(dic)

没有元组推导式

生成器表达式和列标推导式语法基本上是一致的,只要把[]换为()

# 获取1-100内能被3整除的数
gen = (i for i in range(1,100) if i % 3 == 0)
for num in gen:
　　print(num)

# 100以内能被3整除的数的平⽅方
gen = (i * i for i in range(100) if i % 3 == 0)
for num in gen:
print(num)

# 寻找名字中带有两个e的人的名字
names = [['Tom', 'Billy', 'Jefferson', 'Andrew', 'Wesley', 'Steven',
'Joe'],
['Alice', 'Jill', 'Ana', 'Wendy', 'Jennifer', 'Sherry', 'Eva']]
# 不用推导式和表达式
result = []
for first in names:
　　for name in first:
　　　　if name.count("e") >= 2:
　　　　　　result.append(name)
print(result)
# 推导式
gen = (name for first in names for name in first if name.count("e") >= 2)
for name in gen:
　　print(name)

列表推导式比较耗内存,一次性加载,生成器表达式获取的是一个生成器,几乎不占内存,使用的时候才进行调用和使用内存

生成器的特点
惰性机制
只能往前取值
省内存
=============================================================
敲代码反思内容

def func():
    print(111)
    yield 222
    print(333)
    yield 9
    yield "我是小仙女"
    print("你就是小仙女")
g = func()
# print(func().__next__())
# print(func().__next__())   #虽然调用了三次但是
# print(func().__next__())    #结果一直是111 222没有往下执行


# print(g.__next__())#调用三次,每次一段截止到yield,最终都打印出来了
# print(g.__next__())
# print(g.__next__())
# print(g.__next__())

#
# print(g.__next__())  #第一个必须用__next__()
# print(g.send("你是丑女"))   可以向上一个yield传值.
# # print(g._send("随便写一个值,不能空着"))   #最后一个yield不能进行赋值


# g1 = (i for i in g)  #得到一个生成器
# print(list(g1))     print后的数据优先打印, 然后将yield的数据返回到一个列表里
# print(list(g1))    走到底了   空列表

# g1 = (i for i in g)  # 得到一个生成器
# g2 = (i for i in g1) #得到一个生成器


# print(list(g1))   #   print后的数据优先打印, 然后将yield的数据返回到一个列表里
# print(list(g2))  #  值已经被取走   空列表

# for i in g:
#     print(i)
  #z最后一句print结尾的内容也打印出来了,循环次数多了一次本应该报错的,因为for 循环每部有try




lst = [1,2,3,3,4,]
a = lst.__iter__()  #成为迭代器
while 1:
    try:
        print(a.__next__())
    except StopIteration:
        break