迭代是一个通用术语，指一个接一个地获取某物的每一项。任何时候使用循环，显式或隐式，遍历一组项，这就是迭代。

在Python中，iterable和iterator有特定的含义。

iterable是一个具有__iter__方法的对象，该方法返回一个迭代器，或者定义了__getitem__方法，该方法可以接受从0开始的顺序索引(并在索引不再有效时引发IndexError)。iterable是一个你可以从中获取迭代器的对象。

迭代器是具有next (Python 2)或__next__ (Python 3)方法的对象。

无论何时在Python中使用for循环、map或列表推导式等，都会自动调用下一个方法从迭代器中获取每一项，从而完成迭代过程。

开始学习的一个好地方是教程的迭代器部分和标准类型页面的迭代器类型部分。在您理解了基础知识之后，请尝试函数式编程HOWTO中的迭代器部分。

迭代器是实现iter和next方法的对象。如果定义了这些方法，则可以使用for循环或推导式。

class Squares:
    def __init__(self, length):
        self.length = length
        self.i = 0
        
    def __iter__(self):
        print('calling __iter__') # this will be called first and only once
        return self
    
    def __next__(self): 
        print('calling __next__') # this will be called for each iteration
        if self.i >= self.length:
            raise StopIteration
        else:
            result = self.i ** 2
            self.i += 1
            return result

迭代器会耗尽。这意味着在你遍历项目之后，你不能重复，你必须创建一个新对象。假设你有一个类，它包含cities属性，你想要遍历。

class Cities:
    def __init__(self):
        self._cities = ['Brooklyn', 'Manhattan', 'Prag', 'Madrid', 'London']
        self._index = 0
    
    def __iter__(self):
        return self
    
    def __next__(self):
        if self._index >= len(self._cities):
            raise StopIteration
        else:
            item = self._cities[self._index]
            self._index += 1
            return item

类Cities的实例是一个迭代器。然而，如果你想在城市上重复，你必须创建一个新对象，这是一个昂贵的操作。你可以把这个类分成两个类:一个返回城市，第二个返回一个迭代器，它将城市作为初始参数。

class Cities:
    def __init__(self):
        self._cities = ['New York', 'Newark', 'Istanbul', 'London']        
    def __len__(self):
        return len(self._cities)



class CityIterator:
    def __init__(self, city_obj):
        # cities is an instance of Cities
        self._city_obj = city_obj
        self._index = 0
        
    def __iter__(self):
        return self
    
    def __next__(self):
        if self._index >= len(self._city_obj):
            raise StopIteration
        else:
            item = self._city_obj._cities[self._index]
            self._index += 1
            return item

现在如果我们需要创建一个新的迭代器，我们不需要再次创建数据，也就是城市。我们创建了cities对象并将其传递给迭代器。但我们仍在做额外的工作。我们可以通过只创建一个类来实现这一点。

Iterable是一个实现Iterable协议的Python对象。它只需要返回一个迭代器对象的新实例的__iter__()。

class Cities:
    def __init__(self):
        self._cities = ['New York', 'Newark', 'Istanbul', 'Paris']
        
    def __len__(self):
        return len(self._cities)
    
    def __iter__(self):
        return self.CityIterator(self)
    
    class CityIterator:
        def __init__(self, city_obj):
            self._city_obj = city_obj
            self._index = 0

        def __iter__(self):
            return self

        def __next__(self):
            if self._index >= len(self._city_obj):
                raise StopIteration
            else:
                item = self._city_obj._cities[self._index]
                self._index += 1
                return item

迭代器有__iter__和__next__，可迭代对象有__iter__，所以我们可以说迭代器也是可迭代对象，但它们是耗尽的可迭代对象。另一方面，迭代对象永远不会耗尽 因为它们总是返回一个新的迭代器，然后用于迭代

你注意到可迭代器代码的主要部分是在迭代器中，而可迭代器本身只不过是一个额外的层，允许我们创建和访问迭代器。

在可迭代对象上迭代

Python有一个内置的函数iter()，它调用__iter__()。当我们遍历一个可迭代对象时，Python调用iter()，它返回一个迭代器，然后它开始使用迭代器的__next__()来遍历数据。

注意，在上面的例子中，Cities创建了一个可迭代对象，但它不是一个序列类型，这意味着我们不能通过索引获得一个城市。为了解决这个问题，我们应该将__get_item__添加到Cities类中。

