问题描述：

迭代器和生成器之间有什么区别？ 提供一些关于何时使用每种情况的示例将会很有帮助。

解决方案 1：

iterator是一个更通用的概念：任何对象，其类都有一个__next__方法（next在 Python 2 中）和一个__iter__执行的方法return self。

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

当您需要一个具有稍微复杂的状态维护行为的类，或者想要公开除__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

如果您的应用程序确实需要此类额外功能。

解决方案 2：

迭代器和生成器之间有什么区别？ 提供一些关于何时使用每种情况的示例将会很有帮助。

总结：迭代器是具有__iter__和__next__（next在 Python 2 中）方法的对象。生成器提供了一种简单的内置方法来创建迭代器实例。

带有yield的函数仍然是一个函数，当调用它时，它会返回生成器对象的实例：

def a_function():
    "when called, returns generator object"
    yield

生成器表达式也返回一个生成器：

a_generator = (i for i in range(0))

如需更深入的阐述和示例，请继续阅读。

生成器是一个迭代器

在 Python 3.3 版本之前，来自的类collections.abc直接位于下collections，例如，collections.Iterator而不是collections.abc.Iterator。

具体来说，生成器是迭代器的子类型。

>>> import collections, types
>>> issubclass(types.GeneratorType, collections.abc.Iterator)
True

我们可以通过多种方式创建生成器。一种非常常见且简单的方法是使用函数。

具体来说，带有yield的函数是一个在调用时返回生成器的函数：

>>> def a_function():
        "just a function definition with yield in it"
        yield
>>> type(a_function)
<class 'function'>
>>> a_generator = a_function()  # when called
>>> type(a_generator)           # returns a generator
<class 'generator'>

再次强调，生成器是一个迭代器：

>>> isinstance(a_generator, collections.abc.Iterator)
True

迭代器是可迭代的

迭代器 (Iterator) 是一个可迭代对象，

>>> issubclass(collections.abc.Iterator, collections.abc.Iterable)
True

它需要一个__iter__返回 Iterator 的方法：

>>> collections.abc.Iterable()
Traceback (most recent call last):
  File "<pyshell#79>", line 1, in <module>
    collections.abc.Iterable()
TypeError: Can't instantiate abstract class Iterable with abstract methods __iter__

可迭代的一些示例是内置元组、列表、字典、集合、冻结集合、字符串、字节字符串、字节数组、范围和内存视图：

>>> all(isinstance(element, collections.abc.Iterable) for element in (
        (), [], {}, set(), frozenset(), '', b'', bytearray(), range(0), memoryview(b'')))
True

迭代器需要next或方法__next__

在 Python 2 中：

>>> collections.Iterator()
Traceback (most recent call last):
  File "<pyshell#80>", line 1, in <module>
    collections.Iterator()
TypeError: Can't instantiate abstract class Iterator with abstract methods next

在 Python 3 中：

>>> collections.abc.Iterator()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: Can't instantiate abstract class Iterator with abstract methods __next__

我们可以使用以下函数从内置对象（或自定义对象）中获取迭代器iter：

>>> all(isinstance(iter(element), collections.abc.Iterator) for element in (
        (), [], {}, set(), frozenset(), '', b'', bytearray(), range(0), memoryview(b'')))
True

__iter__当您尝试将对象与 for 循环一起使用时，将调用该方法。然后，__next__在迭代器对象上调用该方法，以使每个项目退出循环。StopIteration当您用尽迭代器时，迭代器将引发，此时无法重复使用它。

来自文档

从内置类型文档的迭代器类型部分的生成器类型部分：

Python 的生成器提供了一种实现迭代器协议的便捷方法。如果容器对象的__iter__()方法实现为生成器，它将自动返回一个迭代器对象（从技术上讲，是生成器对象），提供__iter__()和next()[__next__()在 Python 3 中] 方法。有关生成器的更多信息，请参阅yield 表达式的文档。

（重点已添加。）

由此我们了解到生成器是一种（方便的）迭代器类型。

迭代器对象示例

您可以通过创建或扩展自己的对象来创建实现 Iterator 协议的对象。

class Yes(collections.Iterator):

    def __init__(self, stop):
        self.x = 0
        self.stop = stop

    def __iter__(self):
        return self

    def next(self):
        if self.x < self.stop:
            self.x += 1
            return 'yes'
        else:
            # Iterators must raise when done, else considered broken
            raise StopIteration

    __next__ = next # Python 3 compatibility

