Python yield与实现方法代码分析

2023-09-16 18:38:05 57

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

生成器

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

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

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

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

基本操作

#通过`yield`来创建生成器
deffunc():
foriinxrange(10);
yieldi

#通过列表来创建生成器
[iforiinxrange(10)]
#通过`yield`来创建生成器
deffunc():
foriinxrange(10);
yieldi
#通过列表来创建生成器
[iforiinxrange(10)]
Python
#调用如下
>>>f=func()
>>>f#此时生成器还没有运行

>>>f.next()#当i=0时，遇到yield关键字，直接返回
>>>f.next()#继续上一次执行的位置，进入下一层循环
...
>>>f.next()
>>>f.next()#当执行完最后一次循环后，结束yield语句，生成StopIteration异常
Traceback(mostrecentcalllast):
File"",line1,in
StopIteration
>>>
#调用如下
>>>f=func()
>>>f#此时生成器还没有运行

>>>f.next()#当i=0时，遇到yield关键字，直接返回
>>>f.next()#继续上一次执行的位置，进入下一层循环
...
>>>f.next()
>>>f.next()#当执行完最后一次循环后，结束yield语句，生成StopIteration异常
Traceback(mostrecentcalllast):
File"",line1,in
StopIteration
>>>

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

>>>deffunc():
...n=0
...while1:
...n=yieldn#可以通过send函数向n赋值
...
>>>f=func()
>>>f.next()#默认情况下n为0
>>>f.send(1)#n赋值1
>>>f.send(2)
>>>
>>>deffunc():
...n=0
...while1:
...n=yieldn#可以通过send函数向n赋值
...
>>>f=func()
>>>f.next()#默认情况下n为0
>>>f.send(1)#n赋值1
>>>f.send(2)
>>>

应用

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

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

defget_primes(start):
forelementinmagical_infinite_range(start):
ifis_prime(element):
returnelement
defget_primes(start):
forelementinmagical_infinite_range(start):
ifis_prime(element):
returnelement

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

defget_primes(number):
whileTrue:
ifis_prime(number):
yieldnumber
number+=1
defget_primes(number):
whileTrue:
ifis_prime(number):
yieldnumber
number+=1

生成器源码分析

生成器的源码在Objects/genobject.c。

调用栈

在解释生成器之前，需要讲解一下Python虚拟机的调用原理。

Python虚拟机有一个栈帧的调用栈，其中栈帧的是PyFrameObject，位于Include/frameobject.h。

typedefstruct_frame{
PyObject_VAR_HEAD
struct_frame*f_back;/*previousframe,orNULL*/
PyCodeObject*f_code;/*codesegment*/
PyObject*f_builtins;/*builtinsymboltable(PyDictObject)*/
PyObject*f_globals;/*globalsymboltable(PyDictObject)*/
PyObject*f_locals;/*localsymboltable(anymapping)*/
PyObject**f_valuestack;/*pointsafterthelastlocal*/
/*Nextfreeslotinf_valuestack.Framecreationsetstof_valuestack.
FrameevaluationusuallyNULLsit,butaframethatyieldssetsit
tothecurrentstacktop.*/
PyObject**f_stacktop;
PyObject*f_trace;/*Tracefunction*/

/*Ifanexceptionisraisedinthisframe,thenextthreeareusedto
*recordtheexceptioninfo(ifany)originallyinthethreadstate.See
*commentsbeforeset_exc_info()--it'snotobvious.
*Invariant:if_typeisNULL,thensoare_valueand_traceback.
*Desiredinvariant:allthreeareNULL,orallthreearenon-NULL.That
*oneisn'tcurrentlytrue,but"shouldbe".
*/
PyObject*f_exc_type,*f_exc_value,*f_exc_traceback;

PyThreadState*f_tstate;
intf_lasti;/*Lastinstructionifcalled*/
/*CallPyFrame_GetLineNumber()insteadofreadingthisfield
directly.Asof2.3f_linenoisonlyvalidwhentracingis
active(i.e.whenf_traceisset).Atothertimesweuse
PyCode_Addr2Linetocalculatethelinefromthecurrent
bytecodeindex.*/
intf_lineno;/*Currentlinenumber*/
intf_iblock;/*indexinf_blockstack*/
PyTryBlockf_blockstack[CO_MAXBLOCKS];/*fortryandloopblocks*/
PyObject*f_localsplus[1];/*locals+stack,dynamicallysized*/
}PyFrameObject;
typedefstruct_frame{
PyObject_VAR_HEAD
struct_frame*f_back;/*previousframe,orNULL*/
PyCodeObject*f_code;/*codesegment*/
PyObject*f_builtins;/*builtinsymboltable(PyDictObject)*/
PyObject*f_globals;/*globalsymboltable(PyDictObject)*/
PyObject*f_locals;/*localsymboltable(anymapping)*/
PyObject**f_valuestack;/*pointsafterthelastlocal*/
/*Nextfreeslotinf_valuestack.Framecreationsetstof_valuestack.
FrameevaluationusuallyNULLsit,butaframethatyieldssetsit
tothecurrentstacktop.*/
PyObject**f_stacktop;
PyObject*f_trace;/*Tracefunction*/
/*Ifanexceptionisraisedinthisframe,thenextthreeareusedto
*recordtheexceptioninfo(ifany)originallyinthethreadstate.See
*commentsbeforeset_exc_info()--it'snotobvious.
*Invariant:if_typeisNULL,thensoare_valueand_traceback.
*Desiredinvariant:allthreeareNULL,orallthreearenon-NULL.That
*oneisn'tcurrentlytrue,but"shouldbe".
*/
PyObject*f_exc_type,*f_exc_value,*f_exc_traceback;

PyThreadState*f_tstate;
intf_lasti;/*Lastinstructionifcalled*/
/*CallPyFrame_GetLineNumber()insteadofreadingthisfield
directly.Asof2.3f_linenoisonlyvalidwhentracingis
active(i.e.whenf_traceisset).Atothertimesweuse
PyCode_Addr2Linetocalculatethelinefromthecurrent
bytecodeindex.*/
intf_lineno;/*Currentlinenumber*/
intf_iblock;/*indexinf_blockstack*/
PyTryBlockf_blockstack[CO_MAXBLOCKS];/*fortryandloopblocks*/
PyObject*f_localsplus[1];/*locals+stack,dynamicallysized*/
}PyFrameObject;

