以下是基于收益率的简单方法, 用来计算Fibonacci系列, 解释如下:

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>

这是因为向 Python 发出的产出信号 表明您想要创建一个生成器, 即一个根据需求产生价值的物体。

那么,你如何生成这些值?这要么直接通过下一个使用内置函数来实现,要么间接地通过将内置函数输入一个消耗值的构造来实现。

使用下个() 内置函数, 您可以直接引用. extext/ __ extext_ , 迫使生成器产生值 :

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

间接地,如果您为循环提供纤维、列表初始化器、图普特初始化器或其他任何期望产生/产生值的对象,您将“组装”生成器,直到它不再产生(并返回):

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

类似地,图普特首发器:

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

生成器与功能不同, 因为它很懒。 它通过保持本地状态, 并允许您在需要的时候恢复运行来达到这个目的 。

当你喊叫它的时候,

f = fib()

Python 编译函数, 遇到产出关键字, 只需返回生成对象。 似乎没有什么帮助 。

当您要求它生成第一个值时, 它会直接或间接地执行它发现的所有语句, 直到它遇到一个产量, 然后它会返回您提供的产量和暂停值。 对于一个更能证明这一点的例子, 让我们使用一些打印电话( 如果在 Python 2 上用打印“ text ” 代替 打印“ 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(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!'

未引用的结果是打印的内容。 引用的结果是从产出中返回的内容。 现在再次调用 :

>>> 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!'

生成器记得它被按产出值暂停, 然后从那里恢复。 下一则消息被打印, 并搜索收益声明以在它上再次暂停( 原因是同时循环 ) 。

和每个答案一样, 收益被用于创建序列生成器。 它用于动态生成某些序列。 例如, 在按行阅读网络文件行时, 您可以使用以下的收益函数 :

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

您可在您的代码中使用以下代码:

for line in getNextLines():
    doSomeThing(line)

执行控制控制

执行控制将会从 GetNextLines () 转到执行时的循环。 因此, 每次引用 NextLines () 时, 执行都会从上次暂停处开始 。

因此,简言之,一个函数具有以下代码

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"

Python 的输出关键字是做什么的 ?

答复大纲/摘要

函数, 调用时, 返回生成器。 发电机是循环器, 因为它们执行循环程序, 以便您可以对它进行循环。 也可以发送一个发电机信息, 使其在概念上成为共同的常规。 在 Python 3 中, 您可以将一个发电机从一个发电机到另一个发电机, 从两个方向调用。 (附录: 包括顶部的答案在内的几个答案, 并讨论在发电机中使用返回的方法 。)

发电机:

收益率只是功能定义中的法律内涵,而将收益率列入功能定义使其返回产生者。

发电机的想法来自其他语言(见脚注1),其实施方式各有不同。 在Python的发电机中,代码的执行在生产点被冻结。当发电机被调用(方法在下文讨论)时,再恢复执行,然后冻结在下一个生产点。

输出提供了执行循环协议的简单方法,由以下两种方法定义:__iter__和__ext_。这两种方法都使对象成为可与收藏模块的Exerator摘要基础类进行打印的复制器。

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__
True                           # implements the iterator protocol.

生成器类型是一个子迭代器类型 :

from types import GeneratorType
from collections.abc import Iterator

>>> issubclass(GeneratorType, Iterator)
True

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

>>> isinstance(gen, GeneratorType)
True
>>> isinstance(gen, Iterator)
True

迭代器的一个特征是,一旦耗竭,您无法再利用或重置它:

>>> 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, 您可以使用以下来源的产量:

def func(an_iterable):
    yield from an_iterable

但是,也允许向次级发电机授权,这一点将在下一节 " 与次级水泥合作授权 " 中加以解释。

计票:

窗体中显示一个表达式,该表达式允许将数据发送到生成器(见脚注3)

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

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)

首先, 我们必须排队, 下一个是内建函数 。 它会调用合适的下一个或 下一步方法, 取决于您使用的 Python 版本 :

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

现在我们可以将数据发送到生成器。 (“终结者”和“下一个”是一样的 ) :

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

合作社代表团到分科诊所分科

现在,请记住,Python 3的产量是可以得到的。 这使得我们可以将共同路线 委托给一个子烹饪:

def money_manager(expected_rate):
    # must receive deposited value from .send():
    under_management = yield                   # yield None to start.
    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'''
            raise
        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'''
    # must queue up manager:
    next(manager)      # <- same as manager.send(None)
    # This is where we send the initial deposit to the manager:
    manager.send(deposited)
    try:
        yield from manager
    except GeneratorExit:
        return manager.close()  # delegate?

现在我们可以将功能委托给一个子生成器 并且它可以被一个发电机使用 就像上面那样:

my_manager = money_manager(.06)
my_account = investment_account(1000, my_manager)
first_year_return = next(my_account) # -> 60.0

现在模拟在账户中再增加1000, 加上账户的回报( 60.0 ) :

next_year_return = my_account.send(first_year_return + 1000)
next_year_return # 123.6

从PEP 380中,您可以阅读更多关于产量的确切语义。

其他方法:关闭和投掷

关闭方法在功能执行被冻结时提升发电机输出。 也可以被 __ del__ 调用, 这样您就可以设置任何清理代码, 用于处理发电机输出 :

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 6, in money_manager
  File "<stdin>", line 2, in <module>
ValueError

结论 结论 结论 结论 结论

我认为,我已处理了下列问题的所有方面:

Python 的输出关键字是做什么的 ?

事实证明,产量是很大的。我相信我可以为此再增加更详尽的例子。如果你需要更多的或有建设性的批评,请在下面评论,让我知道。

---

附录:

顶级/接受的答复的优先程度**

使用列表作为示例。 参见我上面的引用, 但概括地说: 循环含有 ` irit_ 的方法返回一个迭代器。 一个迭代器另外提供了一种 . next_ 的方法, 以循环为暗号, 以循环为代号, 直到它升起 停止 试运行, 一旦它确实升起 停止 试运行, 它会继续这样做 。 然后它会使用一个发电机表达方式来描述一个发电机。 由于一个发电机表达方式只是创建一个代用器的方便方式, 它只会混淆物质, 而我们还没有到达产值部分 。 在控制发电机耗竭时, 他调用 . next 方法( 只在 Python 2 中有效 ) , 而不是使用 内建函数, 下一步。 调用下一个 (obj) 将是一个适当的间接层, 因为他的代码在 Python 3. Itertools 中不起作用 。 这与结果完全无关 。 没有讨论 与 Python 3 中产生新功能收益的方法提供的方法和 Python 。

上方/接受的回答是一个非常不完整的回答。

回答的精度表示在发电机的表达或理解中产生产量。

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

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时,布雷特坎农写道:在太阳上,2017年1月29日,16:39克雷格·罗德里格斯写道:我同意这两种方法。把事情保留在Python 3的状态是不对的,IMHO。我的投票是语法错误,因为你没有得到你期望的语法。我同意这对我们来说是一个明智的结局,因为任何依赖当前行为的代码都非常聪明,无法维持。在到达那里时,我们可能想要:在2.7的Py3k警告中,用3.7的Py3k警告来表示警告或破坏警告。x语法错误,Nick。 -- Nick Coghlan ncoghlan at gmail.com {Brisbane,澳大利亚,Gmail. com {Brisbane。

此外,还有一个未决问题(10544)似乎指向从来就不是一个好主意(PyPy, PyPy, 写在Python的Python执行文件,

底线,直到CPython的开发者告诉我们别的情况: 不要在生成器表达或理解中放出产量。

发电机中的回程声明

在Python 3 中:

在发电机函数中, 返回语句表示发电机已完成, 并将导致 StopLiveration 上升。 返回的值( 如果有的话) 用作构建 StopLiveration 的参数, 并成为 StopIturation. value 属性 。

Python 2 中的历史注释 : “ 在生成器函数中, 返回语句不允许包含表达式_ 列表 。 在此情况下, 光返回表示生成器已经完成, 并将导致停止使用 。 ” 表达式列表基本上是用逗号分隔的任何多个表达式 - 基本上在 Python 2 中, 您可以返回停止生成器, 但无法返回一个值 。

脚注脚注

将生成器的概念引入 Python 的建议中引用了语言 CLU、 Sather 和 图标 。 一般的想法是, 函数可以维持内部状态, 并产生用户需要的中间数据点 。 这承诺在性能上优于其他方法, 包括Python 线性线性, 某些系统中甚至没有这种系统。 这意味着, 范围天体虽然是可循环的, 但却不是迭代器, 因为它们是可以再利用的 。 和列表一样, 它们的 ` eter_ 方法返回替换器对象 。 收益最初是作为声明引入的, 意思是它只能在代码块的线性起始处出现 。 现在, 收益产生一种收益表达方式 。 https://docs. python.org/2/reference/spoint_stmts.html# grammar- token- yeld_stmt 。 提出这一修改是为了让用户将数据发送到生成器中。 。 要发送数据, 发送数据时, 就必须将它指定它为某种东西, 。

还有一件事情要提: 产量的函数其实不一定要终止。我写了这样的代码:

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);

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