但使用生成器来做到这一点更容易：

def yes(stop):
    for _ in range(stop):
        yield 'yes'

或者可能更简单，一个生成器表达式（工作原理类似于列表推导）：

yes_expr = ('yes' for _ in range(stop))

它们都可以以相同的方式使用：

>>> stop = 4             
>>> for i, y1, y2, y3 in zip(range(stop), Yes(stop), yes(stop), 
                             ('yes' for _ in range(stop))):
...     print('{0}: {1} == {2} == {3}'.format(i, y1, y2, y3))
...     
0: yes == yes == yes
1: yes == yes == yes
2: yes == yes == yes
3: yes == yes == yes

结论

当你需要将 Python 对象扩展为可迭代的对象时，可以直接使用 Iterator 协议。

然而，在绝大多数情况下，您最适合使用yield定义返回生成器迭代器的函数或考虑生成器表达式。

最后，请注意，生成器作为协程提供了更多功能。我在回答“yield 关键字有什么作用？”时深入解释了生成器以及该语句。yield

解决方案 3：

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

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

生成器函数返回的生成器对象（例如：下面）上的每个next()方法调用都会生成序列中的下一个值。f`foo()`

当调用生成器函数时，它会返回一个生成器对象，甚至无需开始执行该函数。当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

解决方案 4：

添加答案是因为现有的答案都没有专门解决官方文献中的混淆问题。

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

根据您阅读的 Python 源文档，函数或对象可能被称为“生成器”。Python词汇表中说的是生成器函数，而Python wiki则暗示是生成器对象。Python教程出色地在三句话的篇幅内暗示了这两种用法：

生成器是一种简单而强大的迭代器创建工具。它们的编写方式与常规函数类似，但需要返回数据时会使用yield语句。每次调用next()时，生成器都会从上次中断的地方继续执行（它会记住所有数据值以及上次执行的语句）。

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

尽管存在这些困惑，但人们可以在Python 语言参考中找到明确的结论：

仅在定义生成器函数时使用yield表达式，并且只能在函数定义主体中使用。在函数定义中使用yield表达式足以使该定义创建生成器函数而不是普通函数。

当调用生成器函数时，它会返回一个称为生成器的迭代器。然后该生成器控制生成器函数的执行。

因此，在正式和准确的用法中，“生成器”不合格是指生成器对象，而不是生成器函数。

上述参考资料适用于 Python 2，但Python 3 语言参考资料也说了同样的事情。然而，Python 3 词汇表指出

生成器...通常指生成器函数，但在某些情况下可能指生成器迭代器。在预期含义不清楚的情况下，使用完整术语可避免歧义。

解决方案 5：

每个人都给出了非常好的、详细的答案，并附上了例子，我真的很感激。我只是想给那些概念上还不太清楚的人提供几行简短的答案：

如果你创建自己的迭代器，那么会有点复杂——你必须创建一个类，至少实现 iter 和 next 方法。但是如果你不想经历这种麻烦，想快速创建一个迭代器，该怎么办呢？幸运的是，Python 提供了一种定义迭代器的快捷方式。你需要做的就是定义一个函数，至少调用一次yield，现在当你调用该函数时，它将返回“某物”，它将像迭代器一样工作（你可以调用 next 方法并在 for 循环中使用它）。这个东西在 Python 中有一个名字，叫做 Generator

希望这能解释清楚一点。

解决方案 6：

强烈推荐Ned Batchelder的示例 ，用于迭代器和生成器

一种无需生成器就能对偶数进行处理的方法

def evens(stream):
   them = []
   for n in stream:
      if n % 2 == 0:
         them.append(n)
   return them

通过使用发电机

def evens(stream):
    for n in stream:
        if n % 2 == 0:
            yield n

• 我们不需要任何清单或return声明

• 对于大型/无限长度的流来说很有效......它只是行走并产生价值

调用evens方法（生成器）与往常一样

num = [...]
for n in evens(num):
   do_smth(n)

• 发电机也用于打破双环路

迭代器

一本满页的书是一个可迭代对象，一个书签是一个
迭代器

并且此书签除了移动之外没有任何作用next

litr = iter([1,2,3])
next(litr) ## 1
next(litr) ## 2
next(litr) ## 3
next(litr) ## StopIteration  (Exception) as we got end of the iterator

要使用 Generator...我们需要一个函数

要使用 Iterator...我们需要next和iter

正如所说的：

Generator 函数返回一个迭代器对象

