你可以使用生成器的一个实际例子是，如果你有某种形状，你想要遍历它的角、边或其他地方。对于我自己的项目(源代码在这里)，我有一个矩形:

class Rect():

    def __init__(self, x, y, width, height):
        self.l_top  = (x, y)
        self.r_top  = (x+width, y)
        self.r_bot  = (x+width, y+height)
        self.l_bot  = (x, y+height)

    def __iter__(self):
        yield self.l_top
        yield self.r_top
        yield self.r_bot
        yield self.l_bot

现在我可以创建一个矩形，并在它的角上循环:

myrect=Rect(50, 50, 100, 100)
for corner in myrect:
    print(corner)

除了__iter__，你可以有一个方法iter_corners，并在myrect.iter_corners()中使用for corner来调用它。使用__iter__更优雅，因为我们可以在for表达式中直接使用类实例名。

简单的解释是: 考虑for语句

for item in iterable:
   do_stuff()

很多时候，iterable中的所有项都不需要从一开始就存在，但可以在需要时动态生成。这在两种情况下都更有效

空间(您永远不需要同时存储所有项目)和 时间(迭代可能在需要所有项目之前完成)。

其他时候，你甚至不知道所有的项目提前。例如:

for command in user_input():
   do_stuff_with(command)

你没有办法预先知道所有用户的命令，但如果你有一个生成器给你命令，你可以使用这样一个很好的循环:

def user_input():
    while True:
        wait_for_command()
        cmd = get_command()
        yield cmd

使用生成器，您还可以对无限序列进行迭代，这在迭代容器时当然是不可能的。

我发现这个解释消除了我的疑虑。因为有一种可能，不知道发电机的人也不知道产量

返回

return语句是销毁所有局部变量并将结果值返回(返回)给调用者的语句。如果同一函数稍后被调用，该函数将获得一组新的变量。

收益率

但是，如果退出函数时局部变量没有被丢弃呢?这意味着我们可以从中断的地方恢复函数。这是引入生成器概念的地方，yield语句从函数停止的地方恢复。

  def generate_integers(N):
    for i in xrange(N):
    yield i

    In [1]: gen = generate_integers(3)
    In [2]: gen
    <generator object at 0x8117f90>
    In [3]: gen.next()
    0
    In [4]: gen.next()
    1
    In [5]: gen.next()

这就是Python中return语句和yield语句的区别。

Yield语句使函数成为生成器函数。

因此生成器是创建迭代器的简单而强大的工具。它们像常规函数一样编写，但它们在想要返回数据时使用yield语句。每次调用next()时，生成器都会从停止的地方恢复(它会记住所有数据值以及最后执行的语句)。

由于没有提到生成器的send方法，这里有一个例子:

def test():
    for i in xrange(5):
        val = yield
        print(val)

t = test()

# Proceed to 'yield' statement
next(t)

# Send value to yield
t.send(1)
t.send('2')
t.send([3])

它展示了向运行中的生成器发送值的可能性。下面视频中关于生成器的更高级课程(包括解释的yield，并行处理的生成器，逃避递归限制等)

David Beazley在PyCon 2014上谈发电机

我发现生成器非常有助于清理代码，并为您提供了一种非常独特的方式来封装和模块化代码。如果您需要某些东西根据自己的内部处理不断地输出值，并且需要从代码中的任何地方调用该东西(而不仅仅是在循环或块中)，则可以使用生成器。

一个抽象的例子是斐波那契数生成器，它不在循环中，当从任何地方调用它时，它总是返回序列中的下一个数字:

def fib():
    first = 0
    second = 1
    yield first
    yield second

    while 1:
        next = first + second
        yield next
        first = second
        second = next

fibgen1 = fib()
fibgen2 = fib()

现在你有了两个斐波那契数生成器对象，你可以在代码中的任何地方调用它们，它们总是会按如下顺序返回更大的斐波那契数:

>>> fibgen1.next(); fibgen1.next(); fibgen1.next(); fibgen1.next()
0
1
1
2
>>> fibgen2.next(); fibgen2.next()
0
1
>>> fibgen1.next(); fibgen1.next()
3
5

生成器的可爱之处在于，它们封装了状态，而不必经历创建对象的繁琐过程。考虑它们的一种方法是将它们视为记住其内部状态的“函数”。

我从Python生成器中得到了斐波那契函数的例子——它们是什么?只要有一点想象力，您就可以想出很多其他情况，在这些情况下，生成器可以很好地替代for循环和其他传统迭代结构。

生成器提供惰性求值。你可以通过对它们进行迭代来使用它们，或者显式地使用'for'，或者隐式地将它传递给任何迭代的函数或构造。您可以将生成器视为返回多个项，就像它们返回一个列表一样，但它们不是一次返回所有项，而是一个接一个地返回它们，并且生成器函数将暂停，直到请求下一个项。

生成器很适合计算大量结果集(特别是涉及循环本身的计算)，因为您不知道是否需要所有结果，或者您不想同时为所有结果分配内存。或者在发电机使用另一个发电机，或者消耗其他资源的情况下，如果发生得越晚越方便。

Another use for generators (that is really the same) is to replace callbacks with iteration. In some situations you want a function to do a lot of work and occasionally report back to the caller. Traditionally you'd use a callback function for this. You pass this callback to the work-function and it would periodically call this callback. The generator approach is that the work-function (now a generator) knows nothing about the callback, and merely yields whenever it wants to report something. The caller, instead of writing a separate callback and passing that to the work-function, does all the reporting work in a little 'for' loop around the generator.

For example, say you wrote a 'filesystem search' program. You could perform the search in its entirety, collect the results and then display them one at a time. All of the results would have to be collected before you showed the first, and all of the results would be in memory at the same time. Or you could display the results while you find them, which would be more memory efficient and much friendlier towards the user. The latter could be done by passing the result-printing function to the filesystem-search function, or it could be done by just making the search function a generator and iterating over the result.

如果您想查看后两种方法的示例，请参阅os.path.walk()(带有回调的旧文件系统遍历函数)和os.walk()(新的文件系统遍历生成器)。当然，如果你真的想收集一个列表中的所有结果，生成器方法转换为大列表方法是微不足道的:

big_list = list(the_generator)