总结理解的迭代器以及可迭代对象（用大白话）

前言（一些废话）

之前面试中迭代器这个概念经常被问到，脑子里一直有这么一个印象和FOR循环似乎有那么一点关系，但是就是不知道怎么用大白话去说，就那种似懂非懂的感觉想要说又不知道从何开始说，所以决定自己通过代码来让自己理解透彻一点。

什么是可迭代对象

众所周知使用for循环可以遍历的对象有：字典，列表，元祖，字符串，集合。我们称之为遍历，也叫作迭代，但是创建的一个类是否可以迭代呢？

# 我们自定义一个容器MyList用来存放数据，可以通过add方法向其中添加数据
>>> class MyList(object):
...     def __init__(self):
...             self.container = []
...     def add(self, item):
...             self.container.append(item)
...
>>> mylist = MyList()
>>> mylist.add(1)
>>> mylist.add(2)
>>> mylist.add(3)
>>> for num in mylist:
...     print(num)
...
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'MyList' object is not iterable
>>>
# MyList容器的对象也是不能迭代的

我们自定义了一个容器类型MyList，在将一个存放了多个数据的MyList对象放到for…in…的语句中，发现for…in…并不能从中依次取出一条数据返回给我们，也就说我们随便封装了一个可以存放多条数据的类型却并不能被迭代使用。反正能用for…in…语句的对象我们就称之为可迭代对象Iterable（好像怪怪的~）。

如何判断一个对象是否可以迭代

那总不能想要判断一个对象是不是可以迭代的都用for循环去验证一下吧?好像有那么一点点low，Python中提供了一个方法 isinstance() 可以去判断是不是Iterable。

>>> from collections import Iterable
>>> isinstance([], Iterable)
True
>>> isinstance({}, Iterable)
True
>>> isinstance('abc', Iterable)
True
>>> isinstance((x for x in range(10)), Iterable)
True
>>> isinstance(100, Iterable)
False

可迭代对象的本质

讲到这里是不是可以提出一个结论：isinstance(‘xxx’, Iterable)返回为True那么就是一个可迭代对象。但是可迭代对象是不是就是迭代器（Iterator）呢？迭代器（Iterator）是不是就是可迭代对象呢？先用isinstance()来看看。

>>> from collections import Iterator

>>> isinstance([], Iterator)
>>> False

>>> isinstance(iter([]), Iterator)
>>> True

>>> isinstance("abc", Iterator)
>>> False

看到这可以回答一个问题了：可迭代对象不一定都是迭代器。那么可迭代对象具体又是什么？用一个我觉得很容易理解的总结：分析对可迭代对象进行迭代使用的过程，发现每迭代一次（即在for…in…中每循环一次）都会返回对象中的下一条数据，一直向后读取数据直到迭代了所有数据后结束。那么，在这个过程中就应该有一个“人”去记录每次访问到了第几条数据，以便每次迭代都可以返回下一条数据。我们把这个能帮助我们进行数据迭代的“人”称为迭代器(Iterator)。
可迭代对象的本质就是可以向我们提供一个这样的中间“人”即迭代器帮助我们对其进行迭代遍历使用。
可迭代对象通过__iter__方法向我们提供一个迭代器，我们在迭代一个可迭代对象的时候，实际上就是先获取该对象提供的一个迭代器，然后通过这个迭代器来依次获取对象中的每一个数据。
那么也就是说，一个具备了__iter__方法的对象，就是一个可迭代对象
我们对刚刚的MyList()类改造一下：

>>> class MyList(object):
...     def __init__(self):
...             self.container = []
...     def add(self, item):
...             self.container.append(item)
...     def __iter__(self):
...             """返回一个迭代器"""
...             # 我们暂时忽略如何构造一个迭代器对象
...             pass

再判断是不是可迭代的：

>>> mylist = MyList()
>>> from collections import Iterable
>>> isinstance(mylist, Iterable)
True
>>>