栈帧保存了给出代码的的信息和上下文，其中包含最后执行的指令，全局和局部命名空间，异常状态等信息。f_valueblock保存了数据，b_blockstack保存了异常和循环控制方法。

举一个例子来说明，

deffoo():
x=1
defbar(y):
z=y+2#
deffoo():
x=1
defbar(y):
z=y+2#

那么，相应的调用栈如下，一个py文件，一个类，一个函数都是一个代码块，对应者一个Frame，保存着上下文环境以及字节码指令。

c---------------------------
a|barFrame|->blockstack:[]
l|(newest)|->datastack:[1,2]
l---------------------------
|fooFrame|->blockstack:[]
s||->datastack:[.barat0x10d389680>,1]
t---------------------------
a|main(module)Frame|->blockstack:[]
c|(oldest)|->datastack:[]
k---------------------------

c---------------------------
a|barFrame|->blockstack:[]
l|(newest)|->datastack:[1,2]
l---------------------------
|fooFrame|->blockstack:[]
s||->datastack:[.barat0x10d389680>,1]
t---------------------------
a|main(module)Frame|->blockstack:[]
c|(oldest)|->datastack:[]
k---------------------------

每一个栈帧都拥有自己的数据栈和block栈，独立的数据栈和block栈使得解释器可以中断和恢复栈帧（生成器正式利用这点）。

Python代码首先被编译为字节码，再由Python虚拟机来执行。一般来说，一条Python语句对应着多条字节码（由于每条字节码对应着一条C语句，而不是一个机器指令，所以不能按照字节码的数量来判断代码性能）。

调用dis模块可以分析字节码，

fromdisimportdis
dis(foo)
0LOAD_CONST1(1)#加载常量1
3STORE_FAST0(x)#x赋值为1
6LOAD_CONST2()#加载常量2
9MAKE_FUNCTION0#创建函数
12STORE_FAST1(bar)
15LOAD_FAST1(bar)
18LOAD_FAST0(x)
21CALL_FUNCTION1#调用函数
24RETURN_VALUE

fromdisimportdis
dis(foo)
0LOAD_CONST1(1)#加载常量1
3STORE_FAST0(x)#x赋值为1
6LOAD_CONST2()#加载常量2
9MAKE_FUNCTION0#创建函数
12STORE_FAST1(bar)
15LOAD_FAST1(bar)
18LOAD_FAST0(x)
21CALL_FUNCTION1#调用函数
24RETURN_VALUE

其中，

第一行为代码行号；
第二行为偏移地址；
第三行为字节码指令；
第四行为指令参数；
第五行为参数解释。

生成器源码分析

由了上面对于调用栈的理解，就可以很容易的明白生成器的具体实现。

生成器的源码位于object/genobject.c。

生成器的创建

PyObject*
PyGen_New(PyFrameObject*f)
{
PyGenObject*gen=PyObject_GC_New(PyGenObject,&PyGen_Type);#创建生成器对象
if(gen==NULL){
Py_DECREF(f);
returnNULL;
}
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);
returnNULL;
}
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函数，如下

