标签: yield

我想告诉我的Python线程屈服,因此避免不必要地占用CPU.在Java中,您可以使用该Thread.yield()函数执行此操作.我不认为Python中有类似的东西,所以我一直在使用time.sleep(t)where t = 0.00001.因为t=0似乎没有效果.

我想也许有些东西我对Python的线程模型没有正确理解,因此缺少原因thread.yield().有人可以向我澄清这个吗？谢谢!

PS:这是Java的文档Thread.yield()所说的:

导致当前正在执行的线程对象暂时暂停并允许其他线程执行.

我知道从技术上讲,一个接口用于读取而不是写入或编辑,但是,我想在下面的类中添加一个add和addrange函数,这是我目前所拥有的哪个不起作用

public class HrefCollection : IEnumerable<Href> 
{
    private IEnumerable<Href> hrefs;

    public IEnumerable<Href> Add( Href href )
    {
        yield return href;
    }

    public IEnumerable<Href> AddRange( List<Href> hrefs )
    {
        foreach( Href href in hrefs )
        {
            yield return href;
        }
    }

    public IEnumerator<Href> GetEnumerator()
    {
        return hrefs.GetEnumerator();
    }

    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
    {
        return hrefs.GetEnumerator();
    }
}

我不太确定如何将收益率回报与私人清单联系起来.

谢谢你的帮助!

我在我的应用程序中有大块的HTML,我想进入共享模板,然后使用content_for和yield来插入必要的内容.但是,如果我在同一个布局文件中多次使用它,则content_for只会附加到之前的那个想法不能很好地工作.这个问题有方法解决吗？

<div class="block side">
    <div class="block_head">
        <div class="bheadl"></div>
        <div class="bheadr"></div>
        <h2><%= yield :block_head %></h2>
    </div>
    <div class="block_content">
        <%= yield :block_content %>
    </div>
    <div class="bendl"></div>
    <div class="bendr"></div>
</div>

我使用以下代码设置块的内容

    <%= overwrite_content_for :block_head do -%>
        My Block
    <% end -%>
    <%= overwrite_content_for :block_content do -%>
        <p>My Block Content</p>
    <% end -%>
    <%= render :file => "shared/_blockside" %>

问题是如果我在同一布局上多次使用它,原始块中的内容将附加到辅助块

我已经尝试创建一个自定义帮助方法来解决它,但它不会返回任何内容

  def overwrite_content_for(name, content = nil, &block)
    @_content_for[name] = ""
    content_for(name, content &block)
  end

我可能也会对此完全错误,如果有更好的方法可以让内容像我一样工作,我想知道.谢谢.

这是一个奇怪的问题，所以我将解释：

我有一个像这样的生成器，它充当 IRC 服务器的生成器前端：

def irc_iter(): # not the real code, simplified
    msgs = get_msgs()
    for msg in msgs:
        if is_ping(msg):
            pong()
        else:
            to_send = yield msg
            for s in to_send:
                send(s)

从理论上讲，这应该允许我做一些很酷的事情，例如：

server = connect()
for line in server:
       if should_respond(line):
           server.send('WOW SUCH MESSAGE')

但是，有一个问题：也会generator.send 产生下一个值。这意味着这server.send也给了我下一条消息......我更愿意像所有其他消息一样处理它，产生为line.

我知道我可以用一种丑陋的方式来解决这个问题，在接收到发送后只产生一个垃圾值，但我试图保持我的代码优雅，但恰恰相反。有没有办法告诉生成器我还不需要新值？

谢谢。

我是一名C#程序员,试图理解一些Python代码.有问题的代码是生成器函数,如下所示:

def func():
    oldValue = curValue
    yield
    curValue = oldValue

如果我理解正确,这将生成一个包含一个成员的可迭代序列.但是,yield声明后没有表达.什么是这种无表达式的陈述应该产生什么？有没有使用这种编码方式的Python习语？

我需要编写一个简单的脚本来加载来自多个文件的数据并以某种方式合并它.但是,鉴于文件可能非常庞大,我想部分加载数据.为此,我决定使用yield.根据示例,我发现我可以使用以下构造用于单个发电机:

$generator = $someClass->load(); //load method uses yield so it returns generator object
foreach($generator as $i) {
  // do something
}

