标签: yield

这个问题在这里已经有了答案:
在返回IEnumerable时是否有理由不使用'yield return'？

关于这些的好处,这里有几个有用的问题yield return.例如,

• 有人可以揭开yield关键字的神秘面纱

• 有趣地使用c#yield
  关键字

• 什么是yield关键字

我正在寻找关于何时不使用的想法yield return.例如,如果我预计需要返回一个集合中的所有项目,它没有看起来就像yield是有用的,对不对？

什么情况下使用yield会限制,不必要,让我陷入困境,或者应该避免？

我有多个yield返回的生成器对象.准备调用这台发电机是相当费时的操作.这就是我想多次重用发生器的原因.

y = FunctionWithYield()
for x in y: print(x)
#here must be something to reset 'y'
for x in y: print(x)

当然,我正在考虑将内容复制到简单的列表中.

我知道Java本身没有直接的等价物,但也许是第三方？

真的很方便.目前我想实现一个迭代器,它产生一个树中的所有节点,这是大约五行带有yield的代码.

我有一些示例Python代码,我需要在C++中模仿它.我不需要任何特定的解决方案(例如基于协同例程的产量解决方案,尽管它们也是可接受的答案),我只需要以某种方式重现语义.

蟒蛇

这是一个基本的序列生成器,显然太大而无法存储物化版本.

def pair_sequence():
    for i in range(2**32):
        for j in range(2**32):
            yield (i, j)

目标是维护上面序列的两个实例,并以半锁步方式迭代它们,但是以块为单位.在下面的示例中,first_pass使用对序列来初始化缓冲区,并second_pass重新生成相同的精确序列并再次处理缓冲区.

def run():
    seq1 = pair_sequence()
    seq2 = pair_sequence()

    buffer = [0] * 1000
    first_pass(seq1, buffer)
    second_pass(seq2, buffer)
    ... repeat ...

C++

我在C++中找到解决方案的唯一方法就是模仿yieldC++协同程序,但我没有找到关于如何做到这一点的任何好的参考.我也对这个问题的替代(非一般)解决方案感兴趣.我没有足够的内存预算来保存传递之间序列的副本.

我想在布局级别根据实际模板定义进行条件渲染content_for(:an__area),任何想法如何完成？

我认为做这样的事情会很好(lambda做一个yield return):

public IList<T> Find<T>(Expression<Func<T, bool>> expression) where T : class, new()
{
    IList<T> list = GetList<T>();
    var fun = expression.Compile();

    var items = () => {
        foreach (var item in list)
            if (fun.Invoke(item))
                yield return item; // This is not allowed by C#
    }

    return items.ToList();
}

但是,我发现我不能在匿名方法中使用yield.我想知道为什么.该产量的文档只是说,这是不允许的.

由于不允许,我只创建了List并将项目添加到其中.

在Python中,通过生成器表达式创建生成器对象与使用yield语句之间有什么区别吗？

使用产量:

def Generator(x, y):
    for i in xrange(x):
        for j in xrange(y):
            yield(i, j)

使用生成器表达:

def Generator(x, y):
    return ((i, j) for i in xrange(x) for j in xrange(y))

这两个函数都返回生成元组的生成器对象,例如(0,0),(0,1)等.

一个或另一个的任何优点？思考？

谢谢大家!这些答案中有很多很棒的信息和进一步的参考资料!

在thrice方法的Ruby中,以下两个实现之间的行为差​​异是什么？

module WithYield
  def self.thrice
    3.times { yield }      # yield to the implicit block argument
  end
end

module WithProcCall
  def self.thrice(&block)  # & converts implicit block to an explicit, named Proc
    3.times { block.call } # invoke Proc#call
  end
end

WithYield::thrice { puts "Hello world" }
WithProcCall::thrice { puts "Hello world" }

通过"行为差异",我包括错误处理,性能,工具支持等.

我正在寻找代码来在终端中旋转光标并找到它.我想知道代码中发生了什么.特别是for c in spinning_cursor():我从未见过这种语法.是因为我一次从生成器返回一个元素yield,并将其分配给c？在y()中使用x的任何其他例子？

import sys
import time

def spinning_cursor():
    cursor='/-\|'
    i = 0
    while 1:
        yield cursor[i]
        i = (i + 1) % len(cursor)

for c in spinning_cursor():
    sys.stdout.write(c)
    sys.stdout.flush()
    time.sleep(0.1)
    sys.stdout.write('\b')

以下行为对我来说似乎有点违反直觉(Python 3.4):

>>> [(yield i) for i in range(3)]
<generator object <listcomp> at 0x0245C148>
>>> list([(yield i) for i in range(3)])
[0, 1, 2]
>>> list((yield i) for i in range(3))
[0, None, 1, None, 2, None]

最后一行的中间值实际上并不总是None,它们是我们send进入生成器的任何东西,等价(我猜)到下面的生成器:

def f():
   for i in range(3):
      yield (yield i)

令我感到有趣的是,这三条线路都很有用.该参考指出,yield仅在一个函数定义允许的(虽然我可能读错和/或它可能只是已经从旧版本复制).前两行在SyntaxErrorPython 2.7中生成,但第三行不生成.

而且,这似乎很奇怪

• 列表推导返回生成器而不是列表
• 并且生成器表达式转换为列表,相应的列表推导包含不同的值.

有人可以提供更多信息吗？