38 题: “yield”关键字有什么作用?

在...创建的问题 Thu, May 2, 2019 12:00 AM

Python中yield关键字的用途是什么?它做了什么?

例如,我正在尝试理解此代码 1

 
def _get_child_candidates(self, distance, min_dist, max_dist):
    if self._leftchild and distance - max_dist < self._median:
        yield self._leftchild
    if self._rightchild and distance + max_dist >= self._median:
        yield self._rightchild  

这是来电者:

 
result, candidates = [], [self]
while candidates:
    node = candidates.pop()
    distance = node._get_dist(obj)
    if distance <= max_dist and distance >= min_dist:
        result.extend(node._values)
    candidates.extend(node._get_child_candidates(distance, min_dist, max_dist))
return result

调用方法_get_child_candidates会发生什么? 列表是否返回?单个元素?它又被召唤了吗?后续呼叫何时停止?


这段代码是由Jochen Schulz(jrschulz)编写的,他为度量空间创建了一个很棒的Python库。这是完整来源的链接:模块mspace

    
9314
30答案                              30 跨度>                         

要了解yield的作用,您必须了解生成器是什么。在您了解生成器之前,您必须了解 iterables

Iterables

创建列表时,您可以逐个阅读其内容。逐个读取它的项目称为迭代:

 
>>> mylist = [1, 2, 3]
>>> for i in mylist:
...    print(i)
1
2
3

mylist可迭代的。当您使用列表推导时,您创建一个列表,因此是一个可迭代的:

 
>>> mylist = [x*x for x in range(3)]
>>> for i in mylist:
...    print(i)
0
1
4

你可以使用的所有东西“for... in...”都是可迭代的; lists,strings,文件......

这些迭代很方便,因为你可以根据自己的意愿阅读它们,但是你将所有的值存储在内存中,当你有很多值时,这并不总是你想要的。

发电机

生成器是迭代器,是一种可迭代的,只能迭代一次。生成器不会将所有值存储在内存中,它们会动态生成值

 
>>> mygenerator = (x*x for x in range(3))
>>> for i in mygenerator:
...    print(i)
0
1
4

除了你使用()而不是[]之外,它们是一样的。但是,不能第二次执行for i in mygenerator,因为生成器只能使用一次:它们计算0,然后忘记它并计算1,然后逐个计算4。

产量

yield是一个像return一样使用的关键字,除了该函数将返回一个生成器。

 
>>> def createGenerator():
...    mylist = range(3)
...    for i in mylist:
...        yield i*i
...
>>> mygenerator = createGenerator() # create a generator
>>> print(mygenerator) # mygenerator is an object!
<generator object createGenerator at 0xb7555c34>
>>> for i in mygenerator:
...     print(i)
0
1
4

这是一个无用的例子,但是当你知道你的函数将返回一组你只需要阅读一次的大量值时它会很方便。

要掌握yield,你必须明白当你调用函数时,你在函数体中编写的代码不会运行。该函数只返回生成器对象,这有点棘手: - )

然后,每当for使用生成器时,您的代码将从它停止的位置继续。

现在困难的部分:

for第一次调用从函数创建的生成器对象时,它将从头开始运行函数中的代码直到它到达yield,然后它将返回循环的第一个值。然后,每个其他调用将再次运行您在函数中写入的循环,并返回下一个值,直到没有值返回。

一旦函数运行,生成器被认为是空的,但不再命中yield。这可能是因为循环已经结束,或者因为你不再满足"if/else"了。


您的代码已解释

发电机:

 
# Here you create the method of the node object that will return the generator
def _get_child_candidates(self, distance, min_dist, max_dist):

    # Here is the code that will be called each time you use the generator object:

    # If there is still a child of the node object on its left
    # AND if distance is ok, return the next child
    if self._leftchild and distance - max_dist < self._median:
        yield self._leftchild

    # If there is still a child of the node object on its right
    # AND if distance is ok, return the next child
    if self._rightchild and distance + max_dist >= self._median:
        yield self._rightchild

    # If the function arrives here, the generator will be considered empty
    # there is no more than two values: the left and the right children

呼叫者:

 
# Create an empty list and a list with the current object reference
result, candidates = list(), [self]

# Loop on candidates (they contain only one element at the beginning)
while candidates:

    # Get the last candidate and remove it from the list
    node = candidates.pop()

    # Get the distance between obj and the candidate
    distance = node._get_dist(obj)

    # If distance is ok, then you can fill the result
    if distance <= max_dist and distance >= min_dist:
        result.extend(node._values)

    # Add the children of the candidate in the candidates list
    # so the loop will keep running until it will have looked
    # at all the children of the children of the children, etc. of the candidate
    candidates.extend(node._get_child_candidates(distance, min_dist, max_dist))

return result

此代码包含几个智能部分:

  • 循环在列表上迭代,但是循环迭代时列表会扩展:-)这是一个简单的方法来遍历所有这些嵌套数据,即使它有点危险,因为你可以最终得到一个无限循环。在这种情况下,candidates.extend(node._get_child_candidates(distance, min_dist, max_dist))耗尽了生成器的所有值,但while不断创建新的生成器对象,这些对象将生成与之前的值不同的值,因为它不应用于同一节点。

  • extend()方法是一个列表对象方法,它需要一个iterable并将其值添加到列表中。

通常我们将列表传递给它:

 
>>> a = [1, 2]
>>> b = [3, 4]
>>> a.extend(b)
>>> print(a)
[1, 2, 3, 4]

但是在你的代码中它得到了一个生成器,这很好,因为:

  1. 您无需两次读取值。
  2. 您可能有很多孩子,并且您不希望它们都存储在内存中。
  3. 醇>

    它的工作原理是因为Python不关心方法的参数是否是列表。 Python期望iterables所以它将适用于字符串,列表,元组和生成器!这叫做鸭子打字,这也是Python如此酷的原因之一。但这是另一个故事,另一个问题......

    你可以sto在这里,或者阅读一点看看发电机的高级用途:

    控制发电机耗尽

     
    >>> class Bank(): # Let's create a bank, building ATMs
    ...    crisis = False
    ...    def create_atm(self):
    ...        while not self.crisis:
    ...            yield "$100"
    >>> hsbc = Bank() # When everything's ok the ATM gives you as much as you want
    >>> corner_street_atm = hsbc.create_atm()
    >>> print(corner_street_atm.next())
    $100
    >>> print(corner_street_atm.next())
    $100
    >>> print([corner_street_atm.next() for cash in range(5)])
    ['$100', '$100', '$100', '$100', '$100']
    >>> hsbc.crisis = True # Crisis is coming, no more money!
    >>> print(corner_street_atm.next())
    <type 'exceptions.StopIteration'>
    >>> wall_street_atm = hsbc.create_atm() # It's even true for new ATMs
    >>> print(wall_street_atm.next())
    <type 'exceptions.StopIteration'>
    >>> hsbc.crisis = False # The trouble is, even post-crisis the ATM remains empty
    >>> print(corner_street_atm.next())
    <type 'exceptions.StopIteration'>
    >>> brand_new_atm = hsbc.create_atm() # Build a new one to get back in business
    >>> for cash in brand_new_atm:
    ...    print cash
    $100
    $100
    $100
    $100
    $100
    $100
    $100
    $100
    $100
    ...
    

    注意:对于Python 3,请使用print(corner_street_atm.__next__())print(next(corner_street_atm))

    它可以用于控制对资源的访问等各种事情。

    Itertools,你最好的朋友

    itertools模块包含操作iterables的特殊函数。曾经希望复制一台发电机? 链两个发电机?使用单行分组嵌套列表中的值? Map / Zip没有创建另一个列表?

    然后只有import itertools

    一个例子?让我们看看四匹马比赛的可能到达顺序:

     
    >>> horses = [1, 2, 3, 4]
    >>> races = itertools.permutations(horses)
    >>> print(races)
    <itertools.permutations object at 0xb754f1dc>
    >>> print(list(itertools.permutations(horses)))
    [(1, 2, 3, 4),
     (1, 2, 4, 3),
     (1, 3, 2, 4),
     (1, 3, 4, 2),
     (1, 4, 2, 3),
     (1, 4, 3, 2),
     (2, 1, 3, 4),
     (2, 1, 4, 3),
     (2, 3, 1, 4),
     (2, 3, 4, 1),
     (2, 4, 1, 3),
     (2, 4, 3, 1),
     (3, 1, 2, 4),
     (3, 1, 4, 2),
     (3, 2, 1, 4),
     (3, 2, 4, 1),
     (3, 4, 1, 2),
     (3, 4, 2, 1),
     (4, 1, 2, 3),
     (4, 1, 3, 2),
     (4, 2, 1, 3),
     (4, 2, 3, 1),
     (4, 3, 1, 2),
     (4, 3, 2, 1)]
    

    了解迭代的内在机制

    迭代是一个暗示迭代(实现__iter__()方法)和迭代器(实现__next__()方法)的过程。 Iterables是您可以从中获取迭代器的任何对象。迭代器是让你迭代迭代的对象。

    有关 for循环如何工作的文章中有更多内容。

        
