## 1\. 生成器和生成器函数
```
生成器的本质就是迭代器
生成器的三种创建办法:
1.通过生成器函数
2.通过生成器表达式创建生成器
3.通过数据转换
```
## 2\. 生成器函数:
函数中包含了yield的就是生成器函数
注意:生成器函数被执行. 获取到的是生成器. 而不是函数的执行生成器表达式:
(结果 for 变量 in 可迭代对象 if 筛选)
取值:
### 1\. \_\_next\_\_()
```c
def func():
print("我是周杰伦")
yield "昆凌" \# 函数中包含了yield, 当前这个函数就不再是普通的函数了. 是生成器函数
g = func()
print(g.\_\_next\_\_())
print(func().\_\_next\_\_())
g1 = func()
g2 = func()
print(g1.\_\_next\_\_())
print(g1.\_\_next\_\_())
print("==============")
print(g2.\_\_next\_\_())
g = func() \# 通过函数func()来创建一个生成器
print(g.\_\_next\_\_()) \# 周杰伦
print(g.\_\_next\_\_()) \# 王力宏
print(g.\_\_next\_\_()) \# 笛卡尔积
print(g.\_\_next\_\_())
\# return 直接返回结果. 结束函数的调用
\# yield 返回结果.可以让函数分段执行
\#
def func():
lst = []
for i in range(1,100001):
lst.append("衣服%s" % i)
return lst
def gen():
i = 1
while i \< 100001:
yield "衣服%s" % i
i = i + 1
g = gen()
print(g.\_\_next\_\_())
print(g.\_\_next\_\_())
print(g.\_\_next\_\_())
print(g.\_\_next\_\_())
print(g.\_\_next\_\_())
print(g.\_\_next\_\_())
def func():
yield 11
yield 22
yield 33
yield 44
g = func() \# 拿到的是生成器. 生成器的本质是迭代器. 迭代器可以被迭代 生成器可以直接for循环
for i in g:
print(i) \# 本质上执行的是\_\_next\_\_()
it = g.\_\_iter\_\_()
while True:
try:
print(it.\_\_next\_\_())
except StopIteration:
break
```
2\. send(值) 给上一个yield位置传一个值, 第一个和最后一个yield不用传值
```c
def func():
print("大碴粥")
a = yield "11"
print(a)
print("狗不理")
b = yield "22"
print(b)
print("大麻花")
c = yield "33"
print(c)
g = func()
print(g.__next__())
print(g.send(1))
print(g.send(2))
print(g.send(3))
# __next__() 可以让生成器向下执行一次
# send() 也可以让生成器向下执行一次, 给上一个yield传一个值, 第一个不能用send(). 最后一个也不要传值
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)
def func():
yield 11
yield 22
yield 33
yield 44
g = func()
lst = list(g) # 可迭代对象
print(lst)
```
3\\. 可以for循环
4\\. list(g)
2\. 各种推倒式和生成器表达式
```c
# 生成列表 里面装1-14的数据
lst = []
for i in range(1,15):
lst.append("python%s" % i)
print(lst)
# 列表推倒式; 最终给你的是列表
# 语法 [最终结果(变量) for 变量 in 可迭代对象]
lst = [i for i in range(1,15)]
print(lst)
# [最终结果 for 变量 in 可迭代对象 if 条件]
lst = [i for i in range(1,101) if i%2==0]
print(lst)
# 1. 获取1-100内能被3整除的数
lst = [i for i in range(1,101) if i % 3 == 0]
# 2. 100以内能被3整除的数的平方
lst = [i*i for i in range(1,101) if i % 3 == 0]
# 3. 寻找名字中带有两个e的⼈的名字
names = [['Tom', 'Billy', 'Jefferson' , 'Andrew' , 'Wesley' , 'Steven' ,
'Joe'],['Alice', 'Jill' , 'Ana', 'Wendy', 'Jennifer', 'Sherry' , 'Eva']]
lst = [name for first in names for name in first if name.count("e") == 2]
print(lst)
lst = ["衣服%s" % i for i in range(10000)]
```
```c
g = (i for i in range(10))
print(list(g))
gen = ("麻花藤我第%s次爱你" % i for i in range(10))
for i in gen:
print(i)
```
\# 生成器的惰性机制
```c
def func():
print(111)
yield 222
g = func()
g1 = (i for i in g)
g2 = (i for i in g1)
print(list(g))
print(list(g1))
print(list(g2))
```
1\. 列表推倒式 [结果 for 变量 in 可迭代对象 if 筛选]
2\. 字典推倒式 {结果 for 变量 in 可迭代对象 if 筛选} 结果=\\\\\\\>key:value
```c
dic = {"a":"b", "c":"d"}
# 把字典中的key:value互换 .{"b":"a", "d":"c"}
new_dic = {dic[key]:key for key in dic}
print(new_dic)
lst1 = ["alex", "wusir", "taibai", "ritian"]
lst2 = ['sb', "很色", "很白", "很牛"]
# {"alex":"sb", "wusir":"很色"}
dic = { lst1[i]:lst2[i] for i in range(len(lst1))}
print(dic)
```
3\. 集合推倒式 {结果 for 变量 in 可迭代对象 if 筛选} 结果=\\\\\\\>key
```c
lst = ["马化腾", "马化腾", "王建忠", "张建忠", "张建忠", "张雪峰", "张雪峰"]
s = {i for i in lst} # 集合推倒式
print(s)
```
