python黑魔法---迭代器（iterator），pythoniterator,优雅不经在于自己使用，还

python黑魔法---迭代器（iterator），pythoniterator,优雅不经在于自己使用，还

因为Python，我见识了优雅。优雅不经在于自己使用，还在于如何设计API给别人使用。

设计 api 的时候，可以利用 python 的描述符完成很多工作，而这些描述符操作，还有一个名字就是“魔法方法”。前面我们介绍了一个装饰器魔法，现在再来认识一下迭代器神功。

迭代器（iterator）是访问集合内元素的一种方式，提供了一种遍历类序列对象的方法。对于一般的序列，利用索引从0一直迭代到序列的最后一个元素。对象从集合的第一个元素开始访问，直到所有的元素都被访问一遍后结束。对于字典、文件、自定义对象类型等，可以自定义迭代方式，从而实现对这些对象的遍历。总之，迭起器就是定义了对对象进行遍历的方式。

一些编程语言C，C++需要实现这样的结构。另外一些高级语言python，ruby则把迭代协议在语言层面就实现了。当然，这样的隐藏了一些细节，有时候明明已经使用了，却浑然不知。

iter 函数

python提供了一个iter函数用来生成迭代器。这个方法有两个参数，当只有一个参数的时候，若这个参数是一个容器，则返回这个容器的迭代器对象，若这个参数本身就是一个迭代器，则返回其自身。

Python

In [1]: alist = [1, 2, 3, 4]

In [2]: it = iter(alist)

In [3]: it
Out[3]: <listiterator at 0x102496e10>

In [4]: it2 = iter(it)

In [5]: id(it) == id(it2)
Out[5]: True

iterator 的特点

迭代器都有一个next方法，每次调用这个方法而实现计数，当然计数不是通过索引实现，调用了next方法只会，迭代指针会指向下一个元素的位置。若下一个元素没有了，则会抛出StopIteration异常。

Python

In [6]: it.next()
Out[6]: 2

In [7]: it.next()
Out[7]: 3

In [8]: it.next()
Out[8]: 4

In [9]: it.next()
---------------------------------------------------------------------------
StopIteration                             Traceback (most recent call last)
<ipython-input-16-54f0920595b2> in <module>()
----> 1 it.next()

StopIteration:

In [10]:

这样做有什么用呢？试想想在迭代指针还没指到的当前元素时候，已经迭代之后的位置元素，那些元素需要计算么？因为只有迭代到当前位置的元素时候，才开始计算元素的值。在迭代之前可以不存在，在迭代之后可以被销毁。实现的迭代器不需要准备所遍历的所有元素，没错，这就是迭代器的一大魅力，惰性计算。

for 循环

知道了迭代器大致的用法，我们来遍历一个迭代器。

In [1]: it = iter(range(4))

In [2]: try:
   ...:     while True:
   ...:         print it.next()
   ...: except StopIteration:
   ...:     pass
   ...:
0
1
2
3

In [3]:

上面的遍历看上去比较别扭，更不没有python优雅的感觉，或许，想到遍历一个容器，for in循环更优雅

In [3]: it = range(4)

In [4]: for i in it:
   ...:     print i
   ...:
0
1
2
3

In [5]:

两次运算的效果几乎一样，那么for循环的机理是什么呢。前面所言python内置实现了各种迭代协议，for循环就是一个很好的例子。for 循环的时候，首先对循环对象实现迭代器包装，返回一个迭代器对象，然后每循环一步，就调用哪个迭代器对象的next方法，循环结束的时候，自动处理了 StopIteration这个异常。for循环是对迭代器进行迭代的语法糖。无处不在的语法糖。

当然实现迭代器的时候，有时候会把索引丢掉，在python可以使用内建函数enumerate获取索引。

iterator 的定义

对于上面的 it 这个迭代器，是通过 iter方法实现的，那么iter函数到底做了什么呢？简而言之，实现了迭代器协议的对象，就是迭代器。什么事迭代器协议呢？再简而言之，满足下面两个条件即可：

• 实现了魔法方法 __iter__()，返回一个迭代对象，这个对象有一个next()方法，
• 实现 next() 方法，返回当前的元素，并指向下一个元素的位置，当前位置已经没有元素的时候，抛出StopIteration异常。

前面我们迭代range(4)是从零开始，现在我们实现一个迭代器对象，可以逆序迭代的。

class ReverseList():

    def __init__(self, item):
        self.list = range(item)

    def __iter__(self):
        return self

    def next(self):

        try:
            return self.list.pop()
        except:
            raise StopIteration

In [1]: it = ReverseList(4)

In [2]: it.next()
Out[2]: 3

In [3]: it.next()
Out[3]: 2

In [4]: it.next()
Out[4]: 1

In [5]: it.next()
Out[5]: 0

In [6]:

更复杂的遍历逻辑，都可以在 next 方法里构造。当然，看到了这里，也就大概知道了迭代器的协议，也已经是python的数据结构实现了的。并且还没见识到惰性计算。其实吧，惰性计算，python有更好的处理魔法，就是生成器，关于生成器，比迭代器神功还有效。

接下来就是用迭代器的迭代之后销毁元素的特性，做一个练习吧。

有一个偶数项的列表 a = ["foo", 2, "bar", 4, "far", 6]，希望对每两个相邻的两个元素打包，是为一组, 使得结果如下是这样的 [("foo", 2), ("bar", 4), ("far", 6)]。如果是要打包是每三个一组呢？

有很多方法可以解决，下面使用迭代器进行处理，大概代码如下：

a = ["foo", 2, "bar", 4, "far", 6]
group_adjacent = lambda x, k: zip(*([iter(x)] * k))

In [1]: a = ["foo", 2, "bar", 4, "far", 6]

In [2]: group_adjacent = lambda x, k: zip(*([iter(x)] * k))

In [3]: group_adjacent(a, 2)
Out[3]: [('foo', 2), ('bar', 4), ('far', 6)]

In [4]:

对于迭代器，python还有很多高级功能，并且还专门有一个itertools标准库用来做迭代器对象的相关处理。

迭代器魔法没有装饰器那么惊艳，却有着魔幻的力量，配合生成器，更有另一番天地。