13495
2019-05-02 19:34:54Z
  1. 所有迭代器只能迭代一次,而不仅仅是生成器函数生成的迭代器。如果您不相信我,请在任何可迭代对象上调用iter()并尝试多次迭代结果。
    2015-03-03 22:54:31Z
  2. @ Craicerjack你的条款混乱了。可迭代是__iter__方法的东西。迭代器是在可迭代上调用iter()的结果。迭代器只能迭代一次。
    2015-08-24 20:52:18Z
  3. yield并不像这个答案所暗示的那样神奇。当您在任何地方调用包含yield语句的函数时,您将获得一个生成器对象,但不会运行任何代码。然后,每次从生成器中提取对象时,Python都会在函数中执行代码,直到出现yield语句,然后暂停并传递对象。当你提取另一个对象时,Python会在yield之后继续,并继续直到它到达另一个yield(通常是同一个,但稍后再迭代一次)。这种情况一直持续到函数运行结束,此时发电机被认为已耗尽。
    2017-05-23 21:41:53Z
  4. “这些迭代很方便......但是你把所有的值存储在内存中并且这并不总是你想要的”,或者错误或令人困惑。迭代器在迭代器上调用iter()时返回一个迭代器,并且迭代器并不总是必须将其值存储在内存中,这取决于 iter 方法的实现,它也可以生成按需序列中的值。
    2018-02-15 19:21:11Z
  5. 醇>

理解yield的捷径

当你看到一个包含yield语句的函数时,应用这个简单的技巧来理解会发生什么:

  1. 在功能开头插入result = []行。
  2. yield expr替换每个result.append(expr)
  3. 在功能底部插入return result行。
  4. 耶 - 没有更多的yield声明!阅读并找出代码。
  5. 将功能与原始定义进行比较。
  6. 醇>

    这个技巧可以让你了解这个函数背后的逻辑,但yield实际发生的情况与基于列表的方法中发生的情况有很大不同。在许多情况下,yield方法将更高效,更快。在其他情况下,即使原始函数工作得很好,这个技巧也会让你陷入无限循环。继续阅读以了解更多信息......

    不要混淆您的Iterables,Iterators和Generators

    首先,迭代器协议 - 当您编写

    时  
    for x in mylist:
        ...loop body...
    

    Python执行以下两个步骤:

    1. 获取mylist的迭代器:

      致电iter(mylist) - &gt;这将返回一个next()方法的对象(或Python 3中的__next__())。

      [这是大多数人忘记告诉你的步骤]

    2. 使用iterator循环遍历项目:

      继续从步骤1返回的迭代器上调用next()方法。将next()的返回值赋值给x并执行循环体。如果从StopIteration中引发异常next(),则意味着迭代器中没有更多值,并且退出循环。

    3. 醇>

      事实是,Python在任何时候想要循环对象的内容时执行上述两个步骤 - 所以它可能是for循环,但它也可能是像otherlist.extend(mylist)这样的代码(其中otherlist)是一个Python列表。)

      这里mylist iterable ,因为它实现了迭代器协议。在用户定义的类中,您可以实现__iter__()方法以使类的实例可迭代。此方法应返回迭代器。迭代器是具有next()方法的对象。可以在同一个类上实现__iter__()next(),并且__iter__()返回self。这适用于简单的情况,但不希望两个迭代器同时循环遍历同一个对象。

      所以这是迭代器协议,许多对象实现了这个协议:

      1. 内置列表,词典,元组,集合,文件。
      2. 实现__iter__()的用户定义类。
      3. 发电机。
      4. 醇>

        请注意,for循环不知道它正在处理什么类型的对象 - 它只是遵循迭代器协议,并且很高兴得到项目,因为它调用next()。内置列表逐个返回项目,字典逐个返回,文件逐个返回等。然后生成器返回...这就是yield的用武之地:

         
        def f123():
            yield 1
            yield 2
            yield 3
        
        for item in f123():
            print item
        

        如果你在yield中有三个return语句而不是f123()个语句,那么只会执行第一个语句,并且该函数将退出。但是f123()并不是普通的功能。当调用f123()时,它返回yield语句中的任何值!它返回一个生成器对象。此外,该功能并没有真正退出 - 它进入暂停状态。当for循环尝试遍历生成器对象时,该函数从之前返回的yield之后的最后一行恢复其挂起状态,执行下一行代码,在本例中为yield语句,并将其返回为下一个项目。这一过程发生,直到函数退出,此时生成器引发StopIteration,循环退出。

        因此,生成器对象有点像适配器 - 在一端它展示了迭代器协议,通过暴露__iter__()next()方法来保持for循环满意。然而,在另一端,它运行该功能足以从中获取下一个值,并将其重新置于暂停模式。

        为什么使用发电机?

        通常,您可以编写不使用生成器但实现相同逻辑的代码。一种选择是使用我之前提到的临时列表'技巧'。这并不适用于所有情况,例如如果你有无限循环,或者当你有一个很长的列表时它可能会低效地使用内存。另一种方法是实现一个新的可迭代类SomethingIter,它将状态保存在实例成员中,并在其next()(或Python 3中的__next__())方法中执行下一个逻辑步骤。根据逻辑,next()方法中的代码可能看起来非常复杂并且容易出错。这里的发电机提供了一个简洁明了的解决方案。

            
1810
2019-04-24 09:37:06Z
  1. “当你看到一个带有yield语句的函数时,应用这个简单的技巧来理解会发生什么”这不完全忽略这个事实你可以send进入发电机,这是发电机的重要组成部分吗?
    2017-06-17 22:41:34Z
  2. “它可能是一个for循环,但它也可能是像otherlist.extend(mylist)这样的代码” - &gt;这是不正确的。 extend()就地修改列表并且不返回可迭代的列表。试图循环otherlist.extend(mylist)将失败TypeError因为extend()隐式返回None,你不能循环None
    2017-09-14 14:48:17Z
  3. @ pedro你误解了这句话。这意味着当执行mylist时,python在otherlist(而不是otherlist.extend(mylist))上执行上述两个步骤。
    2017-12-26 18:53:57Z
  4. 醇>

这样想:

对于具有next()方法的对象,迭代器只是一个奇特的声音术语。所以屈服函数最终会像这样:

原始版本:

 
def some_function():
    for i in xrange(4):
        yield i

for i in some_function():
    print i

这基本上是Python解释器对上面代码的处理方式:

 
class it:
    def __init__(self):
        # Start at -1 so that we get 0 when we add 1 below.
        self.count = -1

    # The __iter__ method will be called once by the 'for' loop.
    # The rest of the magic happens on the object returned by this method.
    # In this case it is the object itself.
    def __iter__(self):
        return self

    # The next method will be called repeatedly by the 'for' loop
    # until it raises StopIteration.
    def next(self):
        self.count += 1
        if self.count < 4:
            return self.count
        else:
            # A StopIteration exception is raised
            # to signal that the iterator is done.
            # This is caught implicitly by the 'for' loop.
            raise StopIteration