那么是不是迭代器呢？

>>> mylist = MyList()
>>> from collections import Iterator
>>> isinstance(mylist, Iterable)
False
>>>

虽然说改造后成为了一个可迭代的对象但是还不是一个迭代器。

iter()函数与next()函数

list、tuple等都是可迭代对象，我们可以通过iter()函数获取这些可迭代对象的迭代器。然后我们可以对获取到的迭代器不断使用next()函数来获取下一条数据。iter()函数实际上就是调用了可迭代对象的__iter__方法。

>>> li = [11, 22, 33, 44, 55]
>>> li_iter = iter(li)
>>> next(li_iter)
11
>>> next(li_iter)
22
>>> next(li_iter)
33
>>> next(li_iter)
44
>>> next(li_iter)
55
>>> next(li_iter)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration
>>>

注意，当我们已经迭代完最后一个数据之后，再次调用next()函数会抛出StopIteration的异常，来告诉我们所有数据都已迭代完成，不用再执行next()函数了。其实也是for循环的本质。
所以把list、dict、str等Iterable变成Iterator可以使用iter()函数
反之是不是我们在我们刚刚的MyList()类中加入一个__next__方法就可以成为迭代器呢？

class MyList(object):
    """自定义的一个可迭代对象"""
    def __init__(self):
        self.items = []

    def add(self, val):
        self.items.append(val)

    def __iter__(self):
        myiterator = MyIterator(self)
        # 返回一个具有next方法的对象
        return myiterator


class MyIterator(object):
    """自定义的供上面可迭代对象使用的一个迭代器"""
    def __init__(self, mylist):
        self.mylist = mylist
        # current用来记录当前访问到的位置
        self.current = 0

    def __next__(self):
        if self.current < len(self.mylist.items):
            item = self.mylist.items[self.current]
            self.current += 1
            return item
        else:
            raise StopIteration

    def __iter__(self):
        return self
# 当然这里也可以写在一起，这样写只是为了更好理解
>>> mylist = MyList()
>>> from collections import Iterator
>>> isinstance(mylist, Iterable)
True
>>>

写在一起:

class MyList(object):
    def __init__(self):
        self.items = []
        self.current = 0

    def add(self,name):
        self.names.append(name)

    def __iter__(self):
        return self

    def __next__(self):
        if self.current < len(self.names):
            ret = self.names[self.current ]
            self.current += 1
            return ret
        else:
            raise StopIteration
if __name__ == '__main__':
    mylist = MyList()
    mylist.add(1)
    mylist.add(2)
    mylist.add(3)
    mylist.add(4)
    mylist.add(5)
    for num in mylist:
        print(num)

小结

1. 凡是可作用于for循环的对象都是Iterable类型；
2. 凡是可作用于next()函数的对象都是Iterator类型，它们表示一个惰性计算的序列；
3. 集合数据类型如list、dict、str等是Iterable但不是Iterator，不过可以通过iter()函数获得一个Iterator对象。
4. Python的for循环本质上就是通过不断调用next()函数实现的

斐波拉契数列

可以看到迭代器的一个好处就是不会占用大量的内存，而是通过next()函数的调用来返回下一个数据值。如果每次返回的数据值不是在一个已有的数据集合中读取的，而是通过程序按照一定的规律计算生成的。我们可以用来实现以下斐波拉契数列：

class Fibonacci(object):
    def __init__(self,all_num):
        self.all_num = all_num
        self.current_num = 0
        self.a = 0
        self.b = 1


    def __iter__(self):
        return self

    def __next__(self):
        if self.current_num < self.all_num:
            ret = self.a
            self.a, self.b = self.b, self.a+self.b
            self.current_num += 1
            return ret
        else:
            raise StopIteration


f = Fibonacci(10)

for num in f:
    print(num)

>>>
0
1
1
2
3
5
8
13
21
34

呼，写完了~ 记录&分享