Deep understanding of yield

The English word yield means production. I was very confused when I first came into contact with Python and I never figured out how to use yield.

I just roughly know that yield can be used to stuff data into the return value of a function, such as the following example:

def addlist(alist):
    for i in alist:
        yield i + 1

Take out each item of alist, and then stuff i + 1 into it. Then take out each item by calling:

alist = [1, 2, 3, 4]
for x in addlist(alist):
    print x,

This is indeed an example of yield application

1. Function containing yield

If you see a function containing yield, it means that this function has It is a Generator, and its execution will be many different from other ordinary functions. For example, the following simple function:

def h():
    print 'To be brave'
    yield 5
h()

You can see that after calling h(), the print statement is not executed! This is yield, so how to make the print statement execute? This is the issue that will be discussed later. Through the subsequent discussion and study, you will understand how yield works.

2. Yield is an expression

Before Python 2.5, yield was a statement, but now in Python 2.5, yield is an expression (Expression), such as:

m = yield 5

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)? You need to use the send(msg) method that will 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 was 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 Generator execution until the next yield expression. For example:

def h():
    print 'Wen Chuan'
    yield 5
    print 'Fighting!'
c = h()
c.next()

After c.next() is called, h() starts executing until it encounters yield 5, so the output result is:

Wen Chuan

When we call c.next() again, Execution will continue until the next yield expression is found. 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() causes the function containing yield to be executed, let’s look at another one The 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, while next() cannot pass a specific value and can only pass None. Therefore, we can see that

c.next() and c.send(None) have the same effect.

Look at this example:

def h():
    print 'Wen Chuan',
    m = yield 5  # Fighting!
    print m
    d = yield 12
    print 'We are together!'
c = h()
c.next()  #相当于c.send(None)
c.send('Fighting!')  #(yield 5)表达式被赋予了'Fighting!'

The output result is:

Wen Chuan Fighting!

It should be reminded that when calling 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. Return values ​​of send(msg) and next()

send(msg) and next() have return values. Their return values ​​are very special. They return the parameters of the next yield expression. For example, if yield 5, 5 will be returned. Did you understand something here? In the first example of this article, by traversing the Generator through for i in alist, alist.Next() is actually called every time, and the return value of alist.Next() each time is the parameter of yield, that is, we begin to think that it is being Something pressed in. Let’s continue the above example:

def h():
    print 'Wen Chuan',
    m = yield 5  # Fighting!
    print m
    d = yield 12
    print 'We are together!'
c = h()
m = c.next()  #m 获取了yield 5 的参数值 5
d = c.send('Fighting!')  #d 获取了yield 12 的参数值12
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 the Generator

Interrupting the Generator is a very flexible technique, you can throw it by throwing Throw a GeneratorExit exception to terminate the Generator. The Close() method has the same function. In fact, it calls throw(GeneratorExit) internally. Let’s see:

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(&#39;Fighting!&#39;)  #d 获取了yield 12 的参数值12
StopIteration