def some_func():
    return it()

for i in some_func():
    print i

为了更深入地了解幕后发生的事情,可以将for循环重写为:

 
iterator = some_func()
try:
    while 1:
        print iterator.next()
except StopIteration:
    pass

这更有意义还是让你更加困惑? :)

我应该注意,为了说明的目的, 过于简单化了。 :)

    
476
2019-05-07 13:28:35Z
  1. __getitem__可以定义而不是__iter__。例如:class it: pass; it.__getitem__ = lambda self, i: i*10 if i < 10 else [][0]; for i in it(): print(i),它将打印:0,10,20,...,90
    2008-10-25 02:03:38Z
  2. 我在Python 3.6中尝试了这个例子,如果我创建iterator = some_function(),变量iterator不再具有next()的函数,而只有__next__()函数。我以为我会提到它。
    2017-05-06 14:37:55Z
  3. 醇>

yield关键字简化为两个简单的事实:

  1. 如果编译器在函数内部检测到yield关键字 where ,则该函数不再通过return语句返回。 相反 立即会返回一个懒惰的“待处理列表”对象,称为生成器
  2. 生成器是可迭代的。什么是 iterable ?它类似于listsetrange或dict-view,带有内置协议,用于按特定顺序访问每个元素
  3. 醇>

    简而言之:生成器是一个懒惰的,递增挂起的列表 yield语句允许您使用函数表示法来编写列表值生成器应该递增吐出来。

     
    generator = myYieldingFunction(...)
    x = list(generator)
    
       generator
           v
    [x[0], ..., ???]
    
             generator
                 v
    [x[0], x[1], ..., ???]
    
                   generator
                       v
    [x[0], x[1], x[2], ..., ???]
    
                           StopIteration exception
    [x[0], x[1], x[2]]     done
    
    list==[x[0], x[1], x[2]]
    

    实施例

    让我们定义一个函数makeRange,就像Python的range一样。拨打makeRange(n)退回发电机:

     
    def makeRange(n):
        # return 0,1,2,...,n-1
        i = 0
        while i < n:
            yield i
            i += 1
    
    >>> makeRange(5)
    <generator object makeRange at 0x19e4aa0>
    

    要强制生成器立即返回其挂起值,您可以将其传递给list()(就像您可以任意迭代一样):

     
    >>> list(makeRange(5))
    [0, 1, 2, 3, 4]
    

    比较“只返回列表”

    的示例

    以上示例可以被视为仅创建您追加并返回的列表:

     
    # list-version                   #  # generator-version
    def makeRange(n):                #  def makeRange(n):
        """return [0,1,2,...,n-1]""" #~     """return 0,1,2,...,n-1"""
        TO_RETURN = []               #>
        i = 0                        #      i = 0
        while i < n:                 #      while i < n:
            TO_RETURN += [i]         #~         yield i
            i += 1                   #          i += 1  ## indented
        return TO_RETURN             #>
    
    >>> makeRange(5)
    [0, 1, 2, 3, 4]
    

    但有一个主要区别;见最后一节。


    如何使用发电机

    iterable是列表推导的最后一部分,并且所有生成器都是可迭代的,所以它们经常被这样使用:

     
    #                   _ITERABLE_
    >>> [x+10 for x in makeRange(5)]
    [10, 11, 12, 13, 14]
    

    为了更好地感受发电机,您可以使用itertools模块(确保在保修时使用chain.from_iterable而不是chain)。例如,您甚至可以使用生成器来实现无限长的惰性列表,如itertools.count()。您可以实现自己的def enumerate(iterable): zip(count(), iterable),或者在while循环中使用yield关键字执行此操作。

    请注意:生成器实际上可用于更多内容,例如实施协同程序或非确定性编程或其他优雅的事物。但是,我在这里提出的“懒惰列表”观点是您将找到的最常见用途。


    幕后花絮

    这就是“Python迭代协议”的工作原理。也就是说,当你做list(makeRange(5))时会发生什么。这就是我之前描述的“懒惰的增量列表”。

     
    >>> x=iter(range(5))
    >>> next(x)
    0
    >>> next(x)
    1
    >>> next(x)
    2
    >>> next(x)
    3
    >>> next(x)
    4
    >>> next(x)
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    StopIteration
    

    内置函数next()只调用对象.next()函数,它是“迭代协议”的一部分,可以在所有迭代器上找到。您可以手动使用next()函数(以及迭代协议的其他部分)来实现奇特的东西,通常以牺牲可读性为代价,因此尽量避免这样做......


    细节点

    通常情况下,大多数人不会关心以下区别,可能想停止阅读。

    在Python中, iterable 是任何“理解for-loop概念”的对象,如列表[1,2,3] iterator 是特定实例所请求的for循环,如[1,2,3].__iter__()生成器是exac与任何迭代器相同,除了它的编写方式(使用函数语法)。

    当您从列表中请求迭代器时,它会创建一个新的迭代器。但是,当您从迭代器(您很少这样做)请求迭代器时,它只会为您提供自己的副本。

    因此,万一你没有做到这样的事情......

     
    > x = myRange(5)
    > list(x)
    [0, 1, 2, 3, 4]
    > list(x)
    []
    

    ...然后记住,生成器是迭代器;也就是说,它是一次性的。如果要重复使用它,请再次拨打myRange(...)。如果需要使用结果两次,请将结果转换为列表并将其存储在变量x = list(myRange(5))中。那些绝对需要克隆生成器的人(例如,谁正在做可怕的hackish元编程)可以使用 itertools.tee 如果绝对必要,因为可复制的迭代器Python PEP 标准提案已被推迟。

        
402
2017-03-19 08:07:35Z
  

yield关键字在Python中的作用是什么?

答案大纲/摘要

  • yield 的功能,返回生成器
  • 生成器是迭代器,因为它们实现了 迭代器协议 ,所以你可以迭代它们。
  • 生成器也可以发送信息,从概念上讲它是 coroutine
  • 在Python 3中,您可以 yield from 在两个方向上委托从一个生成器转移到另一个生成器。
  • (附录批评了几个答案,包括最重要的答案,并讨论了return在发电机中的使用。)

发生器:

yield 仅在函数定义中合法,在函数定义中包含yield会使其返回生成器。

生成器的想法来自其他语言(见脚注1),具有不同的实现。在Python的Generators中,代码的执行是冻结收益率。当调用生成器时(下面讨论方法),执行将恢复,然后在下一次生成时冻结。

yield提供了一个 实现迭代器协议的简便方法,由以下两个定义方法:  __iter__next(Python 2)或__next__(Python 3)。这两种方法 使一个对象成为一个迭代器,您可以使用Iterator Abstract Base进行类型检查 来自collections模块的类。

 
>>> def func():
...     yield 'I am'
...     yield 'a generator!'
... 
>>> type(func)                 # A function with yield is still a function
<type 'function'>
>>> gen = func()
>>> type(gen)                  # but it returns a generator
<type 'generator'>
>>> hasattr(gen, '__iter__')   # that's an iterable
True
>>> hasattr(gen, 'next')       # and with .next (.__next__ in Python 3)
True                           # implements the iterator protocol.

生成器类型是迭代器的子类型:

 
>>> import collections, types
>>> issubclass(types.GeneratorType, collections.Iterator)
True

如有必要,我们可以这样打字检查:

 
>>> isinstance(gen, types.GeneratorType)
True
>>> isinstance(gen, collections.Iterator)
True

Iterator 的功能一旦耗尽,您就可以重复使用或重置它:

 
>>> list(gen)
['I am', 'a generator!']
>>> list(gen)
[]

如果您想再次使用其功能,则必须制作另一个(参见脚注2):

 
>>> list(func())
['I am', 'a generator!']

