主页 / 问题 / 721650
Accepted
iRumba
Asked:2020-09-22 14:24:46 +0000 UTC2020-09-22 14:24:46 +0000 UTC

关于 x = yield f() 的问题——调用和赋值的顺序是什么？

  • 772

解释函数内的这一行是什么意思

some_variable = yield some_function()

如果我理解正确，yield some_function()在这种情况下，它会将结果发送到生成器，然后将结果写入变量，并在此分配后继续执行代码。

如果我理解正确，那么问题。赋值是在当前结果返回处理后发生，还是当前函数先执行到最后，再将结果返回给生成器？

python

2 个回答

  1. Best Answer

    如果你创建了一个生成器g = gen()，那么它自己什么也不做，直到它从外部被提升next(g)。next(g)相当于g.send(None)。

    g.send(y)允许您将值传递给生成器：

    def gen():
    while True:
        x = yield '.'
        print(x * x)

    由于它g = gen()不会自行推进生成器，因此有必要调用next(g)以使代码与x = yield '.'. 由于函数开头没有yield，所以第一次调用总是等价于g.send(None). 在后续调用中传递的值y已经分配给x：

    >>> g = gen()
>>> z = g.send(None)
>>> z
'.'
>>> z = g.send(1)
1
>>> z
'.'
>>> z = g.send(2)
4
>>> z
'.'

    在这种情况下，生成器'.'不断生成。

    可以看出第一次调用g.send(None)没有到达x（否则我们以后会收到一个TypeError，因为None * None）。也就是说，传递给的值g.send()从yield生成器所在的位置返回，然后代码前进到下一个yield，其参数作为结果返回并分配给z.

    现在您可以解释会发生什么：

    def gen():
    some_variable = yield some_function()

    一步步：

    1. 创建一个生成器：

      >>> g = gen()

      生成器内部的代码不会被执行。

    2. 我们将代码推进到第一个产量，它被称为some_function()，我们得到 的值some_function()：

      >>> g.send(None)
'result from some_function()'

      some_variable最后尚未分配的名称g.send()

    3. 以下调用g.send(1)分配1一个some_variable名称并在代码离开生成器时引发 StopIteration：

      >>> g.send(1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

    这些生成器，或有时称为协程，可用于在单个线程中交错执行多个函数。一个实际的例子，你可以使用 装饰器NREQUESTS对并发请求执行网络请求：NCONCURRENTtwisted.internet.defer.inlineCallbacks

    #!/usr/bin/env python
"""Make NREQUESTS http POST requests `NCONCURRENT` at the time using treq module."""
import os
from twisted.internet import defer, task # $ pip install twisted
import treq                              # $ pip install treq

def n_at_a_time(it, n):
    """Iterate over `it` concurently `n` items at a time.

    `it` - an iterator creating Deferreds
    `n`  - number of concurrent iterations
    return a deferred that fires on completion
    """
    return defer.DeferredList([task.coiterate(it) for _ in range(n)])

@defer.inlineCallbacks
def make_request():
    # post request
    response = yield treq.post('http://localhost:8001/post', {'a':'b', 'c': 'd'})
    data = yield response.content()  # read response

def main(reactor):
    reqs = (make_request() for _ in range(int(os.environ['NREQUESTS'])))
    return n_at_a_time(reqs, n=int(os.environ['NCONCURRENT']))

task.react(main)

    一种类似但略有不同的机制（基于yield from而不是on yield）适用于 asyncio 协程。

    • 3

  2. 这是一个粗略的解释：

    some_function = lambda: 'some_function result'

def func():
    while True:
        value = some_function()
        print('value', value)
        result = yield value
        print('result', result)

g = func()
value = next(g) # инициализация генератора(обязательно), и получение value
value = next(g) # и еще просто получить value
g.send(1) # передаем 1 в генератор, теперь result = 1
value = g.send(2) # передаем 2 в генератор, теперь result = 2. Также получаем value
    1. 也就是说，如果你只想得到value它，你只需要value = next(g).
    2. 如果你想安装并得到你需要result的东西。YOU_RESULTvaluevalue = g.send(YOU_RESULT)

    另请注意-g.send(YOU_RESULT)需要初始化。这整件事对于https://ru.wikipedia.org/wiki/ Coroutine来说都是必要的。仅此而已。如果不清楚，请提出问题gnext(g)

    • 0

相关问题