staticPyObject*
gen_iternext(PyGenObject*gen)
{
returngen_send_ex(gen,NULL,0);
}
staticPyObject*
gen_send(PyGenObject*gen,PyObject*arg)
{
returngen_send_ex(gen,arg,0);
}

staticPyObject*
gen_iternext(PyGenObject*gen)
{
returngen_send_ex(gen,NULL,0);
}
staticPyObject*
gen_send(PyGenObject*gen,PyObject*arg)
{
returngen_send_ex(gen,arg,0);
}

从上面的代码中可以看到，send和next都是调用的同一函数gen_send_ex，区别在于是否带有参数。

staticPyObject*
gen_send_ex(PyGenObject*gen,PyObject*arg,intexc)
{
PyThreadState*tstate=PyThreadState_GET();
PyFrameObject*f=gen->gi_frame;
PyObject*result;
if(gen->gi_running){#判断生成器是否已经运行
PyErr_SetString(PyExc_ValueError,
"generatoralreadyexecuting");
returnNULL;
}
if(f==NULL||f->f_stacktop==NULL){#如果代码块为空或调用栈为空，则抛出StopIteration异常
/*Onlysetexceptionifcalledfromsend()*/
if(arg&&!exc)
PyErr_SetNone(PyExc_StopIteration);
returnNULL;
}
if(f->f_lasti==-1){#f_lasti=1代表首次执行
if(arg&&arg!=Py_None){#首次执行不允许带有参数
PyErr_SetString(PyExc_TypeError,
"can'tsendnon-Nonevaluetoa"
"just-startedgenerator");
returnNULL;
}
}else{
/*Pushargontotheframe'svaluestack*/
result=arg?arg:Py_None;
Py_INCREF(result);#该参数引用计数+1
*(f->f_stacktop++)=result;#参数压栈
}
/*Generatorsalwaysreturntotheirmostrecentcaller,not
*necessarilytheircreator.*/
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'tkeepthereferencetof_backanylongerthannecessary.It
*maykeepachainofframesaliveoritcouldcreateareference
*cycle.*/
assert(f->f_back==tstate->frame);
Py_CLEAR(f->f_back);
/*Cleartheborrowedreferencetothethreadstate*/
f->f_tstate=NULL;
/*Ifthegeneratorjustreturned(asopposedtoyielding),signal
*thatthegeneratorisexhausted.*/
if(result==Py_None&&f->f_stacktop==NULL){
Py_DECREF(result);
result=NULL;
/*Setexceptionifnotcalledbygen_iternext()*/
if(arg)
PyErr_SetNone(PyExc_StopIteration);
}
if(!result||f->f_stacktop==NULL){
/*generatorcan'tbererun,soreleasetheframe*/
Py_DECREF(f);
gen->gi_frame=NULL;
}
returnresult;
}

staticPyObject*
gen_send_ex(PyGenObject*gen,PyObject*arg,intexc)
{
PyThreadState*tstate=PyThreadState_GET();
PyFrameObject*f=gen->gi_frame;
PyObject*result;
if(gen->gi_running){#判断生成器是否已经运行
PyErr_SetString(PyExc_ValueError,
"generatoralreadyexecuting");
returnNULL;
}
if(f==NULL||f->f_stacktop==NULL){#如果代码块为空或调用栈为空，则抛出StopIteration异常
/*Onlysetexceptionifcalledfromsend()*/
if(arg&&!exc)
PyErr_SetNone(PyExc_StopIteration);
returnNULL;
}
if(f->f_lasti==-1){#f_lasti=1代表首次执行
if(arg&&arg!=Py_None){#首次执行不允许带有参数
PyErr_SetString(PyExc_TypeError,
"can'tsendnon-Nonevaluetoa"
"just-startedgenerator");
returnNULL;
}
}else{
/*Pushargontotheframe'svaluestack*/
result=arg?arg:Py_None;
Py_INCREF(result);#该参数引用计数+1
*(f->f_stacktop++)=result;#参数压栈
}
/*Generatorsalwaysreturntotheirmostrecentcaller,not
*necessarilytheircreator.*/
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'tkeepthereferencetof_backanylongerthannecessary.It
*maykeepachainofframesaliveoritcouldcreateareference
*cycle.*/
assert(f->f_back==tstate->frame);
Py_CLEAR(f->f_back);
/*Cleartheborrowedreferencetothethreadstate*/
f->f_tstate=NULL;
/*Ifthegeneratorjustreturned(asopposedtoyielding),signal
*thatthegeneratorisexhausted.*/
if(result==Py_None&&f->f_stacktop==NULL){
Py_DECREF(result);
result=NULL;
/*Setexceptionifnotcalledbygen_iternext()*/
if(arg)
PyErr_SetNone(PyExc_StopIteration);
}
if(!result||f->f_stacktop==NULL){
/*generatorcan'tbererun,soreleasetheframe*/
Py_DECREF(f);
gen->gi_frame=NULL;
}
returnresult;
}

