生成器
首先我们来看看什么是个生成器,生成器本质就是迭代器
在python中有三种方式来获取生成器
1.通过生成器函数
2.通过各种推到式来实现生成器
3.通过数据的转换也可以获取生成器
首先,我们先看一个很简单的函数:
|
1
2
3
4
5
6
7
8
9
10
11
|
def
func():
print
(
11
)
return
22
ret
=
func()
print
(ret)
# 运行结果:
11
22
|
将函数中的return换成yield就是生成器
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
# 函数
def func():
print(
'这是函数func'
)
return
'函数func'
func()
# 生成器
def func1():
print(
'这是函数func1'
)
yield
'函数func'
func1()
|
运行的结果和上面的不一样,为什么呢?? 由于函数中存在yield,那么这个函数就是一个生成器函数.
|
1
2
3
4
5
6
7
8
9
|
def func1():
print(
'这是函数func1'
)
yield
'函数func'
print(func1())
结果:<generator
object
func1 at 0x0000023B3F280B48>
|
我们在执行这个函数的时候.就不再是函数的执行了.而是获取这个生成器.如何使用???
想想迭代器,生成器的本质就是迭代器.所以我们可以直接执行__next__()来执行以下生成器
|
1
2
3
4
5
6
7
8
9
|
def
func():
print
(
"111"
)
yield
222
gener
=
func()
# 这个时候函数不会执⾏. ⽽是获取到⽣成器
ret
=
gener.__next__()
# 这个时候函数才会执⾏. yield的作⽤和return⼀样. 也是返回数据
print
(ret)
结果:
111
222
|
那么我们可以看到,yield和return的效果是一样的,但是还是有点区别
yield是分段来执行一个函数
return是直接停止这个函数
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
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__()程序报错
print
(ret3)
结果:
111
222
333
444
|
当程序运行完最后一个yield,那么后面继续运行__next__()程序会报错
好了生成器我们说完了.生成器有什么作用呢?
我们来看一下这个需求,老男孩向楼下卖包子的老板订购了10000个包子.包子铺老板实在一下就全部都做出来了
|
1
2
3
4
5
6
7
8
9
10
|
def
eat():
lst
=
[]
for
i
in
range
(
1
,
10000
):
lst.append(
'包子'
+
str
(i))
return
lst
e
=
eat()
print
(e)
|
这样做是没有问题但是我们目前这么点人吃不完这么多,只能先放到一个地方,要是能够我吃一个老板做一个就完美了.
|
1
2
3
4
5
6
7
8
9
10
|
def
eat():
for
i
in
range
(
1
,
10000
):
yield
'包子'
+
str
(i)
e
=
eat()
print
(e.__next__())
print
(e.__next__())
print
(e.__next__())
print
(e.__next__())
print
(e.__next__())
print
(e.__next__())
|
上下的区别: 第一种是直接把包子都拿来,很占内存也就是很占咱们的位置,第二种使用生成器,想吃就拿一个.吃多少个包多少个.生成器是一个一个的,一直向下进行,不能向上.__next__()到哪,指针就指到哪儿.下一次继续就获取指针指向的值
接下来我们再来认识一个新的东西,send方法
send和__next__()一样都可以让生成器执行到下一个yield
|
1
2
3
4
5
6
7
8
9
10
11
|
def
eat():
for
i
in
range
(
1
,
10000
):
a
=
yield
'包子'
+
str
(i)
print
(
'a is'
,a)
b
=
yield
'窝窝头'
print
(
'b is'
, b)
e
=
eat()
print
(e.__next__())
print
(e.send(
'大葱'
))
print
(e.send(
'大蒜'
))
|
send和__next__()区别:
send 和 next()都是让生成器向下走一次
send可以给上一个yield的位置传递值,不能给最后一个yield发送值,在第一次执行生成器的时候不能使用send()
第一次调用的时候使用send()也可以但是send的参数必须是None
|
1
2
3
4
5
6
7
8
9
|
def func1():
print(
'这是函数func1'
)
f1 = yield
'你好'
print(f1)
f2 = yield
'我好'
print(f2)
f = func1()
f.__next__()
f.send(
'大家好'
)
|
生成器可以for循环来循环获取内部元素:
|
1
2
3
4
5
6
7
8
9
10
11
|
def
func():
yield
1
yield
2
yield
3
yield
4
yield
5
f
=
func()
for
i
in
f:
print
(i)
|
yield from
在python3中提供一种可以直接把可迭代对象中的每一个数据作为生成器的结果进行返回
|
1
2
3
4
5
6
|
def func():
lst = [
'卫龙'
,
'老冰棍'
,
'北冰洋'
,
'牛羊配'
]
yield
from
lst
g = func()
for
i
in
g:
print(i)
|
有个小坑,yield from 是将列表中的每一个元素返回,所以 如果写两个yield from 并不会产生交替的效果
|
1
2
3
4
5
6
7
8
9
|
def func():
lst1 = [
'卫龙'
,
'老冰棍'
,
'北冰洋'
,
'牛羊配'
]
lst2 = [
'馒头'
,
'花卷'
,
'豆包'
,
'大饼'
]
yield
from
lst1
yield
from
lst2
g = func()
for
i
in
g:
print(i)
|
推导式
列表推导式
列表推导式生成器表达式以及其他推导式,首先我们先看一下这样的代码,给出一个列表,通过循环,想列表中添加1~10:
|
1
2
3
4
5
|
li
=
[]
for
i
in
range
(
10
):
li.append(i)
print
(li)
|
我们换成列表推导式是什么样的,来看看:
列表推导式的常⽤写法:
[结果 for 变量 in 可迭代对象]
|
1
2
|
ls
=
[i
for
i
in
range
(
10
)]
print
(ls)
|
列表推导式是通过⼀行来构建你要的列表, 列表推导式看起来代码简单. 但是出现错误之
后很难排查.
例. 从python1期到python17期写入列表lst:
|
1
2
|
lst
=
[
'python%s'
%
i
for
i
in
range
(
1
,
18
)]
print
(lst)
|
筛选模式
[结果 for 变量 in 可迭代对象 if 条件]
|
1
2
3
|
print([i
for
i
in
range(10)
if
i > 3])
结果:
[4, 5, 6, 7, 8, 9]
|
生成器表达式
这个其实就将列表推导式俩边的中括号换成小括号就可以了,我们来看一下
|
1
2
3
4
5
6
7
8
|
l = (i
for
i
in
range(10))
print(l)
print(l.__next__())
print(l.__next__())
print(l.__next__())
print(l.__next__())
print(l.__next__())
|
print(l)的时候获取到是:
|
1
2
3
4
5
6
|
<generator
object
<genexpr> at 0x000001D8C7570B48>
0
1
2
3
4
|
生成器表达式也可以进行筛选
|
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
|
# 获取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
i
in
gen:
print(i)
|
生成器表达式和列表推导式的区别:
1. 列表推导式比较耗内存,一次性加载.生成器表达式几乎不占用内存.使用的时候才分配和使用内存
2. 得到的值不一样,列表推导式得到的是一个列表.生成器表达式获取的是一个生成器
举个例子:
李大锤想吃鸡蛋就上街买了一篮子的鸡蛋放家里,吃的时候拿一个吃的时候拿一个,这样就是一个列表推导式,一次性拿够占地方.
王二麻子也想吃鸡蛋,他上街却买了一只母鸡回家.等他想吃的时候就让母鸡给下鸡蛋,这样就是一个生成器.需要就给你下鸡蛋
生成器的惰性机制: 生成器只有在访问的时候才取值,说白了.你找他要才给你值.不找他要.他是不会执行的.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
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. 来源g1
print(list(g)) # 获取g中的数据. 这时func()才会被执行. 打印111.获取到222. g完毕.
print(list(g1)) # 获取g1中的数据. g1的数据来源是g. 但是g已经取完了. g1 也就没有数据了
print(list(g2)) # 和g1同理理
print(next(g))
print(next(g1))
print(next(g2)) # 可以用next来验证 其实list就是将内容迭代了转换成了列表
|
这是坑,一定要注意,生成器是要值的时候才能拿值,不然就没有啦
字典推导式
根据名字应该也能猜到,推到出来的是字典
|
1
2
3
4
|
lst1 = [
'jay'
,
'jj'
,
'meet'
]
lst2 = [
'周杰伦'
,
'林俊杰'
,
'郭宝元'
]
dic = {lst1[i]:lst2[i]
for
i
in
range(len(lst1))}
print(dic)
|
集合推导式
集合推导式可以帮我们直接生成一个集合,集合的特点;无序,不重复 所以集合推导式自带去重功能
|
1
2
3
|
lst = [1,2,3,-1,-3,-7,9]
s = {abs(i)
for
i
in
lst}
print(s)
|
总结:
推导式有, 列表推导式, 字典推导式, 集合推导式, 没有元组推导式
生成器表达式: (结果 for 变量量 in 可迭代对象 if 条件筛选)
生成器表达式可以直接获取到⽣成器对象. ⽣成器对象可以直接进行for循环. ⽣成器具有惰性机制.