迭代器是使用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

这篇文章涵盖了两者之间的许多细节差异，但想在两者之间的概念差异上添加一些东西:

[…GoF书中定义的迭代器从集合中检索项，而生成器可以“凭空”生成项。这就是为什么斐波那契序列生成器是一个常见的例子:无限级数的数字不能存储在一个集合中。

Ramalho,卢西亚诺。流利的Python(第415页)。O ' reilly媒体。Kindle版。

当然，它并没有涵盖所有的方面，但我认为它给出了一个很好的概念，当一个人是有用的。

可迭代对象是可以(自然地)迭代的对象。然而，要做到这一点，你将需要一个类似迭代器对象的东西，是的，术语可能令人困惑。可迭代对象包括__iter__方法，该方法将返回可迭代对象的迭代器对象。

迭代器对象是一个实现迭代器协议的对象——一组规则。在这种情况下，它必须至少有这两个方法:__iter__和__next__。__next__方法是一个提供新值的函数。__iter__方法返回迭代器对象。在更复杂的对象中，可能有单独的迭代器，但在更简单的情况下，__iter__返回对象本身(通常返回self)。

一个iterable对象是一个列表对象。它不是一个迭代器，但它有一个__iter__方法，返回一个迭代器。你可以直接以things.__iter__()的形式调用这个方法，或者使用iter(things)。

如果你想遍历任何集合，你需要使用它的迭代器:

things_iterator = iter(things)
for i in things_iterator:
    print(i)

然而，Python会自动使用迭代器，这就是为什么你从来没有看到上面的例子。相反，你可以这样写:

for i in things:
    print(i)

自己编写迭代器可能很乏味，所以Python有一个更简单的选择:生成器函数。生成器函数不是普通的函数。不是遍历代码并返回最终结果，而是延迟代码，函数立即返回一个生成器对象。

生成器对象类似于迭代器对象，因为它实现了迭代器协议。这对于大多数目的来说已经足够好了。在其他答案中有许多生成器的例子。

简而言之，迭代器是一个对象，它允许您迭代另一个对象，无论它是一个集合还是其他一些值的来源。生成器是一个简化的迭代器，它或多或少完成相同的工作，但更容易实现。

通常情况下，如果你只需要发电机，你会选择发电机。但是，如果您正在构建一个更复杂的对象，其中包含其他特性之间的迭代，则应该使用迭代器协议。

我用一种非常简单的方式专门为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)

每个人都有一个非常漂亮和冗长的答案，我真的很感激。我只是想给那些在概念上还不太清楚的人一个简短的回答:

If you create your own iterator, it is a little bit involved - you have to create a class and at least implement the iter and the next methods. But what if you don't want to go through this hassle and want to quickly create an iterator. Fortunately, Python provides a short-cut way to defining an iterator. All you need to do is define a function with at least 1 call to yield and now when you call that function it will return "something" which will act like an iterator (you can call next method and use it in a for loop). This something has a name in Python called Generator

希望这能澄清一点。

无代码4行小抄:

A generator function is a function with yield in it.

A generator expression is like a list comprehension. It uses "()" vs "[]"

A generator object (often called 'a generator') is returned by both above.

A generator is also a subtype of iterator.