class Cities:
    def __init__(self):
        self._cities = ['New York', 'Newark', 'Budapest', 'Newcastle']
        
    def __len__(self):
        return len(self._cities)
    
    def __getitem__(self, s): # now a sequence type
        return self._cities[s]
    
    def __iter__(self):
        return self.CityIterator(self)
    
    class CityIterator:
        def __init__(self, city_obj):
            self._city_obj = city_obj
            self._index = 0

        def __iter__(self):
            return self

        def __next__(self):
            if self._index >= len(self._city_obj):
                raise StopIteration
            else:
                item = self._city_obj._cities[self._index]
                self._index += 1
                return item

以下是我在教授Python课程时使用的解释:

ITERABLE是:

任何可以循环的东西(例如，你可以循环一个字符串或文件)或 任何可以出现在for循环右边的东西:for x in iterable:…或 任何你可以用iter()调用并返回ITERATOR: iter(obj)或 一个定义__iter__的对象，该对象返回一个新的ITERATOR， 或者它可能有一个适合索引查找的__getitem__方法。

ITERATOR是一个对象:

在迭代过程中，state会记住它的位置， 使用__next__方法: 返回迭代中的下一个值 更新状态以指向下一个值 信号，当它完成时，引发StopIteration 并且它是可自迭代的(意味着它有一个返回self的__iter__方法)。

注:

Python 3中的__next__方法在Python 2中拼写为next，并且 内置函数next()在传递给它的对象上调用该方法。

例如:

>>> s = 'cat'      # s is an ITERABLE
                   # s is a str object that is immutable
                   # s has no state
                   # s has a __getitem__() method 

>>> t = iter(s)    # t is an ITERATOR
                   # t has state (it starts by pointing at the "c"
                   # t has a next() method and an __iter__() method

>>> next(t)        # the next() function returns the next value and advances the state
'c'
>>> next(t)        # the next() function returns the next value and advances
'a'
>>> next(t)        # the next() function returns the next value and advances
't'
>>> next(t)        # next() raises StopIteration to signal that iteration is complete
Traceback (most recent call last):
...
StopIteration

>>> iter(t) is t   # the iterator is self-iterable

iterable = [1, 2] 

iterator = iter(iterable)

print(iterator.__next__())   

print(iterator.__next__())   

so,

Iterable是一个可以循环的对象。例如，列表，字符串，元组等。 在iterable对象上使用iter函数将返回一个迭代器对象。 现在这个迭代器对象有一个名为__next__的方法(在Python 3中，或者在Python 2中只是next)，通过它你可以访问iterable的每个元素。

所以, 以上代码的输出为:

1

2

其他人已经全面地解释了什么是iterable和iterator，所以我将尝试对生成器做同样的事情。

恕我直言，理解生成器的主要问题是“生成器”这个词的混淆用法，因为这个词有两种不同的含义:

作为创建(生成)迭代器的工具， 以返回迭代器的函数形式(即在函数体中包含yield语句)， 以生成器表达式的形式 作为使用该工具的结果，即结果迭代器。 (在这个意思中，生成器是迭代器的一种特殊形式——“generator”这个词指出了这个迭代器是如何创建的。)

Generator作为第一种工具:

In[2]: def my_generator():
  ...:     yield 100
  ...:     yield 200

In[3]: my_generator

输出[3]:<function __main__.my_generator()> .my_generator(

In[4]: type(my_generator)

[4]:函数

生成器作为使用此工具的结果(即迭代器):

In[5]: my_iterator = my_generator()
In[6]: my_iterator

输出[6]:<生成器对象my_generator at 0x00000000053EAE48>

In[7]: type(my_iterator)

[7]:发电机

Generator作为第二种类型的工具-与该工具的结果迭代器难以区分:

In[8]: my_gen_expression = (2 * i for i in (10, 20))
In[9]: my_gen_expression

Out[9]: <generator object <genexpr> at 0x000000000542C048>

In[10]: type(my_gen_expression)

[10]:发电机

iterable是一个具有__iter__()方法的对象。它可以迭代多次，比如list()和tuple()。

迭代器是进行迭代的对象。它由__iter__()方法返回，通过自己的__iter__()方法返回自身，并有一个next()方法(3.x中的__next__())。

迭代是调用next()响应的过程。__next__()直到引发StopIteration。

例子:

>>> a = [1, 2, 3] # iterable
>>> b1 = iter(a) # iterator 1
>>> b2 = iter(a) # iterator 2, independent of b1
>>> next(b1)
1
>>> next(b1)
2
>>> next(b2) # start over, as it is the first call to b2
1
>>> next(b1)
3
>>> next(b1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration
>>> b1 = iter(a) # new one, start over
>>> next(b1)
1