Python:生成器

2023-01-31 02:01:18 python 生成器

    生成器是python中的一个高级用法,有段时间我对生成器的理解颇为费劲,直到我看到一句话“yield语句挂起该生成器函数的状态,保留足够的信息,以便之后从它离开的地方继续执行”后,让我恍然大悟,这是生成器中的状态挂起,这句话让我想起了在大学时玩ARM单片机时经常碰到的一个概念——中断,单片机在遇到中断信号时,处理中断程序前也要先保护现场,即系统要在执行中断程序之前,必须保存当前处理机程序状态字PSW和程序计数器PC等的值,待中断程序执行完成后在回复现场继续执行下面的程序。仔细想想,个人觉得在保护“现场”这一点上,两者中的道理还是差不多的(也许你并不这么认同),有时候一个新概念的理解就是卡在一个小知识点上,我之前一直不明白“生成器挂起状态”是什么东西,但是回头瞬间想起以前学过的知识,然后类比,有些东西也就恍然大悟了,也是这个“联想”让我对生成器有了更深刻的理解,使用起来也得心应手。现在工作当中,特别是在做数据统计时,碰到了特别长的列表时,我都是用生成器,不进可以节省内存,而且代码更加优雅。下面就来讲讲生成器,不正之处欢迎批评指正!

   生成器就是按照一定算法生产的序列,也就是序列元素可以按照某种算法推算出来,即在循环的过程中不断推算出后续的元素,这样就不必创建完整的序列,从而节省大量的空间。在Python中,这种一边循环一边计算的机制,称为生成器(Generator)。

(一)生成器语法

生成器表达式: 通列表解析语法,只不过把列表解析的[]换成()

生成器表达式能做的事情列表解析基本都能处理,只不过在需要处理的序列比较大时,列表解析比较费内存。

>>> L = [x * x for x in range(10)]
>>> L
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> g = (x * x for x in range(10))
>>> g
<generator object <genexpr> at 0x104feab40>

L是一个list,而g是一个generator。如果要一个一个打印出来,可以通过generator的next()方法。每次调用next(),就计算出下一个元素的值,直到计算到最后一个元素,没有更多的元素时,抛出StopIteration的错误。这里就不过多阐述,大家可以在终端试试,不断执行g.next(),同时可以用sys.getsizeof()来比较下L和g所用内存的大小,这里列表元素比较少,看不出生成器的优势,但是,对于g,把推到式中的range(10)改成range(100),range(100),g所占内存是不会改变的,大家可以试试。


生成器函数: 在函数中如果出现了yield关键字,那么该函数就不再是普通函数,而是生成器函数。

但是生成器函数可以生产一个无限的序列,这样列表根本没有办法进行处理。yield 的作用就是把一个函数变成一个 generator,带有 yield 的函数不再是一个普通函数,Python 解释器会将其视为一个 generator。

def gensquares(N):
    for i in range(N):
        yield i ** 2 
        
for item in gensquares(5):
    print item

这是个简单的例子,使用生成器返回自然数的平方。


(二)生成器的方法

我们可以用dir()函数来看看生成器对象的方法,如下:

