python-yield用法详解.pdf
112 浏览量
2024-02-06
08:03:44
上传
评论
收藏 307KB PDF 举报
1
pyt
h
on
|
y
ield
⽤
法
详解
⾸
先
，
如
果
你
还
没
有
对
yield
有
个
初
步
的
认识
，
那
么
先
把
yield
看
做
"return"
，
这
个
是
直
观
的
，
它
⾸
先
是
个
return,
普
通
的
return
就
是
在
程
序
中
返
回
某
个
值
，
返
回
之
后
程
序
就
不
再
往
下
运
⾏
了
。
看
做
return
之
后
再
把
它
看
做
是
⼀个
⽣
成
器
(generator)
的
⼀
部
分
(
带
yield
的
函
数
才
是
真
正
的
迭
代
器
)
。
好
了
，
如
果
你
对
这
些
不
明
⽩的
话
，
那
先
把
yield
看
做
return
，
然
后
直
接
看
下
⾯
的
程
序
，
你
就
会
明
⽩
yield
的
全
部
意
思
了
：
就
这
么
简
单
的
⼏
⾏
代
码
就
让
你
明
⽩
什么
是
yield
，
代
码的
输
出
是
这
个：
直
接
解
释
代
码
运
⾏
顺
序
，
相
当
于代
码
单
步
调试
：
1.
程
序开
始
执
⾏
以
后
，
因
为
foo
函
数
中
有
field
关
键
字
，
所
以
foo
函
数
并
不
会
真的
执
⾏
，
⽽
是
先
得
到
⼀个
⽣
成
器
g(
相
当
于
⼀个
对
象
)
；
2.
直
到
调
⽤
next
⽅
法
，
foo
函
数
正
式开
始
执
⾏
，
先
执
⾏
foo
函
数
中
的
print
⽅
法
，
然
后
进
⼊
while
循
环
；
3.
程
序
遇
到
yield
关
键
字
，
然
后
把
yield
想
象
成
return, return
了
⼀个
4
之
后
，
程
序
停
⽌
，
并
没
有
执
⾏
赋
值
给
res
操
作
，
此
时
next(g)
语
句
执
⾏
完
成
，
所
以
输
出
的
前
两
⾏
(
第
⼀个
是
while
上
⾯
的
print
的
结
果
，
第
⼆
个
是
return
出
的
结
果
)
是
执
⾏
print(next(g))
的
结
果
；
4.
程
序
执
⾏
print("" * 20),
输
出
20
个
5.
⼜
开
始
执
⾏
下
⾯
的
print(next(g))
，
此
时
和
上
⾯
那
个
差
不
多
，不
过
不
同
的
是
，
这
个
时
候
是
从
刚
才
那
个
next
程
序
停
⽌
的
地
⽅
开
始
执
⾏
的
，
也
就
是
要
执
⾏
res
的
赋
值
操
作
，
这
时
候
要
注
意
，
此
时
的
赋
值
操
作
的
starting...
4
*****************
res: None
4
def foo():
print("starting...")
while True:
res = yield 4
print("res:", res)
g = foo()
print(next(g))
print("*" * 20)
print(next(g))
1
2
3
4
5
6
7
8
9
资源评论