字节码的执行

PyEval_EvalFrameEx函数的功能为执行字节码并返回结果。

#主要流程如下，
for(;;){
switch(opcode){#opcode为操作码，对应着各种操作
caseNOP:
gotofast_next_opcode;
...
...
caseYIELD_VALUE:#如果操作码是yield
retval=POP();
f->f_stacktop=stack_pointer;
why=WHY_YIELD;
gotofast_yield;#利用goto跳出循环
}
}
fast_yield:
...
returnvetval;#返回结果
#主要流程如下，
for(;;){
switch(opcode){#opcode为操作码，对应着各种操作
caseNOP:
gotofast_next_opcode;
...
...
caseYIELD_VALUE:#如果操作码是yield
retval=POP();
f->f_stacktop=stack_pointer;
why=WHY_YIELD;
gotofast_yield;#利用goto跳出循环
}
}
fast_yield:
...
returnvetval;#返回结果

举一个例子，f_back上一个Frame，f_lasti上一次执行的指令的偏移量，

importsys
fromdisimportdis
deffunc():
f=sys._getframe(0)
printf.f_lasti
printf.f_back
yield1
printf.f_lasti
printf.f_back
yield2
a=func()
dis(func)
a.next()
a.next()
importsys
fromdisimportdis
deffunc():
f=sys._getframe(0)
printf.f_lasti
printf.f_back
yield1
printf.f_lasti
printf.f_back
yield2
a=func()
dis(func)
a.next()
a.next()

结果如下，其中第三行的英文为操作码，对应着上面的opcode，每次switch都是在不同的opcode之间进行选择。

Python
0LOAD_GLOBAL0(sys)
3LOAD_ATTR1(_getframe)
6LOAD_CONST1(0)
9CALL_FUNCTION1
12STORE_FAST0(f)
15LOAD_FAST0(f)
18LOAD_ATTR2(f_lasti)
21PRINT_ITEM
22PRINT_NEWLINE
23LOAD_FAST0(f)
26LOAD_ATTR3(f_back)
29PRINT_ITEM
30PRINT_NEWLINE
31LOAD_CONST2(1)
34YIELD_VALUE#此时操作码为YIELD_VALUE，直接跳转上述goto语句，此时f_lasti为当前指令，f_back为当前frame
35POP_TOP
36LOAD_FAST0(f)
39LOAD_ATTR2(f_lasti)
42PRINT_ITEM
43PRINT_NEWLINE
44LOAD_FAST0(f)
47LOAD_ATTR3(f_back)
50PRINT_ITEM
51PRINT_NEWLINE
52LOAD_CONST3(2)
55YIELD_VALUE
56POP_TOP
57LOAD_CONST0(None)
60RETURN_VALUE
#和下面的frame相同，属于同一个frame，也就是说在同一个函数（命名空间）内，frame是同一个。

0LOAD_GLOBAL0(sys)
3LOAD_ATTR1(_getframe)
6LOAD_CONST1(0)
9CALL_FUNCTION1
12STORE_FAST0(f)
15LOAD_FAST0(f)
18LOAD_ATTR2(f_lasti)
21PRINT_ITEM
22PRINT_NEWLINE
23LOAD_FAST0(f)
26LOAD_ATTR3(f_back)
29PRINT_ITEM
30PRINT_NEWLINE
31LOAD_CONST2(1)
34YIELD_VALUE#此时操作码为YIELD_VALUE，直接跳转上述goto语句，此时f_lasti为当前指令，f_back为当前frame
35POP_TOP
36LOAD_FAST0(f)
39LOAD_ATTR2(f_lasti)
42PRINT_ITEM
43PRINT_NEWLINE
44LOAD_FAST0(f)
47LOAD_ATTR3(f_back)
50PRINT_ITEM
51PRINT_NEWLINE
52LOAD_CONST3(2)
55YIELD_VALUE
56POP_TOP
57LOAD_CONST0(None)
60RETURN_VALUE
#和下面的frame相同，属于同一个frame，也就是说在同一个函数（命名空间）内，frame是同一个。

总结

以上所述是小编给大家介绍的Pythonyield与实现方法代码分析，希望对大家有所帮助，如果大家有任何疑问请给我留言，小编会及时回复大家的。在此也非常感谢大家对毛票票网站的支持！

Python yield与实现方法代码分析

热门推荐

随机推荐