yield的功能类似于return，但是不同之处在于它返回的是生成器。
生成器
生成器是通过一个或多个yield表达式构成的函数，每一个生成器都是一个迭代器（但是迭代器不一定是生成器）。
如果一个函数包含yield关键字，这个函数就会变为一个生成器。
生成器并不会一次返回所有结果，而是每次遇到yield关键字后返回相应结果，并保留函数当前的运行状态，等待下一次的调用。
由于生成器也是一个迭代器，那么它就应该支持next方法来获取下一个值。
基本操作
|
1
2
3
4
|
# 通过`yield`来创建生成器def func(): for i in xrange(10); yield i |
|
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
28
29
30
31
32
33
34
35
|
# 通过列表来创建生成器[i for i in xrange(10)]# 通过`yield`来创建生成器def func(): for i in xrange(10); yield i# 通过列表来创建生成器[i for i in xrange(10)]# 调用如下>>> f = func()>>> f # 此时生成器还没有运行<generator object func at 0x7fe01a853820>>>> f.next() # 当i=0时，遇到yield关键字，直接返回>>> f.next() # 继续上一次执行的位置，进入下一层循环...>>> f.next()>>> f.next() # 当执行完最后一次循环后，结束yield语句，生成StopIteration异常Traceback (most recent call last): File "<stdin>", line 1, in <module>StopIteration>>># 调用如下>>> f = func()>>> f # 此时生成器还没有运行<generator object func at 0x7fe01a853820>>>> f.next() # 当i=0时，遇到yield关键字，直接返回>>> f.next() # 继续上一次执行的位置，进入下一层循环...>>> f.next()>>> f.next() # 当执行完最后一次循环后，结束yield语句，生成StopIteration异常Traceback (most recent call last): File "<stdin>", line 1, in <module>StopIteration>>> |
除了next函数，生成器还支持send函数。该函数可以向生成器传递参数。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
>>> def func():... n = 0... while 1:... n = yield n #可以通过send函数向n赋值... >>> f = func()>>> f.next() # 默认情况下n为0>>> f.send(1) #n赋值1>>> f.send(2)>>> >>> def func():... n = 0... while 1:... n = yield n #可以通过send函数向n赋值... >>> f = func()>>> f.next() # 默认情况下n为0>>> f.send(1) #n赋值1>>> f.send(2)>>> |
应用
最经典的例子，生成无限序列。
常规的解决方法是，生成一个满足要求的很大的列表，这个列表需要保存在内存中，很明显内存限制了这个问题。
|
1
2
3
4
5
6
7
8
|
def get_primes(start): for element in magical_infinite_range(start): if is_prime(element): return elementdef get_primes(start): for element in magical_infinite_range(start): if is_prime(element): return element |
如果使用生成器就不需要返回整个列表，每次都只是返回一个数据，避免了内存的限制问题。
|
1
2
3
4
5
6
7
8
9
10
|
def get_primes(number): while True: if is_prime(number): yield number number += 1def get_primes(number): while True: if is_prime(number): yield number number += 1 |
生成器源码分析
生成器的源码在Objects/genobject.c。
调用栈
在解释生成器之前，需要讲解一下Python虚拟机的调用原理。
Python虚拟机有一个栈帧的调用栈，其中栈帧的是PyFrameObject，位于Include/frameobject.h。
|
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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
|
typedef struct _frame { PyObject_VAR_HEAD struct _frame *f_back; /* previous frame, or NULL */ PyCodeObject *f_code; /* code segment */ PyObject *f_builtins; /* builtin symbol table (PyDictObject) */ PyObject *f_globals; /* global symbol table (PyDictObject) */ PyObject *f_locals; /* local symbol table (any mapping) */ PyObject **f_valuestack; /* points after the last local */ /* Next free slot in f_valuestack. Frame creation sets to f_valuestack. Frame evaluation usually NULLs it, but a frame that yields sets it to the current stack top. */ PyObject **f_stacktop; PyObject *f_trace; /* Trace function */ /* If an exception is raised in this frame, the next three are used to * record the exception info (if any) originally in the thread state. See * comments before set_exc_info() -- it's not obvious. * Invariant: if _type is NULL, then so are _value and _traceback. * Desired invariant: all three are NULL, or all three are non-NULL. That * one isn't currently true, but "should be". */ PyObject *f_exc_type, *f_exc_value, *f_exc_traceback; PyThreadState *f_tstate; int f_lasti; /* Last instruction if called */ /* Call PyFrame_GetLineNumber() instead of reading this field directly. As of 2.3 f_lineno is only valid when tracing is active (i.e. when f_trace is set). At other times we use PyCode_Addr2Line to calculate the line from the current bytecode index. */ int f_lineno; /* Current line number */ int f_iblock; /* index in f_blockstack */ PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */ PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */} PyFrameObject;typedef struct _frame { PyObject_VAR_HEAD struct _frame *f_back; /* previous frame, or NULL */ PyCodeObject *f_code; /* code segment */ PyObject *f_builtins; /* builtin symbol table (PyDictObject) */ PyObject *f_globals; /* global symbol table (PyDictObject) */ PyObject *f_locals; /* local symbol table (any mapping) */ PyObject **f_valuestack; /* points after the last local */ /* Next free slot in f_valuestack. Frame creation sets to f_valuestack. Frame evaluation usually NULLs it, but a frame that yields sets it to the current stack top. */ PyObject **f_stacktop; PyObject *f_trace; /* Trace function */ /* If an exception is raised in this frame, the next three are used to * record the exception info (if any) originally in the thread state. See * comments before set_exc_info() -- it's not obvious. * Invariant: if _type is NULL, then so are _value and _traceback. * Desired invariant: all three are NULL, or all three are non-NULL. That * one isn't currently true, but "should be". */ PyObject *f_exc_type, *f_exc_value, *f_exc_traceback; PyThreadState *f_tstate; int f_lasti; /* Last instruction if called */ /* Call PyFrame_GetLineNumber() instead of reading this field directly. As of 2.3 f_lineno is only valid when tracing is active (i.e. when f_trace is set). At other times we use PyCode_Addr2Line to calculate the line from the current bytecode index. */ int f_lineno; /* Current line number */ int f_iblock; /* index in f_blockstack */ PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */ PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */} PyFrameObject; |
栈帧保存了给出代码的的信息和上下文，其中包含最后执行的指令，全局和局部命名空间，异常状态等信息。f_valueblock保存了数据，b_blockstack保存了异常和循环控制方法。
举一个例子来说明，
|
1
2
3
4
5
6
7
8
|
def foo(): x = 1 def bar(y): z = y + 2 # def foo(): x = 1 def bar(y): z = y + 2 # |
那么，相应的调用栈如下，一个py文件，一个类，一个函数都是一个代码块，对应者一个Frame，保存着上下文环境以及字节码指令。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
c ---------------------------a | bar Frame | -> block stack: []l | (newest) | -> data stack: [1, 2]l --------------------------- | foo Frame | -> block stack: []s | | -> data stack: [.bar at 0x10d389680>, 1]t ---------------------------a | main (module) Frame | -> block stack: []c | (oldest) | -> data stack: []k ---------------------------c ---------------------------a | bar Frame | -> block stack: []l | (newest) | -> data stack: [1, 2]l --------------------------- | foo Frame | -> block stack: []s | | -> data stack: [.bar at 0x10d389680>, 1]t ---------------------------a | main (module) Frame | -> block stack: []c | (oldest) | -> data stack: []k --------------------------- |
每一个栈帧都拥有自己的数据栈和block栈，独立的数据栈和block栈使得解释器可以中断和恢复栈帧（生成器正式利用这点）。
Python代码首先被编译为字节码，再由Python虚拟机来执行。一般来说，一条Python语句对应着多条字节码（由于每条字节码对应着一条C语句，而不是一个机器指令，所以不能按照字节码的数量来判断代码性能）。
调用dis模块可以分析字节码，
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
from dis import disdis(foo) 0 LOAD_CONST 1 (1) # 加载常量1 3 STORE_FAST 0 (x) # x赋值为1 6 LOAD_CONST 2 (<code>) # 加载常量2 9 MAKE_FUNCTION 0 # 创建函数 12 STORE_FAST 1 (bar) 15 LOAD_FAST 1 (bar) 18 LOAD_FAST 0 (x) 21 CALL_FUNCTION 1 # 调用函数 24 RETURN_VALUE </code>from dis import dis dis(foo) 0 LOAD_CONST 1 (1) # 加载常量1 3 STORE_FAST 0 (x) # x赋值为1 6 LOAD_CONST 2 (<code>) # 加载常量2 9 MAKE_FUNCTION 0 # 创建函数 12 STORE_FAST 1 (bar) 15 LOAD_FAST 1 (bar) 18 LOAD_FAST 0 (x) 21 CALL_FUNCTION 1 # 调用函数 24 RETURN_VALUE </code> |
其中，
第一行为代码行号；
第二行为偏移地址；
第三行为字节码指令；
第四行为指令参数；
第五行为参数解释。
第一行为代码行号；
第二行为偏移地址；
第三行为字节码指令；
第四行为指令参数；
第五行为参数解释。
生成器源码分析
由了上面对于调用栈的理解，就可以很容易的明白生成器的具体实现。
生成器的源码位于object/genobject.c。
生成器的创建
|
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
28
29
30
31
32
33
|
PyObject *PyGen_New(PyFrameObject *f){ PyGenObject *gen = PyObject_GC_New(PyGenObject, &PyGen_Type); # 创建生成器对象 if (gen == NULL) { Py_DECREF(f); return NULL; } gen->gi_frame = f; # 赋予代码块 Py_INCREF(f->f_code); # 引用计数+1 gen->gi_code = (PyObject *)(f->f_code); gen->gi_running = 0; # 0表示为执行，也就是生成器的初始状态 gen->gi_weakreflist = NULL; _PyObject_GC_TRACK(gen); # GC跟踪 return (PyObject *)gen;}PyObject *PyGen_New(PyFrameObject *f){ PyGenObject *gen = PyObject_GC_New(PyGenObject, &PyGen_Type); # 创建生成器对象 if (gen == NULL) { Py_DECREF(f); return NULL; } gen->gi_frame = f; # 赋予代码块 Py_INCREF(f->f_code); # 引用计数+1 gen->gi_code = (PyObject *)(f->f_code); gen->gi_running = 0; # 0表示为执行，也就是生成器的初始状态 gen->gi_weakreflist = NULL; _PyObject_GC_TRACK(gen); # GC跟踪 return (PyObject *)gen;} |
send与next
next与send函数，如下
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
static PyObject *gen_iternext(PyGenObject *gen){ return gen_send_ex(gen, NULL, 0);}static PyObject *gen_send(PyGenObject *gen, PyObject *arg){ return gen_send_ex(gen, arg, 0);}static PyObject *gen_iternext(PyGenObject *gen){ return gen_send_ex(gen, NULL, 0);}static PyObject *gen_send(PyGenObject *gen, PyObject *arg){ return gen_send_ex(gen, arg, 0);} |
从上面的代码中可以看到，send和next都是调用的同一函数gen_send_ex，区别在于是否带有参数。
|
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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
|
static PyObject *gen_send_ex(PyGenObject *gen, PyObject *arg, int exc){ PyThreadState *tstate = PyThreadState_GET(); PyFrameObject *f = gen->gi_frame; PyObject *result; if (gen->gi_running) { # 判断生成器是否已经运行 PyErr_SetString(PyExc_ValueError, "generator already executing"); return NULL; } if (f==NULL || f->f_stacktop == NULL) { # 如果代码块为空或调用栈为空，则抛出StopIteration异常 /* Only set exception if called from send() */ if (arg && !exc) PyErr_SetNone(PyExc_StopIteration); return NULL; } if (f->f_lasti == -1) { # f_lasti=1 代表首次执行 if (arg && arg != Py_None) { # 首次执行不允许带有参数 PyErr_SetString(PyExc_TypeError, "can't send non-None value to a " "just-started generator"); return NULL; } } else { /* Push arg onto the frame's value stack */ result = arg ? arg : Py_None; Py_INCREF(result); # 该参数引用计数+1 *(f->f_stacktop++) = result; # 参数压栈 } /* Generators always return to their most recent caller, not * necessarily their creator. */ f->f_tstate = tstate; Py_XINCREF(tstate->frame); assert(f->f_back == NULL); f->f_back = tstate->frame; gen->gi_running = 1; # 修改生成器执行状态 result = PyEval_EvalFrameEx(f, exc); # 执行字节码 gen->gi_running = 0; # 恢复为未执行状态 /* Don't keep the reference to f_back any longer than necessary. It * may keep a chain of frames alive or it could create a reference * cycle. */ assert(f->f_back == tstate->frame); Py_CLEAR(f->f_back); /* Clear the borrowed reference to the thread state */ f->f_tstate = NULL; /* If the generator just returned (as opposed to yielding), signal * that the generator is exhausted. */ if (result == Py_None && f->f_stacktop == NULL) { Py_DECREF(result); result = NULL; /* Set exception if not called by gen_iternext() */ if (arg) PyErr_SetNone(PyExc_StopIteration); } if (!result || f->f_stacktop == NULL) { /* generator can't be rerun, so release the frame */ Py_DECREF(f); gen->gi_frame = NULL; } return result;}static PyObject *gen_send_ex(PyGenObject *gen, PyObject *arg, int exc){ PyThreadState *tstate = PyThreadState_GET(); PyFrameObject *f = gen->gi_frame; PyObject *result; if (gen->gi_running) { # 判断生成器是否已经运行 PyErr_SetString(PyExc_ValueError, "generator already executing"); return NULL; } if (f==NULL || f->f_stacktop == NULL) { # 如果代码块为空或调用栈为空，则抛出StopIteration异常 /* Only set exception if called from send() */ if (arg && !exc) PyErr_SetNone(PyExc_StopIteration); return NULL; } if (f->f_lasti == -1) { # f_lasti=1 代表首次执行 if (arg && arg != Py_None) { # 首次执行不允许带有参数 PyErr_SetString(PyExc_TypeError, "can't send non-None value to a " "just-started generator"); return NULL; } } else { /* Push arg onto the frame's value stack */ result = arg ? arg : Py_None; Py_INCREF(result); # 该参数引用计数+1 *(f->f_stacktop++) = result; # 参数压栈 } /* Generators always return to their most recent caller, not * necessarily their creator. */ f->f_tstate = tstate; Py_XINCREF(tstate->frame); assert(f->f_back == NULL); f->f_back = tstate->frame; gen->gi_running = 1; # 修改生成器执行状态 result = PyEval_EvalFrameEx(f, exc); # 执行字节码 gen->gi_running = 0; # 恢复为未执行状态 /* Don't keep the reference to f_back any longer than necessary. It * may keep a chain of frames alive or it could create a reference * cycle. */ assert(f->f_back == tstate->frame); Py_CLEAR(f->f_back); /* Clear the borrowed reference to the thread state */ f->f_tstate = NULL; /* If the generator just returned (as opposed to yielding), signal * that the generator is exhausted. */ if (result == Py_None && f->f_stacktop == NULL) { Py_DECREF(result); result = NULL; /* Set exception if not called by gen_iternext() */ if (arg) PyErr_SetNone(PyExc_StopIteration); } if (!result || f->f_stacktop == NULL) { /* generator can't be rerun, so release the frame */ Py_DECREF(f); gen->gi_frame = NULL; } return result;} |
字节码的执行
PyEval_EvalFrameEx函数的功能为执行字节码并返回结果。
|
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
28
29
30
31
32
33
34
|
# 主要流程如下，for (;;) { switch(opcode) { # opcode为操作码，对应着各种操作 case NOP: goto fast_next_opcode; ... ... case YIELD_VALUE: # 如果操作码是yield retval = POP(); f->f_stacktop = stack_pointer; why = WHY_YIELD; goto fast_yield; # 利用goto跳出循环 }}fast_yield: ... return vetval; # 返回结果# 主要流程如下，for (;;) { switch(opcode) { # opcode为操作码，对应着各种操作 case NOP: goto fast_next_opcode; ... ... case YIELD_VALUE: # 如果操作码是yield retval = POP(); f->f_stacktop = stack_pointer; why = WHY_YIELD; goto fast_yield; # 利用goto跳出循环 }}fast_yield: ... return vetval; # 返回结果 |
举一个例子，f_back上一个Frame，f_lasti上一次执行的指令的偏移量，
|
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
28
|
import sysfrom dis import disdef func(): f = sys._getframe(0) print f.f_lasti print f.f_back yield 1 print f.f_lasti print f.f_back yield 2a = func()dis(func)a.next()a.next()import sysfrom dis import disdef func(): f = sys._getframe(0) print f.f_lasti print f.f_back yield 1 print f.f_lasti print f.f_back yield 2a = func()dis(func)a.next()a.next() |
结果如下，其中第三行的英文为操作码，对应着上面的opcode，每次switch都是在不同的opcode之间进行选择。
|
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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
|
Python 0 LOAD_GLOBAL 0 (sys) 3 LOAD_ATTR 1 (_getframe) 6 LOAD_CONST 1 (0) 9 CALL_FUNCTION 1 12 STORE_FAST 0 (f) 15 LOAD_FAST 0 (f) 18 LOAD_ATTR 2 (f_lasti) 21 PRINT_ITEM 22 PRINT_NEWLINE 23 LOAD_FAST 0 (f) 26 LOAD_ATTR 3 (f_back) 29 PRINT_ITEM 30 PRINT_NEWLINE 31 LOAD_CONST 2 (1) 34 YIELD_VALUE # 此时操作码为YIELD_VALUE，直接跳转上述goto语句，此时f_lasti为当前指令，f_back为当前frame 35 POP_TOP 36 LOAD_FAST 0 (f) 39 LOAD_ATTR 2 (f_lasti) 42 PRINT_ITEM 43 PRINT_NEWLINE 44 LOAD_FAST 0 (f) 47 LOAD_ATTR 3 (f_back) 50 PRINT_ITEM 51 PRINT_NEWLINE 52 LOAD_CONST 3 (2) 55 YIELD_VALUE 56 POP_TOP 57 LOAD_CONST 0 (None) 60 RETURN_VALUE <frame object at 0x7fa75fcebc20> #和下面的frame相同，属于同一个frame，也就是说在同一个函数（命名空间）内，frame是同一个。<frame object at 0x7fa75fcebc20> 0 LOAD_GLOBAL 0 (sys) 3 LOAD_ATTR 1 (_getframe) 6 LOAD_CONST 1 (0) 9 CALL_FUNCTION 1 12 STORE_FAST 0 (f) 15 LOAD_FAST 0 (f) 18 LOAD_ATTR 2 (f_lasti) 21 PRINT_ITEM 22 PRINT_NEWLINE 23 LOAD_FAST 0 (f) 26 LOAD_ATTR 3 (f_back) 29 PRINT_ITEM 30 PRINT_NEWLINE 31 LOAD_CONST 2 (1) 34 YIELD_VALUE # 此时操作码为YIELD_VALUE，直接跳转上述goto语句，此时f_lasti为当前指令，f_back为当前frame 35 POP_TOP 36 LOAD_FAST 0 (f) 39 LOAD_ATTR 2 (f_lasti) 42 PRINT_ITEM 43 PRINT_NEWLINE 44 LOAD_FAST 0 (f) 47 LOAD_ATTR 3 (f_back) 50 PRINT_ITEM 51 PRINT_NEWLINE 52 LOAD_CONST 3 (2) 55 YIELD_VALUE 56 POP_TOP 57 LOAD_CONST 0 (None) 60 RETURN_VALUE <frame object at 0x7fa75fcebc20> #和下面的frame相同，属于同一个frame，也就是说在同一个函数（命名空间）内，frame是同一个。<frame object at 0x7fa75fcebc20> |
总结
以上所述是小编给大家介绍的Python yield与实现方法代码分析，希望对大家有所帮助，如果大家有任何疑问请给我留言，小编会及时回复大家的。在此也非常感谢大家对服务器之家网站的支持！
