python学习笔记:第12天 列表推导式和生成器

1. 迭代器

什么是生成器呢,其实生成器的本质就是迭代器;在python中有3中方式来获取生成器(这里主要介绍前面2种)

  • 通过生成器函数获取
  • 通过各种推导式来实现生成器

生成器函数

我们来看一个普通的函数:

In[2]: def func1():
...: print('aaaa')
...: return 1111
...:
In[3]: fun = func1()
aaaa
In[4]: print(fun)
1111

那么生成器函数跟普通函数有什么不同呢,我们只要把其中的return换成yield关键字参数就是生成器函数了:

In[5]: def func1():
...: print('aaaa')
...: yield 1111
...:
In[6]: fun = func1() # 此时并没有任何打印信息,可以说明函数并没有执行
In[7]: print(fun) # 从输出可以看出这是一个生成器对象
<generator object func1 at 0x0000016F900D6DB0>

从上面的结果来看,我们发现函数func1根本就没有执行,而最后打印的是一个内存地址,这个就是生成器很明显的一个特性:惰性计算,那么我们要怎么执行它呢?我们可以回顾一下迭代器的取值方法:使用迭代器的__next__的方法可以取到迭代器的一个值,那生成器的本质就是迭代器,那我们也可以试下可以这样取值

In[8]: fun.__next__() # 从输出可以看出,yield也和return一样可以有返回值
aaaa # 这里我们就可以看到函数中的aaaa也打印了,表示函数在此处才执行
Out[8]: 1111

我们再来看个例子,观察下生成器是怎么工作的:

In[9]: def func1():
...: print('aaaa')
...: yield '我是第一个yield'
...: print('bbbb')
...: yield '我是第二个yield'
...: print('cccc')
...:
In[10]: gen = func1() # 这里得到的是一个生成器,此处并不会运行函数
...: print(gen)
<generator object func1 at 0x0000016F900F8BA0>
In[11]: print(gen.__next__()) # 首次执行生成器的__netx__()函数时,开始执行函数,
aaaa # 直到遇到yield时返回,并且yield也可以有返回值
我是第一个yield
In[12]: print(gen.__next__()) # 再次运行__netx__()函数时,会继续执行函数(从上次yield的位置继续执行)
bbbb
我是第二个yield
In[13]: print(gen.__next__()) # 再次执行__next__()方法继续执行,此处再往下执行时没有了yield关键字,
cccc # 会抛出StopIteration异常(但时会执行后面的代码)
Traceback (most recent call last):
File "D:\Environment\python-virtualenv\jupyter\lib\site-packages\IPython\core\interactiveshell.py", line 3265, in run_code
exec(code_obj, self.user_global_ns, self.user_ns)
File "<ipython-input-13-9340d28f24b7>", line 1, in <module>
print(gen.__next__())
StopIteration

从上面我们呢可以总结出:

  • yield也可以像return一样也是返回值
  • yield执行完之后会返回到调用者,执行后续的代码,直到再次调用__next__方法,此时生成器函数再从上次停止的位置继续执行
  • 当执行__next__方法后没有yield关键字时,会抛出StopIteration异常,但是会执行yield后面的代码

send方法

接下来我们来看send⽅法, send和__next__()⼀样都可以让⽣成器执⾏到下⼀个yield

In[14]: def eat():
...: print("aaaa")
...: a = yield 1111
...: print("a=",a)
...: b = yield "bbbb"
...: print("b=",b)
...: c = yield "cccc"
...: print("c=",c)
...: yield "GAME OVER"
...:
In[15]: gen = eat() # 获取⽣成器
In[16]: ret1 = gen.__next__()
...: print(ret1)
aaaa
1111
In[17]: ret2 = gen.send("我send了一个参数给a")
...: print(ret2)
a= 我send了一个参数给a # 可以看出send的数据是被上一个yield前的a给接收了
bbbb
In[18]: ret3 = gen.send("我send了一个参数给b")
...: print(ret3) # 这里send的数据也是被b接收了
b= 我send了一个参数给b
cccc
In[19]: ret4 = gen.send("我send了一个参数给c")
...: print(ret4)
c= 我send了一个参数给c
GAME OVER

send和__next__():

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

2. 推导式

列表推导式