Iterator 的全部好处：

每次在内存中存储一​​个元素

解决方案 7：

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

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

对于第二个问题，我个人的回答是：在公共接口中，我倾向于使用生成器，因为它更具弹性：close方法具有更大的可组合性yield from。在本地，我可能会使用迭代器，但前提是它是一个扁平而简单的结构（迭代器不易组合），并且有理由相信序列相当短，特别是如果它可能在到达末尾之前停止。我倾向于将迭代器视为低级原语，除了文字之外。

对于控制流问题，生成器和承诺一样都是重要的概念：两者都是抽象的和可组合的。

解决方案 8：

无代码 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.

解决方案 9：

如果没有另外两个概念，就很难回答这个问题：iterable和iterator protocol。

1. iterator和之间有什么区别？从概念上讲，您可以借助相应的iterable进行迭代。在实践中，有几个区别可以帮助区分和：
   iterable`iteratoriteratoriterable`

   • 一个区别是，iterator有__next__方法，iterable没有方法。

   • 另一个区别是它们都包含__iter__方法。如果是，iterable它返回相应的迭代器。如果是，iterator它返回自身。这可以帮助iterator在iterable实践中区分。

>>> x = [1, 2, 3]
>>> dir(x) 
[... __iter__ ...]
>>> x_iter = iter(x)
>>> dir(x_iter)
[... __iter__ ... __next__ ...]
>>> type(x_iter)
list_iterator

1. iterables中有什么python？list，，等等。什么是？，，等等。我们可以使用上面的方法检查这一点。这有点令人困惑。如果我们只有一种类型，可能会更容易。和之间有什么区别吗string？这样做的原因之一 -具有许多附加功能 - 我们可以对其进行索引或检查它是否包含某个数字等。（请参阅此处的详细信息）。range`iteratorsenumeratezipreversedrangeziprange`

2. 我们如何iterator自己创建一个？理论上我们可以实现Iterator Protocol（参见此处）。我们需要编写__next__方法__iter__并引发StopIteration异常等（请参阅 Alex Martelli 的回答以获取示例和可能的动机，另请参阅此处）。但实际上我们使用生成器。它似乎是迄今为止iterators在中创建的主要方法python。

我可以给你举几个更有趣的例子，这些例子表明这些概念在实践中的使用有些令人困惑：

• 在keras我们有tf.keras.preprocessing.image.ImageDataGenerator；此类没有__next__和__iter__方法；所以它不是一个迭代器（或生成器）；

• 如果你调用它的flow_from_dataframe()方法，你会得到DataFrameIterator具有这些方法的方法；但它没有实现StopIteration（这在内置迭代器中并不常见python）；在文档中我们可能会读到“ADataFrameIterator产生的元组(x, y)”——再次混淆了术语的使用；

• 我们也有Sequence类keras，这是生成器功能的自定义实现（常规生成器不适合多线程），但它没有实现__next__，__iter__而是生成器的包装器（它使用yield语句）；

解决方案 10：

该线程详细介绍了两者之间的所有差异，但想补充一些关于两者之间概念差异的内容：

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

拉马略、卢西亚诺。流利的 Python（第 415 页）。奥莱利媒体。点燃版。

当然，它没有涵盖所有方面，但我认为它在有用的时候能给出一个很好的概念。

解决方案 11：

生成器函数、生成器对象、生成器：

Generator 函数就像Python 中的常规函数​​，但它包含一个或多个yield语句。Generator 函数是一种很好的工具，可以 尽可能轻松地创建Iterator对象。生成器函数返回的Iterator对象也称为Generator 对象或Generator。

在这个例子中，我创建了一个 Generator 函数，它返回一个 Generator 对象<generator object fib at 0x01342480>。就像其他迭代器一样，Generator 对象可以在 for循环中使用，也可以与内置函数一起使用next()，该函数返回来自生成器的下一个值。

def fib(max):
    a, b = 0, 1
    for i in range(max):
        yield a
        a, b = b, a + b
print(fib(10))             #<generator object fib at 0x01342480>

for i in fib(10):
    print(i)               # 0 1 1 2 3 5 8 13 21 34


print(next(myfib))         #0
print(next(myfib))         #1
print(next(myfib))         #1
print(next(myfib))         #2

因此，生成器函数是创建 Iterator 对象的最简单方法。

迭代器：

每个生成器对象都是一个迭代器__iter__，但反之则不然。如果其类实现方法__next__（也称为迭代器协议），则可以创建自定义迭代器对象 。