可以通过编程方式生成数据,例如:

 
def func(an_iterable):
    for item in an_iterable:
        yield item

上面的简单生成器也等同于下面 - 从Python 3.3开始(在Python 2中不可用),你可以使用 yield from

 
def func(an_iterable):
    yield from an_iterable

然而,yield from也允许委托给子发电机, 这将在下一节关于与协同程序的合作授权中进行解释。

协程:

yield形成一个表达式,允许将数据发送到生成器(见脚注3)

以下是一个示例,请注意received变量,该变量将指向发送到生成器的数据:

 
def bank_account(deposited, interest_rate):
    while True:
        calculated_interest = interest_rate * deposited 
        received = yield calculated_interest
        if received:
            deposited += received


>>> my_account = bank_account(1000, .05)

首先,我们必须使用内置函数排队生成器, next 一>。它会 调用适当的next__next__方法,具体取决于版本 你正在使用的Python:

 
>>> first_year_interest = next(my_account)
>>> first_year_interest
50.0

现在我们可以发送数据了发电机。 (发送None是 与拨打next相同。):

 
>>> next_year_interest = my_account.send(first_year_interest + 1000)
>>> next_year_interest
102.5

使用yield from与Sub-Coroutine合作代表团

现在,回想一下,Python 3中提供了yield from.这允许我们委派 corcorines到subcorcorineine:

 
def money_manager(expected_rate):
    under_management = yield     # must receive deposited value
    while True:
        try:
            additional_investment = yield expected_rate * under_management 
            if additional_investment:
                under_management += additional_investment
        except GeneratorExit:
            '''TODO: write function to send unclaimed funds to state'''
        finally:
            '''TODO: write function to mail tax info to client'''


def investment_account(deposited, manager):
    '''very simple model of an investment account that delegates to a manager'''
    next(manager) # must queue up manager
    manager.send(deposited)
    while True:
        try:
            yield from manager
        except GeneratorExit:
            return manager.close()

现在我们可以将功能委托给子发生器,并且可以使用它 通过如上所述的发电机:

 
>>> my_manager = money_manager(.06)
>>> my_account = investment_account(1000, my_manager)
>>> first_year_return = next(my_account)
>>> first_year_return
60.0
>>> next_year_return = my_account.send(first_year_return + 1000)
>>> next_year_return
123.6

您可以在 PEP 380中详细了解yield from的精确语义。

其他方法:关闭并抛出

close方法在该功能点上升GeneratorExit 执行被冻结了。这也将由__del__调用,所以你 可以把任何清理代码放在你处理GeneratorExit的地方:

 
>>> my_account.close()

您还可以抛出可在生成器中处理的异常 或传播回用户:

 
>>> import sys
>>> try:
...     raise ValueError
... except:
...     my_manager.throw(*sys.exc_info())
... 
Traceback (most recent call last):
  File "<stdin>", line 4, in <module>
  File "<stdin>", line 2, in <module>
ValueError

结论

我相信我已经涵盖了以下问题的所有方面:

  

yield关键字在Python中的作用是什么?

事实证明,yield做了很多。我相信我可以添加更多 这方面的例子。如果你想要更多或有一些建设性的批评,请通过评论告诉我 下方。


附录:

对最高/已接受答案的批评**

  • 仅使用列表作为示例,对于可迭代的内容感到困惑。请参阅上面的参考资料,但总结一下:iterable有一个__iter__方法返回迭代器迭代器提供了一个.next(Python 2或.__next__(Python 3)方法,它被for循环隐式调用,直到它引发StopIteration,一旦它出现,它将继续这样做。
  • 然后使用生成器表达式来描述生成器是什么。由于生成器只是创建迭代器的简便方法,因此只会混淆事情,我们还没有达到yield部分。
  • 控制生成器耗尽中,他调用.next方法,而他应该使用内置函数next。这将是一个适当的间接层,因为他的代码在Python 3中不起作用。
  • Itertools?这与yield完全无关。
  • 没有讨论yield提供的方法以及Python 3中的新功能yield from. 最高/接受的答案是一个非常不完整的答案。

批评答案表明yield在生成器表达或理解中。

语法目前允许列表理解中的任何表达。

 
expr_stmt: testlist_star_expr (annassign | augassign (yield_expr|testlist) |
                     ('=' (yield_expr|testlist_star_expr))*)
...
yield_expr: 'yield' [yield_arg]
yield_arg: 'from' test | testlist

由于屈服是一种表达,因此在一些人的吹捧中,在理解或生成器表达中使用它是有趣的 - 尽管没有引用特别好的用例。

CPython核心开发人员讨论弃用其津贴。 这是邮件列表中的相关帖子:

  

2017年1月30日19:05,Brett Cannon写道:

     
    

On Sun,2017年1月29日16:39 Craig Rodrigues写道:

         
      

我对任何一种方法都没关系。把事情留在Python 3中       不好,恕我直言。

    
         

我的投票是它是一个SyntaxError,因为你没有得到你期望的     语法。

  
     

我同意这对我们来说是一个明智的地方,就像任何代码一样   依靠当前的行为真的太聪明了   可维护性。

     

在达到目标方面,我们可能会想:

     
  • 3.7中的语法警告或弃用警告
  •   
  • 2.7.x中的Py3k警告
  •   
  • 3.8中的SyntaxError
  •   

干杯,尼克。

     

- Nick Coghlan | ncoghlan at gmail.com |澳大利亚布里斯班

此外,未决问题(10544)似乎指向了这个方向从不是一个好主意(PyPy,一个用Python编写的Python实现,已经在提出语法警告。)

最重要的是,直到CPython的开发人员告诉我们:不要将yield置于生成器表达式或理解中。

生成器中的return语句

Python 2 中:

  

在生成器函数中,return语句不允许包含expression_list。在t帽子上下文,裸return表示生成器已完成并将导致StopIteration被提升。

expression_list基本上是用逗号分隔的任意数量的表达式 - 实际上,在Python 2中,你可以用return停止生成器,但是你不能返回一个值。

Python 3 中:

  

在生成器函数中,return语句指示生成器已完成并将导致StopIteration被引发。返回值(如果有)用作构造StopIteration的参数,并成为StopIteration.value属性。

脚注

  1. 提案中引用了CLU,Sather和Icon语言 向Python介绍生成器的概念。一般的想法是 一个函数可以维持内部状态并产生中间函数 数据点由用户按需提供。这承诺是卓越的表现 其他方法,包括Python线程,在某些系统上甚至不可用。

  2. 这意味着,例如,xrange个对象(Python 3中的range)不是Iterator,即使它们是可迭代的,因为它们可以被重用。与列表一样,它们的__iter__方法返回迭代器对象。

  3. yield最初是作为声明引入的,意思是它 只能出现在代码块中一行的开头。 现在yield创建了一个yield表达式。 https://docs.python.org/2/reference/simple_stmts的.html#语法令牌yield_stmt 此更改已建议允许用户将数据发送到生成器中 一个人可能会收到它。要发送数据,必须能够将其分配给某些内容,并且 为此,声明不起作用。

321
2017-12-06 20:20:40Z

yield就像return - 它返回你告诉它的任何东西(作为一个发生器)。不同的是,下次调用生成器时,执行从最后一次调用yield语句开始。与return不同,在产生收益时不会清除堆栈帧,但是控制权会转移回调用者,因此下次调用函数时它的状态将恢复。

对于代码,函数get_child_candidates的作用类似于迭代器,因此当您扩展列表时,它会一次向新列表添加一个元素。

list.extend调用迭代器直到它耗尽。对于您发布的代码示例,只返回一个元组并将其附加到列表中会更清楚。

    
276
2019-01-24 09:39:59Z
  1. 这很接近,但不正确。每次调用带有yield语句的函数时,它都会返回一个全新的生成器对象。只有当你调用该生成器的.next()方法时才会在最后一次生成后恢复执行。
    2008-10-24 18:11:04Z
  2. 醇>

还有一件事需要提及:一个收益实际上不必终止的函数。我编写了这样的代码:

 
def fib():
    last, cur = 0, 1
    while True: 
        yield cur
        last, cur = cur, last + cur

然后我可以在其他代码中使用它:

 
for f in fib():
    if some_condition: break
    coolfuncs(f);

它确实有助于简化一些问题,并使一些事情更容易使用。

    
209
2013-04-21 15:42:14Z

对于那些喜欢最小工作示例的人,请冥想这个交互式Python会话:

 
>>> def f():
...   yield 1
...   yield 2
...   yield 3
... 
>>> g = f()
>>> for i in g:
...   print i
... 
1
2
3
>>> for i in g:
...   print i
... 
>>> # Note that this time nothing was printed
    
184
2019-05-08 12:20:10ž

TL; DR 强>

而不是:

 
def square_list(n):
    the_list = []                         # Replace
    for x in range(n):
        y = x * x
        the_list.append(y)                # these
    return the_list                       # lines

执行此操作:

 
def square_yield(n):
    for x in range(n):
        y = x * x
        yield y                           # with this one.

每当你发现自己从头开始建立一个列表时,每件yield

这是我第一次带来收益的“aha”时刻。


yield含糖的说法

  

构建一系列东西

同样的行为:

 
>>> for square in square_list(4):
...     print(square)
...
0
1
4
9
>>> for square in square_yield(4):
...     print(square)
...
0
1
4
9

不同的行为:

收益率单次传递:您只能迭代一次。当函数有一个收益率时,我们将其称为生成器函数。并返回迭代器。这些条款很有启发性。我们失去了容器的便利性,但获得了根据需要计算的系列的能力,并且任意长。

收益率懒惰,它会推迟计算。当你调用它时,一个带有的yield的函数实际上根本不执行。它返回一个迭代器对象,记住它停止的位置。每次在迭代器上调用next()(这发生在for循环中)执行时,前进到下一个yield。 return引发StopIteration并结束系列(这是for循环的自然结束)。

收益率多才多艺。数据不必一起存储,可以一次提供一个。它可以是无限的。

 
>>> def squares_all_of_them():
...     x = 0
...     while True:
...         yield x * x
...         x += 1
...
>>> squares = squares_all_of_them()
>>> for _ in range(4):
...     print(next(squares))
...
0
1
4
9

如果您需要多次传递并且该系列不会太长,请只需拨打list()

 
>>> list(square_yield(4))
[0, 1, 4, 9]

明确选择yield这个词,因为这两个含义适用:

  

产量 - 生产或提供(如农业)

...提供系列中的下一个数据。

  

收益 - 放弃或放弃(如政治权力)

...放弃CPU执行直到迭代器前进。

    
174
2019-01-04 15:30:21Z

Yield为您提供发电机。

 
def get_odd_numbers(i):
    return range(1, i, 2)
def yield_odd_numbers(i):
    for x in range(1, i, 2):
       yield x
foo = get_odd_numbers(10)
bar = yield_odd_numbers(10)
foo
[1, 3, 5, 7, 9]
bar
<generator object yield_odd_numbers at 0x1029c6f50>
bar.next()
1
bar.next()
3
bar.next()
5

如您所见,在第一种情况下,foo一次将整个列表保存在内存中。对于包含5个元素的列表来说,这不是什么大问题,但是如果你想要一个500万的列表呢?这不仅是一个巨大的内存消耗者,而且在调用函数时也需要花费大量时间来构建。

在第二种情况下,bar只给你一个发电机。生成器是可迭代的 - 这意味着您可以在for循环等中使用它,但每个值只能访问一次。所有值也不会同时存储在内存中;生成器对象“记住”上次调用它时循环的位置 - 这样,如果你使用一个可迭代(比方说)计数到500亿,你就不必数到500亿全部立即存储500亿个数字。

同样,这是一个非常人为的例子,如果你真的想要数到500亿,你可能会使用itertools。 :)

