惰性求值

惰性求值(Lazy evaluation)是在需要时才进行求值的计算方式。表达式不在它被绑定到变量之后就立即求值，而是在该值被取用的时候求值。

除可以得到性能的提升(更小的内存占用)外，惰性计算的最重要的好处是它可以构造一个无限的数据类型。

yield的概念

yield的功能类似于return，但是不同之处在于它返回的是生成器。

生成器

生成器是通过一个或多个yield表达式构成的函数，每一个生成器都是一个迭代器(但是迭代器不一定是生成器)。

如果一个函数包含yield关键字，这个函数就会变为一个生成器。

生成器并不会一次返回所有结果，而是每次遇到yield关键字后返回相应结果，并保留函数当前的运行状态，等待下一次的调用。

由于生成器也是一个迭代器，那么它就应该支持next方法来获取下一个值。

# coding=utf8

# author=AaronChou

# 通过`yield`来创建生成器

def func():

for i in xrange(10):

yield i

# 通过列表来创建生成器

[i for i in xrange(10)]

# 调用如下

f = func()

print f # 此时生成器还没有运行

#

print f.next() # 当i=0时，遇到yield关键字，直接返回

# 0

print f.next() # 继续上一次执行的位置，进入下一层循环

# 1

# ...

print f.next()

# 9

print f.next() # 当执行完最后一次循环后，结束yield语句，生成StopIteration异常

# Traceback (most recent call last):

#   File "", line 1, in

# StopIteration

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

当函数执行结束的时候，generator自动自动抛出StopIteration的异常，表示迭代的结束，而在for循环中，我们不需要手动的进行处理异常，循环会自动的正常结束。

除了next函数，生成器还支持send函数。该函数可以向生成器传递参数。

# 通过`yield`来创建生成器

def func():

n = 0

while 1:

n = yield n  # 可以通过send函数向n赋值

f = func()

print f.next()  # 默认情况下n为0

# 0

print f.send(1)  # n赋值1

# 1

print f.send(6)

# 6

1

2

3

4

5

6

7

8

9

10

11

12

13

14

注意fac不可迭代,而fac(5)可迭代

一个带有yield的函数就是一盒generator,它和普通的函数不同，声称一个generator看起来想函数调用，但是部执行任何函数代码，直到对其调用next()(注意在for循环中会自动调用next)才开始执行。虽然执行流程和普通函数一样，但是每执行到一个yield语句，就会中断，并返回一个迭代值，下次执行的时候从yield的下一个语句开始执行。看起来像是一个函数在正常执行的过程中被yield中断了数次，每次中断都会通过yield返回当前迭代器的值。

yield的好处显而易见，把一个函数该写成generator就获得了迭代能力，比起在类的实例中保存状态计算下一个next的值，更加使代码清洁，而且执行流程非常清晰

判断是否为generator

方法是使用isgeneratorfunction来进行判断

from inspect import isgeneratorfunction

isgeneratorfunction(fac)

1

2

应用

最经典的例子，生成无限序列。

常规的解决方法是，生成一个满足要求的很大的列表，这个列表需要保存在内存中，很明显内存限制了这个问题。

def get_primes(start):

for element in magical_infinite_range(start):

if is_prime(element):

return element

1

2

3

4

使用生成器就不需要返回整个列表，每次都只是返回一个数据，避免了内存的限制问题。

def get_primes(number):

while True:

if is_prime(number):

yield number

number += 1

1

2

3

4

5

用生成器生成一个Fibonacci数列:

def fab(max):

a, b = 0, 1

while a < max:

yield a

a, b = b, a + b

for i in fab(20):

print i, ",",

1

2

3

4

5

6

7

8

9

10

迭代器(iterator)，生成器(constructor)，Yield

当创建了一个列表，可以一个个的读取它的每一项，这叫做迭代器(iterator)。可以用在for...in...语句中的都是可迭代的：比如lists,strings,files…因为这些可迭代的对象你可以随意的读取所以非常方便易用,但是必须把它们的值放到内存里,当它们有很多值时就会消耗太多的内存.

mylist = [x * x for x in range(3)]

for i in mylist:

print i

1

2

3

生成器(constructor)也是迭代器的一种，但是只能迭代它们一次，原因很简单，因为它们不是全部存在内存里，它们只在要调用的时候在内存里生成。

mygenerator = (x * x for x in range(3))

for i in mygenerator:

print i

1

2

3

生成器和迭代器的区别就是用()代替[]，不能用for i in mygenerator第二次调用生成器:首先计算0，然后会在内存里丢掉0去计算1，直到计算完4.

mygenerator = (x * x for x in range(3))

for i in mygenerator:

yield i * i

1

2

3

使用Yield时，调用函数的时候，函数里的代码并没有运行。函数仅仅返回生成器对象，然后，每当for语句迭代生成器的时候你的代码才会运转。节省了内存空间。

Yield其实就是Python中应用了惰性求值的思想，使得函数能够建立可计算的无限列表而没有妨碍计算的无限循环或大小问题

参考：

http://www.ibm.com/developerworks/cn/opensource/os-cn-python-yield/

http://www.cnblogs.com/coder2012/p/4990834.html