一堆东西。任何时候你想要生成一个项目序列，但又不想一次将它们全部“物化”到一个列表中。例如，你可以有一个简单的生成器，返回质数:

def primes():
    primes_found = set()
    primes_found.add(2)
    yield 2
    for i in itertools.count(1):
        candidate = i * 2 + 1
        if not all(candidate % prime for prime in primes_found):
            primes_found.add(candidate)
            yield candidate

然后你可以用它来生成后续质数的乘积:

def prime_products():
    primeiter = primes()
    prev = primeiter.next()
    for prime in primeiter:
        yield prime * prev
        prev = prime

这些都是相当简单的示例，但是您可以看到它对于处理大型(可能是无限的!)数据集是多么有用，而无需预先生成数据集，这只是比较明显的用途之一。

简单的解释是: 考虑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

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

使用生成器的原因之一是为了使某些解决方案的解决方案更清晰。

另一种方法是一次处理一个结果，避免建立庞大的结果列表，否则无论如何都要分开处理。

如果你有这样一个fibonacci- to-n函数:

# function version
def fibon(n):
    a = b = 1
    result = []
    for i in xrange(n):
        result.append(a)
        a, b = b, a + b
    return result

你可以更容易地写出这样的函数:

# generator version
def fibon(n):
    a = b = 1
    for i in xrange(n):
        yield a
        a, b = b, a + b

函数更清晰。如果你这样使用这个函数:

for x in fibon(1000000):
    print x,

在本例中，如果使用生成器版本，则根本不会创建整个1000000项列表，每次只创建一个值。在使用列表版本时，情况并非如此，在列表版本中，将首先创建列表。

也适用于打印到n的质数:

def genprime(n=10):
    for num in range(3, n+1):
        for factor in range(2, num):
            if num%factor == 0:
                break
        else:
            yield(num)

for prime_num in genprime(100):
    print(prime_num)

生成器提供惰性求值。你可以通过对它们进行迭代来使用它们，或者显式地使用'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)

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

返回

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()时，生成器都会从停止的地方恢复(它会记住所有数据值以及最后执行的语句)。