生成器
生成器(generator)也是一种迭代器,在每次迭代时返回一个值,直到抛出 StopIteration
异常。它有两种构造方式:
- 生成器表达式
和列表推导式的定义类似,生成器表达式使用 ()
而不是 []
,比如:
numbers = (x for x in range(5)) # 注意是(),而不是[] for num in numbers: print num
- 生成器函数
含有 yield
关键字的函数,调用该函数时会返回一个生成器。
本文主要讲生成器函数。
生成器函数
先来看一个简单的例子:
>>> def generator_function(): ... print 'hello 1' ... yield 1 ... print 'hello 2' ... yield 2 ... print 'hello 3' >>> >>> g = generator_function() # 函数没有立即执行,而是返回了一个生成器,当然也是一个迭代器 >>> g.next() # 当使用 next() 方法,或使用 next(g) 的时候开始执行,遇到 yield 暂停 hello 1 1 >>> g.next() # 从原来暂停的地方继续执行 hello 2 2 >>> g.next() # 从原来暂停的地方继续执行,没有 yield,抛出异常 hello 3 Traceback (most recent call last): File "<stdin>", line 1, in <module> StopIteration
可以看到,上面的函数没有使用 return
语句返回值,而是使用了 yield
『生出』一个值。一个带有 yield
的函数就是一个生成器函数,当我们使用 yield
时,它帮我们自动创建了 __iter__()
和 next()
方法,而且在没有数据时,也会抛出 StopIteration
异常,也就是我们不费吹灰之力就获得了一个迭代器,非常简洁和高效。
带有 yield
的函数执行过程比较特别:
- 调用该函数的时候不会立即执行代码,而是返回了一个生成器对象;
- 当使用
next()
(在 for 循环中会自动调用next()
) 作用于返回的生成器对象时,函数开始执行,在遇到yield
的时候会『暂停』,并返回当前的迭代值; - 当再次使用
next()
的时候,函数会从原来『暂停』的地方继续执行,直到遇到yield
语句,如果没有yield
语句,则抛出异常;
整个过程看起来就是不断地 执行->中断->执行->中断
的过程。一开始,调用生成器函数的时候,函数不会立即执行,而是返回一个生成器对象;然后,当我们使用 next()
作用于它的时候,它开始执行,遇到 yield
语句的时候,执行被中断,并返回当前的迭代值,要注意的是,此刻会记住中断的位置和所有的变量值,也就是执行时的上下文环境被保留起来;当再次使用 next()
的时候,从原来中断的地方继续执行,直至遇到 yield
,如果没有 yield
,则抛出异常。
简而言之,就是 next
使函数执行,yield
使函数暂停。
例子
看一个 Fibonacci 数列的例子,如果使用自定义迭代器的方法,是这样的:
>>> class Fib(object): ... def __init__(self): ... self.a, self.b = 0, 1 ... def __iter__(self): ... return self ... def next(self): ... self.a, self.b = self.b, self.a + self.b ... return self.a ... >>> f = Fib() >>> for item in f: ... if item > 10: ... break ... print item ... 1 1 2 3 5 8
而使用生成器的方法,是这样的:
>>> def fib(): ... a, b = 0, 1 ... while True: ... a, b = b, a + b ... yield a ... >>> f = fib() >>> for item in f: ... if item > 10: ... break ... print item ... 1 1 2 3 5 8
可以看到,使用生成器的方法非常简洁,不用自定义 __iter__()
和 next()
方法。
另外,在处理大文件的时候,我们可能无法一次性将其载入内存,这时可以通过构造固定长度的缓冲区,来不断读取文件内容。有了 yield
,我们就不用自己实现读文件的迭代器了,比如下面的实现:
def read_in_chunks(file_object, chunk_size=1024): """Lazy function (generator) to read a file piece by piece. Default chunk size: 1k.""" while True: data = file_object.read(chunk_size) if not data: break yield data f = open('really_big_file.dat') for piece in read_in_chunks(f): process_data(piece)
进阶使用
我们除了能对生成器进行迭代使它返回值外,还能:
- 使用
send()
方法给它发送消息; - 使用
throw()
方法给它发送异常; - 使用
close()
方法关闭生成器;
send() 方法
看一个简单的例子:
>>> def generator_function(): ... value1 = yield 0 ... print 'value1 is ', value1 ... value2 = yield 1 ... print 'value2 is ', value2 ... value3 = yield 2 ... print 'value3 is ', value3 ... >>> g = generator_function() >>> g.next() # 调用 next() 方法开始执行,返回 0 0 >>> g.send(2) value1 is 2 1 >>> g.send(3) value2 is 3 2 >>> g.send(4) value3 is 4 Traceback (most recent call last): File "<stdin>", line 1, in <module> StopIteration
在上面的代码中,我们先调用 next()
方法,使函数开始执行,代码执行到 yield 0
的时候暂停,返回了 0;接着,我们执行了 send()
方法,它会恢复生成器的运行,并将发送的值赋给上次中断时 yield 表达式的执行结果,也就是 value1,这时控制台打印出 value1 的值,并继续执行,直到遇到 yield 后暂停,此时返回 1;类似地,再次执行 send()
方法,将值赋给 value2。
简单地说,send()
方法就是 next()
的功能,加上传值给 yield
。
throw() 方法
除了可以给生成器传值,我们还可以给它传异常,比如:
>>> def generator_function(): ... try: ... yield 'Normal' ... except ValueError: ... yield 'Error' ... finally: ... print 'Finally' ... >>> g = generator_function() >>> g.next() 'Normal' >>> g.throw(ValueError) 'Error' >>> g.next() Finally Traceback (most recent call last): File "<stdin>", line 1, in <module> StopIteration
可以看到,throw()
方法向生成器函数传递了 ValueError
异常,此时代码进入 except ValueError 语句,遇到 yield 'Error',暂停并返回 Error 字符串。
简单的说,throw()
就是 next()
的功能,加上传异常给 yield
。
close() 方法
我们可以使用 close()
方法来关闭一个生成器。生成器被关闭后,再次调用 next() 方法,不管能否遇到 yield 关键字,都会抛出 StopIteration 异常,比如:
>>> def generator_function(): ... yield 1 ... yield 2 ... yield 3 ... >>> g = generator_function() >>> >>> g.next() 1 >>> g.close() # 关闭生成器 >>> g.next() Traceback (most recent call last): File "<stdin>", line 1, in <module> StopIteration
小结
- yield 把函数变成了一个生成器。
- 生成器函数的执行过程看起来就是不断地
执行->中断->执行->中断
的过程。- 一开始,调用生成器函数的时候,函数不会立即执行,而是返回一个生成器对象;
- 然后,当我们使用
next()
作用于它的时候,它开始执行,遇到yield
语句的时候,执行被中断,并返回当前的迭代值,要注意的是,此刻会记住中断的位置和所有的数据,也就是执行时的上下文环境被保留起来; - 当再次使用
next()
的时候,从原来中断的地方继续执行,直至遇到yield
,如果没有yield
,则抛出异常。
还没有评论,来说两句吧...