Python 3: send method of generators
I can't understand the send method. I understand that it is used to operate the generator. But the syntax is here: generator.send(value) .
I somehow can't catch why the value should become the result of the current yield expression. I prepared an example:
def gen():
for i in range(10):
X = yield i
if X == 'stop':
break
print("Inside the function " + str(X))
m = gen()
print("1 Outside the function " + str(next(m)) + 'n')
print("2 Outside the function " + str(next(m)) + 'n')
print("3 Outside the function " + str(next(m)) + 'n')
print("4 Outside the function " + str(next(m)) + 'n')
print('n')
print("Outside the function " + str(m.send(None)) + 'n') # Start generator
print("Outside the function " + str(m.send(77)) + 'n')
print("Outside the function " + str(m.send(88)) + 'n')
#print("Outside the function " + str(m.send('stop')) + 'n')
print("Outside the function " + str(m.send(99)) + 'n')
print("Outside the function " + str(m.send(None)) + 'n')
The result is:
1 Outside the function 0
Inside the function None
2 Outside the function 1
Inside the function None
3 Outside the function 2
Inside the function None
4 Outside the function 3
Inside the function None
Outside the function 4
Inside the function 77
Outside the function 5
Inside the function 88
Outside the function 6
Inside the function 99
Outside the function 7
Inside the function None
Outside the function 8
Well, frankly speaking, it is astonishing me.
yield statement is executed, the state of the generator is frozen and the value of expression_list is returned to next 's caller. Well, it doesn't seem to have happened. Why can we execute if statement and print function inside gen() . X inside and outside the function differs? Ok. Let us assume that send(77) transmits 77 into m . Well, yield expression becomes 77. Then what is X = yield i ? And how 77 inside the function converts into 5 when occurs outside? Anyway, could you somehow comment on these send and yield statements?
When you use send and expression yield in a generator, you're treating it as a coroutine; a separate thread of execution that can run sequentially interleaved but not in parallel with its caller.
When the caller executes R = m.send(a) , it puts the object a into the generator's input slot, transfers control to the generator, and waits for a response. The generator receives object a as the result of X = yield i , and runs until it hits another yield expression eg Y = yield j . Then it puts j into its output slot, transfers control back to the caller, and waits until it gets resumed again. The caller receives j as the result of R = m.send(a) , and runs until it hits another S = m.send(b) statement, and so on.
R = next(m) is just the same as R = m.send(None) ; it's putting None into the generator's input slot, so if the generator checks the result of X = yield i then X will be None .
As a metaphor, consider a dumb waiter:
When the server gets an order from a customer, they put the pad in the dumb waiter, send it to the kitchen, and wait by the hatch for the dish:
R = kitchen.send("Ham omelette, side salad")
The chef (who's been waiting by the hatch) picks up the order, prepares the dish, yield s it to the restaurant, and waits for the next order:
next_order = yield [HamOmelette(), SideSalad()]
The server (who's been waiting by the hatch) takes the dish to the customer and returns with another order, etc.
Because both the server and chef wait by the hatch after send ing an order or yield ing a dish, there's only one person doing anything at any one time ie the process is single threaded. Both sides can use normal control flow, as the generator machinery (the dumb waiter) takes care of interleaving execution.
The most confusing part should be this line X = yield i , specially when you call send() on the generator. Actually the only thing you need to know is:
in the lexical level: next() is equal to send(None)
in the interpreter level: X = yield i equals to below lines( ORDER MATTERS ):
yield i
# won't continue until next() or send() is called
# and this is also the entry point of next() or send()
X = the_input_of_send
and, the 2 lines of comment is the exact reason, why we need to call send(None) for the first time, because the generator will return i (yield i ) before assign the value to X
def gen():
i = 1
while True:
i += 1
x = yield i
print(x)
m = gen()
next(m)
next(m)
m.send(4)
result
None
4
look at more simplified codes above.
I think the thing leaded to your confusion is 'x = yield i' statment, this statment is not saying value accepted from send() method assgined to i then i assgined to x. Instead, value i is returned by yield statment to generator, x is assgined by send() method.One statement does two thing at same time.
上一篇: 物联网请求响应协议
下一篇: Python 3：发送器的发送方法