这是生成器最简单的用例。正如你所说,它可以用来编写有效的排列,使用yield来通过调用堆栈推送,而不是使用某种堆栈变量。生成器也可以用于专门的树遍历,以及其他各种方式。

    
160
2019-03-13 06:04:08Z
  1. 只是一个注释 - 在Python 3中,range也返回一个生成器而不是一个列表,所以你也会看到一个类似的想法,除了__repr__/__str__被覆盖显示更好的结果,在这种情况下为range(1, 10, 2)
    2019-03-21 18:33:13Z
  2. 醇>

它正在返回一台发电机。我对Python并不是特别熟悉,但是我相信如果您熟悉这些内容,则与 C#的迭代器阻止相同

关键的想法是编译器/解释器/什么做了一些欺骗,所以就调用者而言,他们可以继续调用next()并且它将继续返回值 - 就好像生成器方法是暂停。现在显然你不能真正“暂停”一个方法,所以编译器会建立一个状态机,让你记住你当前的位置以及局部变量等。这比自己编写迭代器容易得多。

    
153
2018-10-31 08:42:59Z

在我描述如何使用发电机的众多优秀答案中,有一种我认为尚未给出的答案。这是编程语言理论的答案:

Python中的yield语句返回一个生成器。 Python中的生成器是一个返回 continuations 的函数(特别是一种协程,但是continuation代表了解更新的一般机制)。

编程语言理论的延续是一种更为基础的计算,但它们并不经常使用,因为它们极难推理并且也很难实现。但是延续的概念是直截了当的:它是尚未完成的计算状态。在此状态下,将保存变量的当前值,尚未执行的操作等。然后在程序后面的某个时刻,可以调用continuation,以便程序的变量重置为该状态,并执行保存的操作。

这种更一般的形式的延续可以用两种方式实现。在call/cc方式中,程序的堆栈实际上是保存的,然后在调用continuation时,堆栈将被恢复。

在连续传递样式(CPS)中,continuation只是普通函数(仅在函数是第一类的语言中),程序员明确地管理它并传递给子例程。在这种风格中,程序状态由闭包(以及恰好在其中编码的变量)表示,而不是驻留在堆栈中某处的变量。管理控制流的函数接受继续作为参数(在CPS的某些变体中,函数可以接受多个延续)并通过简单地调用它们并在之后返回来调用它们来操纵控制流。继续传递样式的一个非常简单的例子如下:

 
def save_file(filename):
  def write_file_continuation():
    write_stuff_to_file(filename)

  check_if_file_exists_and_user_wants_to_overwrite(write_file_continuation)