['__class__', '__delattr__', '__doc__', '__fORMat__', '__getattribute__', '__hash__', '__init__', '__iter__', '__name__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'close', 'gi_code', 'gi_frame', 'gi_running', 'next', 'send', 'throw']


它里面有__iter__()和next()方法,这不就是迭代器协议要满足的两个基本条件吗?(不了解迭代器协议,可以看之前的博文,点此)也就是说生成器是一个特殊的迭代器。

close()

手动关闭生成器函数,后面的调用会直接返回StopIteration异常。看下面简单例子:

wKiom1hLkvjBvTB5AABZKcZX7Ls839.png-wh_50

    

send()

生成器函数最大的特点是可以接受外部传入的一个变量,并根据变量内容计算结果后返回。

这是生成器函数最难理解的地方,也是最重要的地方。

首先看个简单的例子

#coding=utf-8
def fun(value=None):
    print "begin"

    while 1:
        try:
            value = (yield value)
            print "yield"
        except Exception,e:
            value = e


g = fun(8)
print g.next()
print "==============="
print g.next()
print "==============="
print g.next()

运行结果如下:

wKioL1hLroeTDTlYAAAw15CTFsM013.png-wh_50

    由上图的运行结果可知,生成器函数调用后,它的函数体并没有执行,而是到第一次调用next()时才开始执行,而且是执行到yield表达式为止,此时就要状态挂起,第二次调用next()时再恢复之前的挂起状态接着执行,所以第一次执行next()时,并没有打印出"yield",到第二次调用next()时,第一个执行的就是print "yield"语句,所以也就打印出了"yield",直到再次遇到yield表达式,然后再挂起,依次类推。

这里还要提到一点就是yield表达式,第一次调用next()时,value = yield v语句中只执行了yield v这个表达式,而赋值操作并未执行。只有第二次调用next()时yield表达式的值赋给了value,而yield表达式的默认“返回值”是None.

这一块大家可以参考这篇博文

在函数里单独的yield 5 与m = yield 5还是有区别的。

这可能有点难理解,举个例子来验证下:

#coding=utf-8
class A(object):
    def __init__(self,v):
        self._value = v
    def fun(self,value):
        print "begin"
        while 1:
            try:
                self._value = (yield value)
                print "aaa",self._value
                print "yield"
            except Exception,e:
                self._value = e

G = A(8)
g = G.fun(88)
print "_value  " ,  G._value
print g.next()
print "_value  " ,G._value
print "==============="
print g.next()
print "_value  " ,G._value
print "==============="
print g.next()
print "_value  " ,G._value

运行结果如下:

wKiom1hLtdnzXFJVAABIR1AiII8552.png-wh_50

从运行结果上来看,第一次调用next()时,G._value的值并没有改变,说明此时self._value = (yield value)并没有执行赋值操作,第二次调用next()时,G._value的值改变了,为None,说明执行了赋值操作。


有了上面的一些基础,理解send()方法应该很容易,看下面例子:

#coding=utf-8
def fun(v):
    while 1:

        value = (yield v)
        if value == 14:
            break
        v = 'get: %s' % value

g = fun(None)
print g.send(None)
print g.send(10)
print g.send(12)
print g.send(14)


执行流程:

1.通过g.send(None)或者next(g)可以启动生成器函数,并执行到第一个yield语句结束的位置。

此时,执行完了yield语句,但是没有给value赋值。注意:在启动生成器函数时只能send(None),如果试图输入其它的值都会得到错误提示信息。这里,如果你去掉g.send(None)这句,就会报错。

2.通过g.send(10),会传入10,并赋值给value,然后计算出v的值,并回到while头部,执行yield v语句有停止。此时会输出"get: 10",然后挂起。

3.通过g.send(12),会重复第2步,最后输出结果为"Got:12"

4.当我们g.send(14)时,程序会执行break然后推出循环,最后整个函数执行完毕,所以会是StopIteration异常。

wKiom1hLwzTTePp4AABPlYMLy1A260.png-wh_50



其实,send()是全功能版本的next(),next()相当于send(None),前面提到过yield表达式有“返回值”,send()作用就是控制这个“返回值”的,使得yield表达式的返回值是它的实参。

这一句要好好理解,看上面的例子,最后打印出来的值都是函数中v的值(也就是实参)。

throw()

用来向生成器函数送入一个异常,可以结束系统定义的异常,或者自定义的异常。

throw()后直接抛出异常并结束程序,或者消耗掉一个yield,或者在没有下一个yield的时候直接进行到程序的结尾。

#coding=utf-8
def gen():
    while True:
        try:
            yield 'normal value'
            yield 'normal value 2'
            print('here')
        except ValueError:
            print('we got ValueError here')
        except TypeError:
            break

g=gen()
print next(g)
print g.throw(ValueError)
print next(g)
print g.throw(TypeError)

1.print next(g):会输出normal value,并停留在yield 'normal value 2'之前。

2.由于执行了g.throw(ValueError),所以会跳过所有后续的try语句,也就是说yield 'normal value 2'不会被执行,然后进入到except语句,打印出we got ValueError here。然后再次进入到while语句部分,消耗一个yield,所以会输出normal value。然后状态挂起。

3.print next(g),会执行yield 'normal value 2'语句,并停留在执行完该语句后的位置。

4.g.throw(TypeError):会跳出try语句,从而print('here')不会被执行,然后执行break语句,跳出while循环,然后到达程序结尾,所以跑出StopIteration异常。

最后运行结果如下:

wKiom1hLxxOjhC2SAABWgtuh7gQ091.png-wh_50


生成器的主要三个方法中,send()方法是比较难理解的,不过只要记住send()作用就是控制yield表达式“返回值”的,使得yield表达式的返回值是它的实参。

最后总结起来就这么几句:

1.生成器就是一种迭代器,可以使用for进行迭代。

2.第一次执行next(generator)时,会执行完yield语句后程序进行挂起,所有的参数和状态会进行保存。再一次执行next(generator)时,会从挂起的状态开始往后执行。在遇到程序的结尾或者遇到StopIteration时,循环结束。

3.生成器函数和常规函数几乎是一样的。它们都是使用def语句进行定义,差别在于,生成器使用yield语句返回一个值,而常规函数使用return语句返回一个值

4.可以通过generator.send(arg)来传入参数,这是协程模型。

5.可以通过generator.throw(exception)来传入一个异常。throw语句会消耗掉一个yield。

6.可以通过generator.close()来手动关闭生成器。

7.next()等价于send(None)



相关文章