但是，使用生成器函数创建迭代器要容易得多，因为它们简化了迭代器的创建，但自定义迭代器可以给您更多的自由，您还可以根据您的要求实现其他方法，如下例所示。

class Fib:
    def __init__(self,max):
        self.current=0
        self.next=1
        self.max=max
        self.count=0

    def __iter__(self):
        return self

    def __next__(self):
        if self.count>self.max:
            raise StopIteration
        else:
            self.current,self.next=self.next,(self.current+self.next)
            self.count+=1
            return self.next-self.current

    def __str__(self):
        return "Generator object"

itobj=Fib(4)
print(itobj)               #Generator object

for i in Fib(4):  
    print(i)               #0 1 1 2

print(next(itobj))         #0
print(next(itobj))         #1
print(next(itobj))         #1

解决方案 12：

您可以针对同一数据比较两种方法：

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

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

解决方案 13：

可迭代对象是可以（自然地）迭代的对象。但是，要做到这一点，您将需要迭代器对象之类的东西，是的，这个术语可能令人困惑。可迭代对象包含一个__iter__方法，该方法将返回可迭代对象的迭代器对象。

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

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

如果您想要迭代任何集合，您将需要使用它的迭代器：

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

但是，Python 会自动使用迭代器，这就是为什么你永远不会看到上述示例。相反，你应该这样写：

for i in things:
    print(i)

自己编写迭代器可能很繁琐，因此 Python 有一个更简单的替代方案：生成器函数。生成器函数不是普通函数。它不会运行代码并返回最终结果，而是延迟执行代码，函数会立即返回一个生成器对象。

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

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

通常情况下，如果您只需要生成器，那么您会选择生成器。但是，如果您要构建一个更复杂的对象，其中包括迭代等功能，那么您将改用迭代器协议。

解决方案 14：

尽管 Python 本质上可以做很多事情，但我专门以一种非常简单的方式为 Python 新手编写了这篇文章。

让我们从最基础的开始：

考虑一个列表，

l = [1,2,3]

让我们编写一个等效函数：

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

o/p 的print(l): [1,2,3]& o/p 的print(f()) : [1,2,3]

让我们使列表 l 可迭代：在 python 中列表始终是可迭代的，这意味着您可以随时应用迭代器。

让我们在列表上应用迭代器：

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

因此如果你已经观察过，一旦你制作了函数 fa 生成器，它就已经是 iter(f)

现在，

l 是列表，应用迭代器方法“iter”后变为 iter(l)

f 已经是 iter(f)，应用迭代器方法 "iter" 后它变成 iter(iter(f))，再次是 iter(f)

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

例如 o/p 为：

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

是

<class 'list_iterator'>

永远不要忘记这是 Python 而不是 C 或 C++

因此，从上述解释可以得出的结论是：

列表 l ~= iter(l)

生成函数 f == iter(f)

解决方案 15：

所有生成器都是迭代器，但反之则不然。

from typing import Iterator
from typing import Iterable
from typing import Generator

class IT:

    def __init__(self):
        self.n = 0

    def __iter__(self):
        return self

    def __next__(self):
        if self.n == 4:
            raise StopIteration
        try:
            return self.n
        finally:
            self.n += 1


def g():
    for i in range(4):
        yield i

def test(it):
    print(f'type(it) = {type(it)}')
    print(f'isinstance(it, Generator) = {isinstance(it, Generator)}')
    print(f'isinstance(it, Iterator) = {isinstance(it, Iterator)}')
    print(f'isinstance(it, Iterable) = {isinstance(it, Iterable)}')
    print(next(it))
    print(next(it))
    print(next(it))
    print(next(it))
    try:
        print(next(it))
    except StopIteration:
        print('boom
')


print(f'issubclass(Generator, Iterator) = {issubclass(Generator, Iterator)}')
print(f'issubclass(Iterator, Iterable) = {issubclass(Iterator, Iterable)}')
print()
test(IT())
test(g())

输出：

issubclass(Generator, Iterator) = True
issubclass(Iterator, Iterable) = True

type(it) = <class '__main__.IT'>
isinstance(it, Generator) = False
isinstance(it, Iterator) = True
isinstance(it, Iterable) = True
0
1
2
3
boom

type(it) = <class 'generator'>
isinstance(it, Generator) = True
isinstance(it, Iterator) = True
isinstance(it, Iterable) = True
0
1
2
3
boom