添加一个答案，因为现有的答案都没有专门解决官方文献中的困惑。

生成器函数是用yield而不是return定义的普通函数。当被调用时，生成器函数返回一个生成器对象，这是一种迭代器——它有一个next()方法。当调用next()时，将返回生成器函数产生的下一个值。

函数或对象都可以被称为“生成器”，这取决于你阅读的Python源文档。Python术语表表示生成器函数，而Python wiki表示生成器对象。Python教程成功地在三句话中暗示了这两种用法:

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

前两句话用生成器函数标识生成器，而第三句话用生成器对象标识它们。

尽管存在这些困惑，但人们可以从Python语言参考中找到明确的最终答案:

yield表达式仅在定义生成器函数时使用，并且只能在函数定义的主体中使用。在函数定义中使用yield表达式足以导致该定义创建一个生成器函数，而不是普通函数。 当调用generator函数时，它返回一个称为generator的迭代器。然后，该生成器控制生成器函数的执行。

因此，在正式和精确的用法中，“generator”不合格指的是生成器对象，而不是生成器功能。

上面的参考资料是针对Python 2的，但Python 3语言参考资料也说了同样的事情。然而，Python 3术语表指出

发电机……通常指生成器函数，但在某些上下文中也可能指生成器迭代器。在意图不明确的情况下，使用完整的术语可以避免歧义。

对于相同的数据，你可以比较两种方法:

def myGeneratorList(n):
    for i in range(n):
        yield i

def myIterableList(n):
    ll = n*[None]
    for i in range(n):
        ll[i] = i
    return ll

# Same values
ll1 = myGeneratorList(10)
ll2 = myIterableList(10)
for i1, i2 in zip(ll1, ll2):
    print("{} {}".format(i1, i2))

# Generator can only be read once
ll1 = myGeneratorList(10)
ll2 = myIterableList(10)

print("{} {}".format(len(list(ll1)), len(ll2)))
print("{} {}".format(len(list(ll1)), len(ll2)))

# Generator can be read several times if converted into iterable
ll1 = list(myGeneratorList(10))
ll2 = myIterableList(10)

print("{} {}".format(len(list(ll1)), len(ll2)))
print("{} {}".format(len(list(ll1)), len(ll2)))

此外，如果检查内存占用，生成器占用的内存要少得多，因为它不需要同时将所有值存储在内存中。

迭代器是使用next()方法获取序列的以下值的对象。

生成器是使用yield关键字生成或生成值序列的函数。

由生成器函数(下面的ex: foo())返回的生成器对象(下面的ex: f)上的每个next()方法调用，都会生成序列中的下一个值。

当调用生成器函数时，它返回一个生成器对象，甚至不需要开始执行该函数。当第一次调用next()方法时，函数开始执行，直到到达yield语句，该语句返回yield值。收益率会跟踪发生了什么，也就是说，它会记住最后一次执行。其次，next()调用从前一个值开始。

下面的示例演示生成器对象上yield和对next方法的调用之间的相互作用。

>>> def foo():
...     print("begin")
...     for i in range(3):
...         print("before yield", i)
...         yield i
...         print("after yield", i)
...     print("end")
...
>>> f = foo()
>>> next(f)
begin
before yield 0            # Control is in for loop
0
>>> next(f)
after yield 0             
before yield 1            # Continue for loop
1
>>> next(f)
after yield 1
before yield 2
2
>>> next(f)
after yield 2
end
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

iterator是一个更通用的概念:任何具有__next__方法(Python 2中的next)和__iter__方法且返回self的对象。

每个生成器都是迭代器，反之亦然。生成器是通过调用具有一个或多个yield表达式(yield语句，在Python 2.5及更早版本中)的函数来构建的，它是一个满足上一段对迭代器定义的对象。

当你需要一个具有复杂状态维护行为的类，或者想公开__next__(以及__iter__和__init__)之外的其他方法时，你可能想使用自定义迭代器，而不是生成器。大多数情况下，一个生成器(有时，对于足够简单的需求，一个生成器表达式)就足够了，而且编码更简单，因为状态维护(在合理的范围内)基本上是由框架挂起和恢复“为您完成”的。

例如，一个生成器，如:

def squares(start, stop):
    for i in range(start, stop):
        yield i * i

generator = squares(a, b)

或等效的生成器表达式(genexp)

generator = (i*i for i in range(a, b))

将需要更多的代码来构建自定义迭代器:

class Squares(object):
    def __init__(self, start, stop):
       self.start = start
       self.stop = stop
    def __iter__(self): return self
    def __next__(self): # next in Python 2
       if self.start >= self.stop:
           raise StopIteration
       current = self.start * self.start
       self.start += 1
       return current

iterator = Squares(a, b)

但是，当然，使用类Squares，你可以很容易地提供额外的方法。

def current(self):
    return self.start

如果您的应用程序中确实需要这些额外的功能。

之前的回答忽略了这一点:生成器有close方法，而典型的迭代器没有。close方法在生成器中触发StopIteration异常，该异常可能在迭代器中的finally子句中被捕获，以获得运行一些清理的机会。这种抽象使得它在大型迭代器中比简单迭代器更有用。可以像关闭文件一样关闭生成器，而不必担心下面有什么。

也就是说，我个人对第一个问题的回答是:iteratable只有__iter__方法，典型的迭代器只有__next__方法，生成器既有__iter__又有__next__，还有一个附加的close。

For the second question, my personal answer would be: in a public interface, I tend to favor generators a lot, since it’s more resilient: the close method an a greater composability with yield from. Locally, I may use iterators, but only if it’s a flat and simple structure (iterators does not compose easily) and if there are reasons to believe the sequence is rather short especially if it may be stopped before it reach the end. I tend to look at iterators as a low level primitive, except as literals.

对于控制流而言，生成器是一个与承诺同样重要的概念:两者都是抽象的和可组合的。

我用一种非常简单的方式专门为Python新手编写，尽管Python在本质上做了很多事情。

让我们从最基本的开始:

考虑一个列表，

l = [1,2,3]

让我们写一个等效函数:

def f():
    return [1,2,3]

打印(l)的O /p: [1,2,3] & O /p打印(f()): [1,2,3]

让列表l可迭代:在python中，列表总是可迭代的，这意味着你可以在任何你想要的时候应用迭代器。

让我们在list上应用迭代器:

iter_l = iter(l) # iterator applied explicitly

让我们把一个函数设为可迭代的，也就是说，写一个等效的生成器函数。 在python中，只要你引入关键字yield;它变成了一个生成器函数，迭代器将隐式应用。

注意:每个生成器在应用隐式迭代器时总是可迭代的，这里隐式迭代器是关键 因此生成器函数将是:

def f():
  yield 1 
  yield 2
  yield 3

iter_f = f() # which is iter(f) as iterator is already applied implicitly

如果你观察到，一旦你让函数f成为一个生成器，它就已经是iter(f)

Now,

L是列表，在应用迭代器方法iter后，它变成， iter(左) F已经是iter(F)，在应用迭代器方法“iter”它 变成iter(iter(f))也就是iter(f)

这有点像你将int类型转换为int(x)它已经是int类型并且它将保持int(x)

例如o/p:

print(type(iter(iter(l))))

is

<class 'list_iterator'>

别忘了这是Python而不是C或c++

因此，由上述解释得出的结论是:

列出l ~= iter(l) 生成函数f == iter(f)