关于列表推导式,其实之前的文章中已经使用过,这里再正式介绍下;假设我们要打印1到20之间的奇数,照之前正常的写法我们要这么写:

# 假设有一个需求,要写一个循环遍历1到20之间所有的奇数
lst = []
for i in range(1, 21):
if i % 2 == 1:
lst.append(i)
print(lst)
# 结果:
# [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]

列表推导式的语法为:

  • 第一种只使用for循环遍历
[expr for item in itratorable]

# 相当于以下代码
ret = []
for item in iterable:
ret.append(expr)
  • 第二种for循环遍历再加if条件判断
[expr for item in iterable if cond]

# 相当于以下结构代码
ret = []
for item in iterable:
if cond:
ret.append(expr)

第三种for循环加if双分支结构,注意此时的if/else语句要写在for语句前面

[expr1 if cond else expr2 for item in iterable ]

# 相当于以下代码
ret = []
for item in iterable:
if cond:
ret.append(expr1)
else:
ret.append(expr2)

对于上面的例子使用列表推导式可以这样写:

# 使用推导式:
lst = [i for i in range(1, 21) if i % 2 == 1]
print(lst)
# 结果:
# [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]

使用列表推导式我们可以发现代码时精简了许多,而且代码的可读性更高了,其实还有一个优势是推导式速度更快:

In [1]: %%timeit
...: lst1 = []
...: for i in range(10000):
...: lst1.append(i)
...:
788 µs ± 14.9 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each) In [2]: %%timeit
...: lst1 = [i for i in range(10000)]
...:
307 µs ± 1.84 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each) In [3]:

从上面的结果分析,使用列表推导式生成列表的方式要比普通for循环的效率要高很多

字典推导式

字典跟列表推导式的语法非常相似,使用{}括起来,然后在里面想列表推导式一样写自己的表达式即可:

dic = {expr for k, v in iterable if cond}        # 这里的expr表达式可以写成:k: v的形式

# 相当于以下代码
dic = dict()
for k, v in iterable:
if cond:
expr(dic)

例如,把字典中的键值对都调换以下可以用如下方法:

dic = {"张无忌":"赵敏", "杨过":"小龙女", "郭靖":"黄蓉"}
# dic = {'k1':'v1', 'k2': 'v2', 'k3': 'v3'} dic = {v: k for k, v in dic.items()}
print(dic)

生成器表达式

对于生成器表达式来说,只需要把列表推导式的中括号换成小括号就可以了:

In[20]: def inc(x):
...: print('inc {0}'.format(x))
...: return x+1
...:
In[21]: g = (inc(x) for x in range(10)) # 这里的g就是一个生成器对象
In[22]: print(g)
<generator object <genexpr> at 0x0000016F90161DB0>
In[23]: print(g.__next__())
inc 0
1
In[24]: print(g.__next__()) # 也可以使用__next__方法取出一个值
inc 1
2
In[25]: print(g.__next__())
inc 2
3
In[26]: next(g) # 使用netx()和__next__()方法是一样的
inc 3
Out[26]: 4
In[27]: next(g)
inc 4
Out[27]: 5

当然,生成器表达式也可以跟其他推导式一样套用if语句,其语法都是一样的,这里就不做介绍了。

⽣成器表达式和列表推导式的区别:

  • 列表推导式比较耗内存. ⼀次性加载. ⽣成器表达式⼏乎不占⽤内存. 使⽤的时候才分

    配和使⽤内存

  • 得到的值不⼀样. 列表推导式得到的是⼀个列表. ⽣成器表达式获取的是⼀个⽣成器.

⽣成器的惰性机制: ⽣成器只有在访问的时候才取值. 说⽩了. 你找他要他才给你值. 不找他

要. 他是不会执⾏的.

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同理
# 注:list中有for的调用,可以迭代遍历生成器元素
#结果:
# 1111
# [222]
# []
# []

访问生成器的另一种方法

使用yield from iterator语句

In[28]: def test():
...: l1 = [1, 2, 3, 4]
...: l2 = ['a', 'b', 'c', 'd']
...: yield from l1 #
...: yield from l2
...:
In[29]: g = test()
In[30]: for i in g:
...: print(i)
...:
1
2
3
4
a
b
c
d
上一篇:php学习网站推荐


下一篇:用MVC5+EF6+WebApi 做一个考试功能(六) 仓储模式 打造EF通用仓储类