但是如果我想一次使用两台发电机呢？

$generatorA = $someClass1->load(); //load method uses yield so it returns generator object
$generatorB = $someClass2->load(); //load method uses yield so it returns generator object
foreach($generatorA as $i) {
  // how can I access to resultSet from generatorB here?
}

我和一位同事在PHP版本:5.5.11中使用新关键字"yield"发现了一个非常奇怪的行为,我们想知道以下是否正常:

给出以下代码:

function yieldTest()
{
    echo 'wtf1';
    die('wtf2');

    foreach (['foo', 'bar', 'baz'] as $each) {
        yield $each;
    }
}

var_dump(yieldTest()); 

关于这一点的奇怪之处在于,如果函数中存在"yield",则:echo和die完全被跳过并且不被执行,并且仅对象"yield"构建是var_dumped.

当我们手动构建数组/对象并使用return时,它按预期工作.

我们发现,一旦函数中存在yield,它甚至会跳过抛出异常.

这种非常奇怪的行为是真的意图还是我们发现了一个错误？

我们不能真正相信这是需要的,因为它会大大降低功能的可靠性.

谷歌也没有找到任何与此问题有关的信息,为什么我认为我在这里问.

我正在思考一个更先进的方向,也很难找到解决这个问题的方法.在做出任何决定之前,我想过要求专家建议来解决这个问题.

增强型生成器具有新方法.send()和.throw(),允许调用者传递消息或将异常引入生成器(协同程序).

从python文档:这可以非常方便,尤其是.throw()方法,它请求生成器处理调用者中引发的异常.

请求#1:上述语句的任何示例代码.我没有找到任何代码片段来解释这个问题.

但是,我也在考虑反问题:生成器是否可以引发异常,将其传递给调用者,让调用者"修复"它,并继续生成器自己的执行？这就是我想称之为"反向投掷".

请求#2:上述语句的任何示例代码.我没有找到任何代码片段来解释这个问题.

简单地在生成器中引发异常就不行了.我尝试在生成器中"引发SomeException",但这不起作用,因为在"加速"之后,生成器无法再执行---它只是停止,并且进一步尝试运行生成器会导致StopIteration异常.换句话说,"加注"比"收益"更致命:一个人可以在屈服于来电者后恢复自己,但是"加注"将自己发送到死胡同.

我想知道是否有简单的方法在Python中进行"反向投掷"？这将使我们能够通过互相抛出异常来编写协同程序.但为什么要使用例外？好吧,我不知道......这一切都是从一些粗略的想法开始的.

案例研究代码:

class MyException(Exception):pass


def handleError(func):
''' handle an error'''
    errors =[]
    def wrapper(arg1):
        result = func(arg1)

        for err in findError(result):
            errors.append(err)

        print errors
        return result

    return wrapper

def findError(result):
'''
Find an error if any
'''
    print result
    for k, v in result.iteritems():
        error_nr = v % 2
        if error_nr ==0:
            pass
        elif error_nr > 0:
            yield MyException

@handleError
def numGen(input):

''' This function take the input and generates 10 …

Java 13引入了yield用于switch表达式的关键字。

我该如何使用它？它与默认值return或break值有什么区别？

假设我有一个表示某些变量范围的 Python 列表：

conditions = [['i', (1, 5)], ['j', (1, 2)]]

这表示变量i范围从 1 到 5，在该循环变量j范围内从 1 到 2。我想要每个可能的组合的字典：

{'i': 1, 'j': 1}
{'i': 1, 'j': 2}
{'i': 2, 'j': 1}
{'i': 2, 'j': 2}
{'i': 3, 'j': 1}
{'i': 3, 'j': 2}
{'i': 4, 'j': 1}
{'i': 4, 'j': 2}
{'i': 5, 'j': 1}
{'i': 5, 'j': 2}

原因是我想迭代它们。但是因为整个空间太大，我不想生成所有这些，存储它们然后迭代那个字典列表。我考虑过使用以下递归过程，但我需要这部分的帮助yield。它应该在哪里？如何避免嵌套生成器？

def iteration(conditions, currentCondition, valuedIndices):
    if currentCondition == len(conditions):
        yield valuedIndices
    else:
        cond = conditions[currentCondition]
        index …