python生成器和python装饰器几乎平起平坐,在python世界中占有重要的地位。如果说python装饰器是为了让程序员悄无声息拓展函数功能,那么python生成器就是为了让你的代码更省资源,更高效!说实话python生成器的抽象程度和灵活程度都要比python装饰器高,功能也更加强大,所以我也只能暂时比较粗略地说句“python生成器就像一把瑞士军刀,让你的代码更加短小(简洁)精悍(有力)”。
首先我们来看一段python2环境下运行的一段代码:
#注意,在python3.x中range和xrange已被合并,这段代码运行必须在py2下!
for i in range(3):
print(i)
print('----------')
for i in xrange(3):
print(i)
print('----------')
lst1 = [x*x for x in range(3)]
lst2 = (x*x for x in range(3))
for i in lst1:
print(i)
print('----------')
for i in lst2:
print(i)
打印结果如下:
0
1
2
----------
0
1
2
----------
0
1
4
----------
0
1
4
看了这段代码,你可能会说:python真麻烦,有range又有xrange,有[]又有(),运行结果还一样。这不是白费事嘛?
那我们现在稍微改动下代码:
a = range(3)
b = xrange(3)
print(type(a))
print(a)
print(a[0],a[1])
print('---------')
print(type(b))
print(b)
print(b[0],b[1])
print('---------')
lst1 = [x*x for x in range(3)]
lst2 = (x*x for x in range(3))
print(type(lst1))
print(type(lst2))
打印结果如下:
'list'>
[0, 1, 2]
(0, 1)
---------
'xrange'>
xrange(3)
(0, 1)
---------
'list'>
'generator'>
这里需要说明:range()返回一个列表list,xrange()返回一个生成器;也即[]返回一个列表list而()返回一个生成器。
* 注意:用[]推导出来的是迭代器(Iterables)。用()推导出来的是生成器(Generators)。*
可迭代对象(iterable) 与 迭代器(iterator)
iterable可迭代对象是实现了__iter__()方法的对象。更确切的说,是container.__iter__()方法,该方法返回的是的一个iterator对象,因此你可以从iterable可迭代对象获得iterator迭代器。
在python中,迭代通常是通过for … in …来完成的,而且只要是可迭代对象(iterable),都能进行迭代。
例如,在下面的遍历中
for value in something
这个something就是一个可迭代对象(iterable)。比如list,string,file。
对于iterable,我们该关注的是,它是一个能一次返回一个成员的对象(iterable is an object capable of returning its members one at a time),一些iterable将所有值都存储在内存中,比如list,而另一些并不是这样,比如我们下面将讲到的iterator。
iterator(迭代器)是这样的对象:实现了无参的__next__() 方法,返回序列中的下一个元素;如果没有元素,将会抛出StopIteration异常。Python的迭代器也实现了__iter__()方法,所以一个迭代器(iterator)也是可迭代的(iterable)。
iterator.next()是iterator区别于iterable的关键了,它允许我们显式地获取一个元素.当调用next()方法时,实际上产生了2个操作:
二者的关系如下 :
iter(可迭代对象) 生成迭代器
>>> s = 'abc' #s是一个可迭代对象
>>> it = iter(s) #it是一个迭代器
>>> for i in it:
... print(i)
我们现在不用for循环遍历这个迭代器,我们尝试调用next()方法。
>>> s = 'abc'
>>> it = iter(s)
>>> next(it)
'a'
>>> s = 'abc'
>>> it = iter(s)
>>> next(it)
'a'
>>> next(it)
'b'
>>> next(it)
'c'
>>> next(it)
Traceback (most recent call last):
File "" , line 1, in
StopIteration
>>>
除了最后一行抛出异常外,其他结果和for循环一样。也就是说,用for循环遍历迭代器(iterator)X时,会循环地调用X的next()方法取得每一次的值,直到iterator为空,返回的StopIteration作为循环结束的标志。for … in … 会自动处理StopIteration异常,从而避免了抛出异常而使程序中断。
我们对一个可迭代对象(iterable)用for … in …进行迭代时,实际是先通过调用iter()方法得到一个iterator,假设叫做X.然后循环地调用X的next()方法取得每一次的值,直到iterator为空,返回的StopIteration作为循环结束的标志.for … in … 会自动处理StopIteration异常,从而避免了抛出异常而使程序中断.
需要格外注意的是,iterator是消耗型的,即每一个值被使用过后,就消失了.因此,你可以将以上的操作2理解成pop.对iterator进行遍历之后,其就变成了一个空的容器了,但不等于None哦.因此,若要重复使用iterator,利用list()方法将其结果保存起来是一个不错的选择。
代码如下:
>>> from collections import Iterable, Iterator
>>> a = [1,2,3] # 众所周知,list是一个iterable
>>> b = iter(a) # 通过iter()方法,得到iterator,iter()实际上调用了__iter__(),此后不再多说
>>> isinstance(a, Iterable)
True
>>> isinstance(a, Iterator)
False
>>> isinstance(b, Iterable)
True
>>> isinstance(b, Iterator)
True
# 可见,itertor一定是iterable,但iterable不一定是itertor
# iterator是消耗型的,用一次少一次.对iterator进行变量,iterator就空了!
>>> c = list(b)
>>> c
[1, 2, 3]
>>> d = list(b)
>>> d
[]
# 空的iterator并不等于None.
>>> if b:
... print(1)
...
1
>>> if b == None:
... print(1)
...
# 再来感受一下next()
>>> e = iter(a)
>>> next(e) #next()实际调用了__next__()方法,此后不再多说
1
>>> next(e)
2
生成器概念
只要 Python 函数的定义体中有 yield 关键字,该函数就是生成器函数。调用生成器函数时,会返回一个生成器对象。也就是说,生成器函数是生成器工厂。
函数返回一个值,而生成器函数生成一个值。不仅如此,函数返回值后就退出了,而生成器可以生产多次值,生成器函数中还能出现多个yield。
如何“生成”生成器
如何产生一个生成器呢,方法有二:
1.生成器函数(generator function):带有yield关键字的函数就是生成器函数,它的返回值是个生成器。
2.生成器表达式(generator expression):而形如(elem for elem in [1, 2, 3])的表达式,称为generator expression,也能产生一个生成器。
生成器表达式生成生成器:
>>> gen = ( i for i in [2,3,4,5,6])
>>> gen
at 0x00000178D648D1A8>
>>> for i in gen:
... print(i)
...
2
3
4
5
6
我们调用next()方法,也是可以的:
>>> gen = ( i for i in [2,3,4,5,6])
>>> next(gen)
2
>>> next(gen)
3
>>> next(gen)
4
>>> next(gen)
5
>>> next(gen)
6
>>> next(gen)
Traceback (most recent call last):
File "" , line 1, in <module>
StopIteration
这和我们上面迭代器(iterator)的使用一毛一样!
其实,生成器(generator)就是迭代器(iterator)的一种,以更优雅的方式实现的iterator,而且完全可以像使用iterator一样使用generator。当然除了定义,定义一个iterator,你需要分别实现_ _ iter _ _ ()方法和 _ _ next_ _()方法,但generator只需要一个yield关键字就可以。
生成器函数产生生成器
>>> def gen123():
... yield 1
... yield 2
... yield 3
...
>>> gen123
<function gen123 at 0x00000178D6614D08>
>>> gen123()
0x00000178D648D1A8>
>>> for i in gen123():
... print(i)
...
1
2
3
这里你也能猜出来,我们调用next()方法除了会抛出异常,效果也一样:
>>> def gen123():
... yield 1
... yield 2
... yield 3
...
>>> gen = gen123()
>>> next(gen)
1
>>> next(gen)
2
>>> next(gen)
3
>>> next(gen)
Traceback (most recent call last):
File "" , line 1, in
StopIteration
其实 ,for循环会每次隐时调用next()方法,前进到函数中的下一个yield语句处。
生成器函数执行过程
生成器另外一个黑科技是生成器中的yield语句会挂起该生成器函数的状态,保留足够的信息,以便之后从它离开的地方继续执行。
我们来看代码:
>>> def genAB(): #❶
... print('start')
... yield 'A' #❷
... print('continue')
... yield 'B' #❸
... print('end') #❹
...
>>> for i in genAB(): #❺
... print('--->',i) #❻
...
打印结果:
start
---> A
continue
---> B
end
❶ 定义生成器函数的方式与普通的函数无异,只不过要使用 yield 关键字。
❷ 在 for 循环中第一次隐式调用 next() 函数时(序号➎),会打印
‘start’,然后停在第一个 yield 语句,生成值 ‘A’。
❸ 在 for 循环中第二次隐式调用 next() 函数时,会打印
‘continue’,然后停在第二个 yield 语句,生成值 ‘B’。
❹ 第三次调用 next() 函数时,会打印 ‘end.’,然后到达函数定义体
的末尾,导致生成器对象抛出 StopIteration 异常。
❺ 迭代时,for 机制的作用与 g = iter(gen_AB()) 一样,用于获取
生成器对象,然后每次迭代时调用 next(g)。
❻ 循环块打印 –> 和 next(g) 返回的值。但是,生成器函数中的
print 函数输出结果之后才会看到这个输出。
❼ ‘start’ 是生成器函数定义体中 print(‘start’) 输出的结果。
❽ 生成器函数定义体中的 yield ‘A’ 语句会生成值 A,提供给 for 循
环使用,而 A 会赋值给变量 i,最终输出 –> A。
❾ 第二次调用 next(g),继续迭代,生成器函数定义体中的代码由
yield ‘A’ 前进到 yield ‘B’。文本 continue 是由生成器函数定义
体中的第二个 print 函数输出的。
❿ yield ‘B’ 语句生成值 B,提供给 for 循环使用,而 B 会赋值给变
量 c,所以循环打印出 –> B。
⓫ 第三次调用 next(it),继续迭代,前进到生成器函数的末尾。文本
end. 是由生成器函数定义体中的第三个 print 函数输出的。到达生成
器函数定义体的末尾时,生成器对象抛出 StopIteration 异常。for
机制会捕获异常,因此循环终止时没有报错。