就像有人要你做5个纸杯蛋糕一样。如果你做了至少一个纸杯蛋糕,你可以在做其他蛋糕时给他们吃。

In [4]: def make_cake(numbers):
   ...:     for i in range(numbers):
   ...:         yield 'Cake {}'.format(i)
   ...:

In [5]: factory = make_cake(5)

这里称为发电机, 它会做蛋糕。 如果您叫作 Make_ 函数, 您可以得到一个发电机, 而不是运行此函数。 这是因为当输出关键字出现在一个函数中时, 它会变成一个生成器 。

In [7]: next(factory)
Out[7]: 'Cake 0'

In [8]: next(factory)
Out[8]: 'Cake 1'

In [9]: next(factory)
Out[9]: 'Cake 2'

In [10]: next(factory)
Out[10]: 'Cake 3'

In [11]: next(factory)
Out[11]: 'Cake 4'

他们消耗了所有的蛋糕, 但他们又要求一个。

In [12]: next(factory)
---------------------------------------------------------------------------
StopIteration                             Traceback (most recent call last)
<ipython-input-12-0f5c45da9774> in <module>
----> 1 next(factory)

StopIteration:

并且他们被告知不要问更多的问题。 所以一旦你消耗了发电机, 你就会用它做。 如果你想要更多的蛋糕,你需要再打电话做蛋糕。 这就像再订一份蛋糕。

