各位， 我很困惑，所以我什至没有正确地问问题，但这里是:

我有一个使用 inlineCallbacks 的扭曲应用程序。现在我需要定义一个迭代器，这意味着将生成器返回给调用者。但是，迭代器不能被 inlineCallbacks 修饰，可以吗？如果没有，那么我该如何编写这样的代码。

澄清一下:目标是 process_loop 需要每隔 5 秒调用一次，它只能处理 1 block ，比如 10 秒，然后它必须放手。但是，要知道这 10 个 block (存储在 cached 中，它是一个 dict 的一个 dict)，它需要调用一个返回 deferred 的函数。

@inlineCallbacks ### can\'t have inlineCallbacks here, right?
def cacheiter(cached):
    for cachename,cachevalue in cached.items():
        result = yield (call func here which returns deferred)
        if result is True:
            for k,v in cachedvalue.items():
                yield cachename, k, v

@inlineCallbacks
def process_chunk(myiter, num):
    try:
        for i in xrange(num):
            nextval = myiter.next()
            yield some_processing(nextval)
        returnValue(False)
    except StopIteration:
        returnValue(True)

@inlineCallbacks
def process_loop(cached):
    myiter = cacheiter(cached)
    result = yield process_chunk(myiter, 10)
    if not result:
        print 'More left'
        reactor.callLater(5, process_loop, cached)
    else:
        print 'All done'

最佳答案

你是对的，你不能在 cacheiter 中表达你想要表达的东西。 inlineCallbacks 装饰器不会让您拥有返回迭代器的函数。如果你用它来装饰一个函数，那么结果就是一个总是返回一个 Deferred 的函数。这就是它的用途。

造成这种困难的部分原因是迭代器不能很好地处理异步代码。如果在生成迭代器的元素时涉及到 Deferred，那么从迭代器中出来的元素将首先是 Deferred。

你可能会做这样的事情来解决这个问题:

@inlineCallbacks
def process_work():
    for element_deferred in some_jobs:
        element = yield element_deferred
        work_on(element)

这可以工作，但它看起来特别奇怪。由于生成器只能屈服于它们的调用者(例如，不能屈服于它们的调用者的调用者)，因此 some_jobs 迭代器对此无​​能为力；只有 process_work 中的词法代码才能产生延迟到 inlineCallbacks 提供的蹦床等待。

如果您不介意这种模式，那么我们可以想象您的代码正在编写如下:

from twisted.internet.task import deferLater
from twisted.internet.defer import inlineCallbacks, returnValue
from twisted.internet import reactor

class cacheiter(object):
    def __init__(self, cached):
        self._cached = iter(cached.items())
        self._remaining = []

    def __iter__(self):
        return self


    @inlineCallbacks
    def next(self):
        # First re-fill the list of synchronously-producable values if it is empty
        if not self._remaining:
            for name, value in self._cached:
                # Wait on this Deferred to determine if this cache item should be included
                if (yield check_condition(name, value)):
                    # If so, put all of its values into the value cache so the next one
                    # can be returned immediately next time this method is called.
                    self._remaining.extend([(name, k, v) for (k, v) in value.items()])

        # Now actually give out a value, if there is one.
        if self._remaining:
            returnValue(self._remaining.pop())

        # Otherwise the entire cache has been visited and the iterator is complete.
        # Sadly we cannot signal completion with StopIteration, because the iterator
        # protocol isn't going to add an errback to this Deferred and check for
        # StopIteration.  So signal completion with a simple None value.
        returnValue(None)


@inlineCallbacks
def process_chunk(myiter, num):
    for i in xrange(num):
        nextval = yield myiter.next()
        if nextval is None:
            # The iterator signaled completion via the special None value.
            # Processing is complete.
            returnValue(True)
        # Otherwise process the value.
        yield some_processing(nextval)

    # Indicate there is more processing to be done.
    returnValue(False)


def sleep(sec):
    # Simple helper to delay asynchronously for some number of seconds.
    return deferLater(reactor, sec, lambda: None)


@inlineCallbacks
def process_loop(cached):
    myiter = cacheiter(cached)
    while True:
        # Loop processing 10 items from myiter at a time, until process_chunk signals
        # there are no values left.
        result = yield process_chunk(myiter, 10)
        if result:
            print 'All done'
            break

        print 'More left'
        # Insert the 5 second delay before starting on the next chunk.
        yield sleep(5)

d = process_loop(cached)

不过，您可以采用的另一种方法是使用 twisted.internet.task.cooperate。 cooperate 接受一个迭代器并使用它，假设使用它可能代价高昂，并将作业拆分为多个 react 器迭代。取上述cacheiter的定义:

from twisted.internet.task import cooperate

def process_loop(cached):
    finished = []

    def process_one(value):
        if value is None:
            finished.append(True)
        else:
            return some_processing(value)

    myiter = cacheiter(cached)

    while not finished:
        value_deferred = myiter.next()
        value_deferred.addCallback(process_one)
        yield value_deferred

task = cooperate(process_loop(cached))
d = task.whenDone()

关于Python 扭曲 : iterators and yields/inlineCallbacks，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/5972664/