4.8　迭代器

迭代对于读者已经不陌生了，已经多次看到这个词语并对其有了初步解了。

我们已经知道，对序列（列表、元组）、字典和文件都可以用iter()方法生成迭代对象，然后用next()方法访问。当然，这种访问不是自动的，如果用for循环，就可以自动完成上述访问了。

如果用dir（list）、dir（tuple）、dir（file）、dir（dict）来查看不同类型对象的属性，会发现它们都有一个名为iter的东西。这应该引起读者的关注，因为它和迭代器（iterator）、内置的函数iter()在名字上很像，除了前后的双下画线。望文生义，我们也能猜出它肯定是跟迭代有关的东西。当然，这种猜测也不是没有根据的，其重要根据就是英文单词，如果它们之间没有一点关系，肯定不会将命名设置的一样。

是的，iter就是对象的一个特殊方法，它是迭代规则（iterator potocol）的基础。或者说，如果对象没有它，就不能返回迭代器，就没有next()方法，就不能迭代。

如果读者用的是Python 3.x，迭代器对象实现的是next()方法，不是next()。并且，在Python 3.x中有一个内建函数next()，可以实现next（it），访问迭代器，这相当于Python 2.x中的it.next()（it是迭代对象）。

4.8.1　iter()

类型是list、tuple、file、dict的对象有iter()方法，标志着它们能够迭代。这些类型都是Python中固有的，我们能不能自己写一个对象，让它能够迭代呢？

当然可以。

  1. #!/usr/bin/env python
  2. # coding=utf-8
  3.  
  4. class MyRange(object):
  5.     def __init__(self, n):
  6.         self.i = 0
  7.         self.n = n
  8.     def __iter__(self):
  9.         return self
  10.     def next(self):
  11.         if self.i < self.n:
  12.             i = self.i
  13.             self.i += 1
  14.             return i
  15.         else:
  16.             raise StopIteration()
  17.  
  18. if __name__ == "__main__":
  19.     x = MyRange(7)
  20.     print "x.next()==>", x.next()
  21.     print "x.next()==>", x.next()
  22.     print "------for loop--------"
  23.     for i in x:
  24.     print i

将代码保存并运行，结果是：

  1. $ python 21401.py
  2. x.next()==> 0
  3. x.next()==> 1
  4. ------for loop--------
  5. 2
  6. 3
  7. 4
  8. 5
  9. 6

以上代码的含义，是自己仿写了拥有range()的对象，这个对象是可迭代的，分析如下。

（1）iter()是类中的核心，它返回了迭代器本身，实现了iter()方法的对象，即意味着其可迭代。

（2）含有next()的对象就是迭代器，并且在这个方法中，在没有元素的时候要发起StopIteration()异常。

对以上类的调用换一种方式：

  1. if __name__ == "__main__":
  2.     x = MyRange(7)
  3.     print list(x)
  4.     print "x.next()==>", x.next()

运行后会出现如下结果：

  1. $ python 21401.py 
  2. [0, 1, 2, 3, 4, 5, 6]
  3. x.next()==>
  4. Traceback (most recent call last):
  5.   File "21401.py", line 26, in <module>
  6.     print "x.next()==>", x.next()
  7.   File "21401.py", line 21, in next
  8.     raise StopIteration()
  9. StopIteration

说明什么呢？print list（x）将对象返回值都装进了列表中并打印出来，这个正常运行了。最终，指针移动到了迭代对象的最后一个，next()方法没有检测，也不知道是不是要停止了，它还要继续下去，当继续下一个的时候，才发现没有元素了，于是返回了StopIteration()。

为什么要用这种可迭代的对象呢？就像上面的例子一样，列表不是挺好的吗？

列表的确非常好，在很多时候效率很高，并且能够解决很多普遍的问题。但是，不要忘记，在某些时候，列表可能会给你带来灾难。因为在你使用列表的时候，需要将列表内容一次性都读入到内存中，这样就增加了内存的负担。如果列表太大，就有内存溢出的危险了，这时候就需要迭代对象。比如斐波那契数列：

  1. #!/usr/bin/env python
  2. # coding=utf-8
  3.  
  4. __metaclass__ = type
  5.  
  6. class Fibs:
  7.     def __init__(self, max):
  8.         self.max = max
  9.         self.a = 0
  10.         self.b = 1
  11.  
  12.     def __iter__(self):
  13.         return self
  14.  
  15.     def next(self):
  16.         fib = self.a
  17.         if fib > self.max:
  18.             raise StopIteration
  19.     self.a, self.b = self.b, self.a + self.b
  20.     return fib
  21.  
  22. if __name__ == "__main__":
  23.     fibs = Fibs(5)
  24.     print list(fibs)

运行结果是：

  1. $ python 21402.py 
  2. [0, 1, 1, 2, 3, 5]

给读者一个思考问题：要在斐波那契数列中找出大于1000的最小的数，能不能在上述代码的基础上改造得出呢？

4.8.2　range()和xrange()

关于列表和迭代器之间的区别还有两个非常典型的内建函数：range()和xrange()，研究一下这两个内建函数的差异，会有所收获的。

  1. range(...)
  2.     range(stop) -> list of integers
  3.     range(start, stop[, step]) -> list of integers
  4. >>> dir(range)
  5.      ['__call__', '__class__', '__cmp__', '__delattr__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__self__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']

从range()的帮助文档和方法中可以看出，它的结果是一个列表。但是，如果用help（xrange）查看：

  1. class xrange(object)
  2.     |  xrange(stop) -> xrange object
  3.     |  xrange(start, stop[, step]) -> xrange object
  4.     |  
  5.     |  Like range(), but instead of returning a list, returns an object that
  6.     |  generates the numbers in the range on demand.  For looping, this is 
  7.     |  slightly faster than range() and more memory efficient.

xrange()返回的是对象，类似range()，但不是列表。在循环的时候，它跟range()相比“slightly faster than range()and more memory efficient”（稍快并具有更高的内存效率）。查看它的方法：

  1. >>> dir(xrange)
  2. ['__class__', '__delattr__', '__doc__', '__format__', '__getattribute__', '__getitem__', '__hash__', '__init__', '__iter__', '__len__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']

看到令人兴奋的iter了吗？说明它是可迭代的，它返回的是一个可迭代的对象。

也就是说，通过range()得到的列表会一次性被读入内存，而xrange()返回的对象，则需要一个数值才返回一个数值。看一个把zip()牵扯进来的例子。

  1. >>> zip(range(4), xrange(100000000))
  2. [(0, 0), (1, 1), (2, 2), (3, 3)]

第一个range（4）产生的列表被读入内存；第二个很长，但是不用担心，它根本不会产生那么长的列表，因为只需要前4个数值，它就提供前4个数值。如果你要修改为range（100000000），就要花费时间了，但可以尝试一下。

迭代器的确有迷人之处，但是它也不是万能之物。比如迭代器不能回退，只能如过河的卒子，不断向前。另外，迭代器也不适合在多线程环境中对可变集合使用。