In [13]: factory = make_cake(3)

In [14]: for cake in factory:
    ...:     print(cake)
    ...:
Cake 0
Cake 1
Cake 2

您也可以使用上面的生成器来循环。

举个例子:假设你每次问密码时都想要随机密码。

In [22]: import random

In [23]: import string

In [24]: def random_password_generator():
    ...:     while True:
    ...:         yield ''.join([random.choice(string.ascii_letters) for _ in range(8)])
    ...:

In [25]: rpg = random_password_generator()

In [26]: for i in range(3):
    ...:     print(next(rpg))
    ...:
FXpUBhhH
DdUDHoHn
dvtebEqG

In [27]: next(rpg)
Out[27]: 'mJbYRMNo'

这里的 rpg 是一个生成器, 它可以生成无限数量的随机密码。 所以我们也可以说, 当我们不知道序列的长度时, 生成器是有用的, 不同于列表, 列表中有一定数量的元素 。

从方案拟订的角度来看,迭代器是作为散装件执行的。

为实施同时执行的迭代器、发电机和线形集合等,人们使用发往有调度员的关闭对象的电文,用发件人对“信息”的回答。

"下一步"是给一个封口发送的信息 由"标准"电话创建

有多种方法可以实施此计算。 我使用了突变, 但可以通过返回当前值和下一个生成者( 使其具有优先透明度 ) , 进行这种不发生突变的计算。 鼠标使用一些中间语言对初始程序进行一系列转换, 其中之一是将产出操作者转换为使用更简单的操作员的某种语言。

这是如何重写产量的演示, 它使用 R6RS 的结构, 但语义与 Python 的相同 。 这是相同的计算模式, 只需要修改语法, 才能使用 Python 的 产量重写 。

- (define gen (lambda (l) (define gen (lambda (l)) (define emple (lambda (lambda () ()) (if (null? l)) 'END (let ((v (car l))(set))(l (cdr))) (lambda (m) (cket m) (case m ('yield (yeld)(yeld))('ield))('iint (lamb) (lambda (lab) (lambda (data) (data) (l data))) ())) ) - (define 流 (gen 'ield (gen'(1,2 3 ) )) - (流 (流 ield) ) ) - (Live END - (Slead) (流 (流 ) (流 ) (流 (流 流 (流 流 流 流 流 流 ) 'ield) 'end - >