This article illustrates the usage of Python yield. Share with you for your reference, as follows:
The English word yield means production. When I first came into contact with Python, I was very confused and never understood the usage of yield.
It is just a rough idea that yield can be used to stuff data for a function return value, such as the following example:
def addlist(alist):for i in alist:yield i +1
Take out each item of alist, and then put i + 1 in it. Then take out each item by calling:
alist =[1,2,3,4]for x inaddlist(alist):
print x,
This is indeed an example of yield application
1. Function containing yield
If you see that a function contains yield, it means that this function is already a Generator, and its execution will be quite different from other ordinary functions. For example, the following simple function:
def h():
print 'To be brave'yield5h()
As you can see, after calling h(), the print statement is not executed! This is yield, so how do you make the print statement execute? This is the issue to be discussed later. Through the following discussion and learning, you will understand the working principle of yield.
2. yield is an expression
Before Python 2.5, yield was a statement, but now in 2.5, yield is an expression (Expression), such as:
m =yield5
The return value of the expression (yield 5) will be assigned to m, so it is wrong to think that m = 5. So how to get the return value of (yield 5)? Need to use the send (msg) method to be introduced later.
3. See the principle through the next() statement
Now, let's reveal the working principle of yield. We know that our h() above is not executed after being called, because it has a yield expression, so we let it execute through the next() statement. The next() statement will resume the execution of the Generator until the next yield expression. such as:
def h():
print 'Wen Chuan'yield5
print 'Fighting!'
c =h()
c.next()
After c.next() is called, h() starts to execute until it encounters yield 5, so the output result:
Wen Chuan
When we call c.next() again, execution will continue until we find the next yield expression. Since there is no yield later, an exception will be thrown:
Wen Chuan
Fighting!
Traceback (most recent call last):
File “/home/evergreen/Codes/yidld.py”, line 11, in <module
c.next()
StopIteration
4. send(msg) and next()
After understanding how next() makes the function containing yield execute, let's look at another very important function send(msg). In fact, next() and send() have similar functions in a certain sense. The difference is that send() can pass the value of the yield expression into it, while next() cannot pass a specific value, but can only pass None into it. Therefore, we can view it as
c.next() and c.send(None) have the same effect.
Look at this example:
def h():
print 'Wen Chuan',
m =yield5 # Fighting!
print m
d =yield12
print 'We are together!'
c =h()
c.next() #Equivalent to c.send(None)
c.send('Fighting!') #(yield5)The expression is given'Fighting!'
The output result is:
Wen Chuan Fighting!
It should be reminded that when you call for the first time, please use the next() statement or send(None). You cannot use send to send a non-None value, otherwise an error will occur because there is no yield statement to receive this value.
5. The return value of send(msg) and next()
send(msg) and next() have return values, their return values are very special, and they return the parameters of the next yield expression. For example, if yield 5, then 5 is returned. At this point, do you understand something? In the first example of this article, traversing the Generator through for i in alist actually calls alist.Next() every time, and each time the return value of alist.Next() is the parameter of yield, that is, we begin to think that it is Dongdong pressed in. Let's continue the above example:
def h():
print 'Wen Chuan',
m =yield5 # Fighting!
print m
d =yield12
print 'We are together!'
c =h()
m = c.next() #m gets the parameter value 5 of yield5
d = c.send('Fighting!') #d gets the parameter value 12 of yield12
print 'We will never forget the date', m,'.', d
Output result:
Wen Chuan Fighting!
We will never forget the date 5 . 12
6. throw() and close() interrupt Generator
Interrupting the Generator is a very flexible technique. You can terminate the Generator by throwing a GeneratorExit exception. The function of the Close() method is the same, but internally it calls throw(GeneratorExit). We look at:
def close(self):try:
self.throw(GeneratorExit)except(GeneratorExit, StopIteration):
pass
else:
raise RuntimeError("generator ignored GeneratorExit")
# Other exceptions are not caught
Therefore, when we call the close() method and then call next() or send(msg), an exception will be thrown:
Traceback (most recent call last):
File “/home/evergreen/Codes/yidld.py”, line 14, in <module
d = c.send('Fighting!') #d got the parameter value 12 of yield 12
StopIteration
For more information about Python, please refer to the topic of this site: "Python Data Structure and Algorithm Tutorial", "Python Socket Programming Skills Summary", "Python Function Use Skills Summary", "Python String Operation Skills Summary" and "Python Introduction and Advanced Classic Course"
I hope this article will help you in Python programming.
Recommended Posts