在这个(非常简单的)示例中,程序员将实际写入文件的操作保存到一个延续中(这可能是一个非常复杂的操作,需要写出许多细节),然后传递该延续(即,对另一个执行更多处理的运算符的第一类闭包,然后在必要时调用它。 (我在实际的GUI编程中经常使用这种设计模式,因为它节省了我的代码行,或者更重要的是,在GUI事件触发后管理控制流。)

本文的其余部分将不失一般性地将延续概念化为CPS,因为它更容易理解和阅读。

结果

现在让我们谈谈Python中的生成器。生成器是延续的特定子类型。虽然延续通常能够保存计算 的状态(即程序的调用堆栈),但生成器只能保存迭代的状态迭代器 。虽然这个定义对于某些发电机的使用情况略有误导。例如:

 
def f():
  while True:
    yield 4

这显然是一个合理的迭代,其行为定义得很好 - 每次生成器迭代它时,它返回4(并且永远这样做)。但是在考虑迭代器时,它可能不是想到的典型迭代类型(即for x in collection: do_something(x))。这个例子说明了生成器的强大功能:如果有什么是迭代器,生成器可以保存迭代的状态。

重申:Continuations可以保存程序堆栈的状态,生成器可以保存迭代状态。这意味着continuation比生成器更强大,但生成器也很多,更容易。它们对于语言设计者来说更容易实现,对于程序员来说它们对我们来说更容易e(如果你有时间刻录,请尝试阅读并理解此页面关于延续和调用/立方厘米)。

但是你可以轻松地实现(和概念化)生成器作为一个简单的,持续传递样式的特定情况:

每当调用yield时,它会告诉函数返回延续。当再次调用该函数时,它从它停止的任何地方开始。因此,在伪伪代码中(即,不是伪代码,而不是代码),生成器的next方法基本如下:

 
class Generator():
  def __init__(self,iterable,generatorfun):
    self.next_continuation = lambda:generatorfun(iterable)

  def next(self):
    value, next_continuation = self.next_continuation()
    self.next_continuation = next_continuation
    return value

其中yield关键字实际上是实际生成器函数的语法糖,基本上类似于:

 
def generatorfun(iterable):
  if len(iterable) == 0:
    raise StopIteration
  else:
    return (iterable[0], lambda:generatorfun(iterable[1:]))

请记住,这只是伪代码,Python中生成器的实际实现更复杂。但是作为理解发生了什么的练习,尝试使用延续传递样式来实现生成器对象而不使用yield关键字。

    
140
2018-05-20 10:25:32Z

这是一个简单语言的例子。我将提供高级人类概念与低级Python概念之间的对应关系。

我想对一系列数字进行操作,但我不想在创建该序列时打扰我自己,我只想专注于我想要做的操作。所以,我做了以下几点:

  • 我打电话给你并告诉你我想要一个以特定方式产生的数字序列,我让你知道算法是什么。
    此步骤对应于生成函数的def,即包含yield的函数。
  • 过了一会儿,我告诉你,“好的,准备好告诉我数字的顺序”。
    这一步对应于调用返回生成器对象的生成器函数。请注意,您还没有告诉我任何数字;你抓住你的纸和铅笔。
  • 我问你,“告诉我下一个号码”,你告诉我第一个号码;之后,你等我问你下一个号码。这是你的工作,要记住你在哪里,你已经说过什么数字,以及下一个数字是什么。我不关心细节。
    此步骤对应于在生成器对象上调用.next()
  • ...重复上一步,直到......
  • 最终,你可能会走到尽头。你没告诉我一个号码;你只是喊道,“抓住你的马!我已经完成了!没有更多的数字!”
    此步骤对应于结束其作业的生成器对象,并引发StopIteration异常生成器函数不需要引发异常。当函数结束或发出return时,它会自动引发。

这是生成器所做的(包含yield的函数);它开始执行,只要它执行yield就会暂停,当被要求获得.next()值时,它会从最后一点继续。它完全符合Python的迭代器协议的设计,它描述了如何顺序请求值。

迭代器协议最着名的用户是Python中的for命令。所以,每当你做一个:

 
for item in sequence:

如果sequence是如上所述的列表,字符串,字典或生成器对象,则无关紧要;结果是一样的:你逐个读取序列中的项目。

请注意,def使用包含yield关键字的函数并不是创建生成器的唯一方法;这只是创建一个最简单的方法。

有关更准确的信息,请参阅迭代器类型, yield语句和生成器

    
126
2018-05-20 10:06:05Z

虽然很多答案显示了为什么你使用yield创建一个生成器,但yield有更多的用途。制作协程非常容易,它可以在两个代码块之间传递信息。我将不再重复使用yield创建生成器的任何精细示例。

帮助了解yield是什么在下面的代码中,您可以使用手指跟踪具有yield的任何代码的循环。每当你的手指击中yield时,你必须等待输入nextsend。当一个next被调用时,你跟踪代码直到你点击yield ... yield右边的代码被评估并返回给调用者......然后你等待。再次调用next时,您将通过代码执行另一个循环。但是,您会注意到在协程中,yield也可以与send一起使用...它将从调用者发送一个值到让步功能。如果给出send,则yield接收发送的值,并将其从左侧吐出......然后通过代码的跟踪进行直到再次击中yield(最后返回值,就像调用next一样)。

例如:

 
>>> def coroutine():
...     i = -1
...     while True:
...         i += 1
...         val = (yield i)
...         print("Received %s" % val)
...
>>> sequence = coroutine()
>>> sequence.next()
0
>>> sequence.next()
Received None
1
>>> sequence.send('hello')
Received hello
2
>>> sequence.close()
    
110
2014-02-04 02:27:35Z
  1. 可爱! 蹦床(在Lisp意义上)。通常不会看到那些!
    2015-12-04 18:31:17Z
  2. 醇>

还有另外yield的用途和含义(自Python 3.3起):

 
yield from <expr>

来自 PEP 380 - 委托给子发电机的语法

  

建议生成器将其部分操作委托给另一个生成器。这允许将包含'yield'的代码段分解出来并放在另一个生成器中。此外,允许子生成器返回一个值,该值可供委派生成器使用。

     

当一个生成器重新生成另一个生成器生成的值时,新语法也会为优化提供一些机会。

此外,将介绍(自Python 3.5起):

 
async def new_coroutine(data):
   ...
   await blocking_action()

避免协程与常规生成器混淆(今天两者都使用了yield)。

    
102
2018-05-20 10:34:03Z

所有伟大的答案,但对于新手来说有点困难。

我假设你已经学会了return声明。

作为类比,returnyield是双胞胎。 return表示“返回并停止”,而“收益”表示“返回,但继续”

  
  1. 尝试使用return获取num_list。
  2.   醇>
 
def num_list(n):
    for i in range(n):
        return i

运行它:

 
In [5]: num_list(3)
Out[5]: 0

请注意,您只获得一个数字而不是它们的列表。 return永远不会让你高兴,只执行一次并退出。

  
  1. yield
  2.   醇>

return替换为yield

 
In [10]: def num_list(n):
    ...:     for i in range(n):
    ...:         yield i
    ...:

In [11]: num_list(3)
Out[11]: <generator object num_list at 0x10327c990>

In [12]: list(num_list(3))
Out[12]: [0, 1, 2]

现在,你赢了所有数字。

相比return运行一次并停止,yield运行您计划的次数。 您可以将return解释为return one of them,将yield解释为return all of them。这叫做iterable

  
  1. 我们可以用yield重写return语句
  2.   醇>
 
In [15]: def num_list(n):
    ...:     result = []
    ...:     for i in range(n):
    ...:         result.append(i)
    ...:     return result

In [16]: num_list(3)
Out[16]: [0, 1, 2]

这是关于yield的核心。

列表return输出和对象yield输出之间的差异是:

您将始终从列表对象获取[0,1,2],但只能从“对象yield输出”中检索一次。因此,它有一个新名称generator对象,如Out[11]: <generator object num_list at 0x10327c990>所示。

总之,作为一个隐喻的隐喻:

  •  returnyield是双胞胎
  •  listgenerator是双胞胎
88
2018-05-28 09:06:22Z
  1. 这是可以理解的,但一个主要区别是你可以在函数/方法中有多个产量。这个比喻完全打破了。 Yield会记住它在函数中的位置,因此下次调用next()时,函数会继续执行接下来的yield。我认为这很重要,应该表达出来。
    2018-08-23 13:27:21Z
  2. 醇>

以下是一些如何实际实现生成器的Python示例,就像Python没有为它们提供语法糖一样:

作为Python生成器:

 
from itertools import islice

def fib_gen():
    a, b = 1, 1
    while True:
        yield a
        a, b = b, a + b

assert [1, 1, 2, 3, 5] == list(islice(fib_gen(), 5))

使用词法闭包代替生成器

 
def ftake(fnext, last):
    return [fnext() for _ in xrange(last)]

def fib_gen2():
    #funky scope due to python2.x workaround
    #for python 3.x use nonlocal
    def _():
        _.a, _.b = _.b, _.a + _.b
        return _.a
    _.a, _.b = 0, 1
    return _

assert [1,1,2,3,5] == ftake(fib_gen2(), 5)

使用对象关闭代替生成器(因为 ClosuresAndObjectsAreEquivalent )  

class fib_gen3:
    def __init__(self):
        self.a, self.b = 1, 1

    def __call__(self):
        r = self.a
        self.a, self.b = self.b, self.a + self.b
        return r

assert [1,1,2,3,5] == ftake(fib_gen3(), 5)
    
86
2017-10-24 10:46:05Z

我打算发布“阅读Beazley的'Python:Essential Reference'第19页,以快速描述发生器”,但是很多其他人已经发布了很好的描述。

另外,请注意yield可以在协同程序中用作它们在生成器函数中的双重使用。虽然它与您的代码片段的用法不同,但(yield)可以用作函数中的表达式。当调用者使用send()方法向方法发送值时,协程将执行,直到遇到下一个(yield)语句。

生成器和协同程序是设置数据流类型应用程序的一种很酷的方法。我认为在函数中了解yield语句的其他用法是值得的。

    
82
2013-01-28 01:37:10Z

从编程的角度来看,迭代器实现为 thunks

为了实现并发执行的迭代器,生成器和线程池等作为thunks(也称为匿名函数),使用发送给具有调度程序的闭包对象的消息,并且调度程序回答“消息”。

http://en.wikipedia.org/wiki/Message_passing

next ”是发送到闭包的消息,由“ iter ”调用创建。

有很多方法可以实现这个计算。我使用了变异,但通过返回当前值和下一个yielder,很容易做到没有变异。

这是一个使用R6RS结构的演示,但语义与Python完全相同。它是相同的计算模型,只需要在Python中重写它就需要改变语法。

 
Welcome to Racket v6.5.0.3.

-> (define gen
     (lambda (l)
       (define yield
         (lambda ()
           (if (null? l)
               'END
               (let ((v (car l)))
                 (set! l (cdr l))
                 v))))
       (lambda(m)
         (case m
           ('yield (yield))
           ('init  (lambda (data)
                     (set! l data)
                     'OK))))))
-> (define stream (gen '(1 2 3)))
-> (stream 'yield)
1
-> (stream 'yield)
2
-> (stream 'yield)
3
-> (stream 'yield)
'END
-> ((stream 'init) '(a b))
'OK
-> (stream 'yield)
'a
-> (stream 'yield)
'b
-> (stream 'yield)
'END
-> (stream 'yield)
'END
->
    
80
2018-05-20 10:29:34Z

这是一个简单的例子:

 
def isPrimeNumber(n):
    print "isPrimeNumber({}) call".format(n)
    if n==1:
        return False
    for x in range(2,n):
        if n % x == 0:
            return False
    return True

def primes (n=1):
    while(True):
        print "loop step ---------------- {}".format(n)
        if isPrimeNumber(n): yield n
        n += 1

for n in primes():
    if n> 10:break
    print "wiriting result {}".format(n)

输出:

 
loop step ---------------- 1
isPrimeNumber(1) call
loop step ---------------- 2
isPrimeNumber(2) call
loop step ---------------- 3
isPrimeNumber(3) call
wiriting result 3
loop step ---------------- 4
isPrimeNumber(4) call
loop step ---------------- 5
isPrimeNumber(5) call
wiriting result 5
loop step ---------------- 6
isPrimeNumber(6) call
loop step ---------------- 7
isPrimeNumber(7) call
wiriting result 7
loop step ---------------- 8
isPrimeNumber(8) call
loop step ---------------- 9
isPrimeNumber(9) call
loop step ---------------- 10
isPrimeNumber(10) call
loop step ---------------- 11
isPrimeNumber(11) call

我不是Python开发人员,但它在我看来yield保持程序流的位置,下一个循环从“yield”位置开始。似乎它正在等待那个位置,就在此之前,在外面返回一个值,下一次继续工作。

这似乎是一个有趣而且很好的能力:D

    
72
2018-05-20 10:31:01Z
  1. 不要忘记2是素数: - )
    2018-07-02 01:20:23Z
  2. 你是对的。但是看到“收益率”的行为对流动的影响是什么?我可以用数学名称改变算法。是否有助于对“收益率”进行不同的评估?
    2018-07-02 01:44:08Z
  3. 醇>

这是yield的精神形象。

我喜欢将一个线程视为具有堆栈(即使它没有以这种方式实现)。

当调用普通函数时,它将其局部变量放在堆栈上,进行一些计算,然后清除堆栈并返回。其局部变量的值再也看不到了。

使用yield函数,当它的代码开始运行时(即在调用函数之后,返回一个生成器对象,然后调用其next()方法),它同样将其局部变量放入堆栈并计算一段时间。但是,当它到达yield语句时,在清除其部分堆栈并返回之前,它会获取其局部变量的快照并将它们存储在生成器对象中。它还会在其代码中写下它当前所处的位置(即特定的yield语句)。

所以它是发电机悬挂的一种冻结功能。

当随后调用next()时,它会将函数的所有物检索到堆栈中并重新设置动画。该功能继续从它停止的地方进行计算,不知道它刚刚在冷库中度过了永恒的事实。

比较以下示例:

 
def normalFunction():
    return
    if False:
        pass

def yielderFunction():
    return
    if False:
        yield 12

当我们调用第二个函数时,它的行为与第一个函数的行为非常不同。 yield语句可能无法访问,但如果它出现在任何地方,它会改变我们正在处理的内容。

 
>>> yielderFunction()
<generator object yielderFunction at 0x07742D28>

调用yielderFunction()不会运行其代码,但会使代码生成一个生成器。 (为了便于阅读,可能以yielder前缀命名这些东西是个好主意。)

 
>>> gen = yielderFunction()
>>> dir(gen)
['__class__',
 ...
 '__iter__',    #Returns gen itself, to make it work uniformly with containers
 ...            #when given to a for loop. (Containers return an iterator instead.)
 'close',
 'gi_code',
 'gi_frame',
 'gi_running',
 'next',        #The method that runs the function's body.
 'send',
 'throw']

gi_codegi_frame字段是存储冻结状态的位置。用dir(..)探索它们,我们可以确认我们上面的心理模型是可信的。

    
59
2017-03-01 13:36:58Z

如同每个答案所示,yield用于创建序列生成器。它用于动态生成一些序列。例如,在网络上逐行读取文件时,可以使用yield函数,如下所示:

 
def getNextLines():
   while con.isOpen():
       yield con.read()

您可以在代码中使用它,如下所示:

 
for line in getNextLines():
    doSomeThing(line)

执行控制转移问题

执行yield时,执行控制将从getNextLines()传送到for循环。因此,每次调用getNextLines()时,执行都会从上次暂停时开始执行。

因此简而言之,具有以下代码的函数

 
def simpleYield():
    yield "first time"
    yield "second time"
    yield "third time"
    yield "Now some useful value {}".format(12)

for i in simpleYield():
    print i

将打印

 
"first time"
"second time"
"third time"
"Now some useful value 12"
    
50
2018-05-20 10:42:59Z

收益是一个对象

函数中的return将返回单个值。

如果您希望函数返回大量值,请使用yield

更重要的是,yield障碍

  像CUDA语言中的障碍一样,它不会转移控制直到它获得   完成。

也就是说,它将从头开始运行您的函数中的代码,直到它达到yield。然后,它将返回循环的第一个值。

然后,每隔一次调用将再次运行你在函数中写入的循环,返回下一个值,直到没有任何值返回。

    
44
2018-05-20 10:45:50Z

(我的下面的答案仅从使用Python生成器的角度讲,而不是生成器机制的底层实现,它涉及堆栈和堆操作的一些技巧。)

当在python函数中使用yield而不是return时,该函数变成了一个特殊的叫做generator function的东西。该函数将返回generator类型的对象。 yield关键字是一个标志,用于通知python编译器处理such特殊功能。正常功能将在从其返回某个值后终止。但是在编译器的帮助下,生成器函数可以被认为是可恢复的。也就是说,将恢复执行上下文,并且执行将从上次运行继续。直到你显式调用return,这将引发StopIteration异常(也是迭代器协议的一部分),或者到达函数的末尾。我找到了很多关于generator的参考资料,但functional programming perspective一个是最可消化的。

(现在我想谈谈generator背后的基本原理,以及iterator基于我自己的理解。我希望这可以帮助你掌握迭代器的 基本动机 这种概念也出现在其他语言中,例如C#。)

据我所知,当我们想要处理大量数据时,我们通常先将数据存储在某处,然后逐个处理。但这种天真的方法存在问题。如果数据量很大,那么事先将它们作为一个整体存储起来是很昂贵的。 因此,不要直接存储data本身,为什么不间接存储某种metadata,即the logic how the data is computed

有两种方法可以包装这些元数据。

  1. OO方法,我们包装元数据as a class。这就是所谓的iterator,它实现了迭代器协议(即__next__()__iter__()方法)。这也是常见的迭代器设计模式
  2. 功能方法,我们包装元数据as a function。这是 所谓的generator function。但在引擎盖下,返回的generator object仍然是IS-A迭代器,因为它还实现了迭代器协议。
  3. 醇>

    无论哪种方式,都会创建一个迭代器,即一些可以为您提供所需数据的对象。 OO方法可能有点复杂。无论如何,使用哪一个取决于你。

        
44
2018-11-23 01:38:59Z

总之,yield语句将您的函数转换为一个工厂,该工厂生成一个名为generator的特殊对象,它包裹着原始函数的主体。当generator被迭代时,它会执行你的函数,直到它到达下一个yield,然后暂停执行并计算传递给yield的值。它在每次迭代时重复此过程,直到执行路径退出函数。例如,

 
def simple_generator():
    yield 'one'
    yield 'two'
    yield 'three'

for i in simple_generator():
    print i

简单输出

 
one
two
three

电源来自使用具有计算序列的循环的发电机,发电机每次执行循环停止以“产生”下一个计算结果,这样它就可以实时计算列表,效益为特别大的计算保存的内存

假设你想创建一个自己的range函数,它可以生成一个可迭代的数字范围,你可以这样做,

 
def myRangeNaive(i):
    n = 0
    range = []
    while n < i:
        range.append(n)
        n = n + 1
    return range

并像这样使用它;

 
for i in myRangeNaive(10):
    print i

但这是低效的,因为

  • 您创建一个只使用一次的数组(这会浪费内存)
  • 此代码实际上循环遍历该数组两次! :(

幸运的是,Guido和他的团队非常慷慨地开发发电机,所以我们可以做到这一点;

 
def myRangeSmart(i):
    n = 0
    while n < i:
       yield n
       n = n + 1
    return

for i in myRangeSmart(10):
    print i

现在每次迭代时,一个名为next()的生成器上的函数执行该函数,直到它达到'yield'语句,在该语句中它停止并“产生”该值或到达函数的末尾。在这种情况下,在第一次调用时,next()执行yield语句并生成'n',在下一次调用时它将执行increment语句,跳回'while',计算它,如果为true,它将停止并且再次产生'n',它将继续这样,直到while条件返回false并且生成器跳转到函数的末尾。

    
43
2018-05-20 11:04:36Z

许多人使用return而不是yield,但在某些情况下,yield可以更高效,更容易使用。

这是一个yield最适合的例子:

  

返回(在功能中)

 
import random

def return_dates():
    dates = [] # With 'return' you need to create a list then return it
    for i in range(5):
        date = random.choice(["1st", "2nd", "3rd", "4th", "5th", "6th", "7th", "8th", "9th", "10th"])
        dates.append(date)
    return dates
  

一愕ld (在功能上)

 
def yield_dates():
    for i in range(5):
        date = random.choice(["1st", "2nd", "3rd", "4th", "5th", "6th", "7th", "8th", "9th", "10th"])
        yield date # 'yield' makes a generator automatically which works
                   # in a similar way. This is much more efficient.
  

调用函数

 
dates_list = return_dates()
print(dates_list)
for i in dates_list:
    print(i)

dates_generator = yield_dates()
print(dates_generator)
for i in dates_generator:
    print(i)

两个函数都做同样的事情,但yield使用三行而不是五行,并且担心变量少一个。

  
    

这是代码的结果:

  

正如你所看到的,两个函数都做同样的事情。唯一的区别是return_dates()给出了一个列表,yield_dates()给出了一个生成器。

一个现实生活中的例子就像是逐行读取文件或者你只想制作一个生成器。

    
41
2018-05-20 11:02:52Z

yield就像一个函数的返回元素。不同之处在于yield元素将函数转换为生成器。在某些东西“屈服”之前,生成器的行为就像一个函数。发电机停止,直到下一次调用,并从它开始的完全相同的点继续。您可以通过拨打list(generator())获得所有“已产生”值的序列。

    
36
2015-05-20 06:19:32Z

yield关键字只收集返回的结果。想象yield就像return +=

    
35
2016-04-23 03:16:19Z

这是一个简单的基于yield的方法,用于计算斐波那契系列,解释如下:

 
def fib(limit=50):
    a, b = 0, 1
    for i in range(limit):
       yield b
       a, b = b, a+b

当你在REPL中输入它然后尝试调用它时,你会得到一个神秘的结果:

 
>>> fib()
<generator object fib at 0x7fa38394e3b8>

这是因为存在yield信号通知Python要创建生成器,即根据需要生成值的对象。

那么,你如何生成这些值?这可以通过使用内置函数next直接完成,也可以通过将其馈送到消耗值的构造来间接完成。

使用内置的next()功能,直接调用.next/__next__,强制生成器产生一个值:

 
>>> g = fib()
>>> next(g)
1
>>> next(g)
1
>>> next(g)
2
>>> next(g)
3
>>> next(g)
5

间接地,如果您向fib循环,for初始化程序,list初始化程序或其他任何需要生成/生成值的对象提供tuple,您将“消耗”生成器,直到不再生成值为止由它(并返回):

 
results = []
for i in fib(30):       # consumes fib
    results.append(i) 
# can also be accomplished with
results = list(fib(30)) # consumes fib

同样,使用tuple初始值设定项:

 
>>> tuple(fib(5))       # consumes fib
(1, 1, 2, 3, 5)

生成器与函数的不同之处在于它是惰性的。它通过维护本地状态并允许您随时恢复来实现此目的。

当你第一次通过调用它来调用fib时:

 
f = fib()

Python编译函数,遇到yield关键字并简单地返回一个生成器对象。看起来不是很有帮助。

当你请求它直接或间接生成第一个值时,它会执行它找到的所有语句,直到它遇到yield,然后它会将你提供的值返回到yield并暂停。有关更好地演示此示例的示例,让我们使用一些print调用(如果在Python 2上则替换为print "text"):

 
def yielder(value):
    """ This is an infinite generator. Only use next on it """ 
    while 1:
        print("I'm going to generate the value for you")
        print("Then I'll pause for a while")
        yield value
        print("Let's go through it again.")

现在,输入REPL:

 
>>> gen = yielder("Hello, yield!")

现在有一个生成器对象正在等待命令让它生成一个值。使用next并查看打印内容:

 
>>> next(gen) # runs until it finds a yield
I'm going to generate the value for you
Then I'll pause for a while
'Hello, yield!'

未加引号的结果是印刷的。引用的结果是从yield返回的结果。现在再次致电next

 
>>> next(gen) # continues from yield and runs again
Let's go through it again.
I'm going to generate the value for you
Then I'll pause for a while
'Hello, yield!'

发电机记得它在yield value暂停并从那里恢复。打印下一条消息,再次执行搜索yield语句暂停(由于while循环)。

    
32
2017-07-12 12:44:24Z

一个容易理解的例子它是什么:yield

 
def f123():
    for _ in range(4):
        yield 1
        yield 2


for i in f123():
    print i

输出结果为:

 
1 2 1 2 1 2 1 2
    
32
2019-06-06 12:08:26Z
来源放置 这里