For freedom Christ has set us free. Stand firm, therefore, and do not submit again to a yoke of slavery.
基督释放了我们，叫我们得以自由，所以要站立得稳，不要再被奴仆的轭挟制。(GALATIANS 5:1)
#迭代器
迭代，对于读者已经不陌生了，曾有专门一节来讲述，如果印象不深，请复习《迭代》。
正如读者已知，对序列（列表、元组）、字典和文件都可以用iter()方法生成迭代对象，然后用next()方法访问。当然，这种访问不是自动的，如果用for循环，就可以自动完成上述访问了。
如果用dir(list),dir(tuple),dir(file),dir(dict)来查看不同类型对象的属性，会发现它们都有一个名为__iter__的东西。这个应该引起读者的关注，因为它和迭代器（iterator）、内置的函数iter()在名字上是一样的，除了前后的双下划线。望文生义，我们也能猜出它肯定是跟迭代有关的东西。当然，这种猜测也不是没有根据的，其重要根据就是英文单词，如果它们之间没有一点关系，肯定不会将命名搞得一样。
猜对了。__iter__就是对象的一个特殊方法，它是迭代规则(iterator potocol)的基础。或者说，对象如果没有它，就不能返回迭代器，就没有next()方法，就不能迭代。
提醒注意，如果读者用的是python3.x，迭代器对象实现的是
__next__()方法，不是next()。并且，在python3.x中有一个内建函数next()，可以实现next(it)，访问迭代器，这相当于于python2.x中的it.next()（it是迭代对象）。
那些类型是list、tuple、file、dict对象有__iter__()方法，标着他们能够迭代。这些类型都是python中固有的，我们能不能自己写一个对象，让它能够迭代呢？
当然呢！要不然python怎么强悍呢。
#!/usr/bin/env python
# coding=utf-8
"""
the interator as range()
"""
class MyRange(object):
def __init__(self, n):
self.i = 0
self.n = n
def __iter__(self):
return self
def next(self):
if self.i < self.n:
i = self.i
self.i += 1
return i
else:
raise StopIteration()
if __name__ == "__main__":
x = MyRange(7)
print "x.next()==>", x.next()
print "x.next()==>", x.next()
print "------for loop--------"
for i in x:
print i
将代码保存，并运行，结果是：
$ python 21401.py
x.next()==> 0
x.next()==> 1
------for loop--------
2
3
4
5
6
以上代码的含义，是自己仿写了拥有range()的对象，这个对象是可迭代的。分析如下：
类MyRange的初始化方法__init__()就不用赘述了，因为前面已经非常详细分析了这个方法，如果复习，请阅读《类(2)》相关内容。
__iter__()是类中的核心，它返回了迭代器本身。一个实现了__iter__()方法的对象，即意味着其实可迭代的。
含有next()的对象，就是迭代器，并且在这个方法中，在没有元素的时候要发起StopIteration()异常。
如果对以上类的调用换一种方式：
if __name__ == "__main__":
x = MyRange(7)
print list(x)
print "x.next()==>", x.next()
运行后会出现如下结果：
$ python 21401.py
[0, 1, 2, 3, 4, 5, 6]
x.next()==>
Traceback (most recent call last):
File "21401.py", line 26, in <module>
print "x.next()==>", x.next()
File "21401.py", line 21, in next
raise StopIteration()
StopIteration
说明什么呢？print list(x)将对象返回值都装进了列表中并打印出来，这个正常运行了。此时指针已经移动到了迭代对象的最后一个，正如在《迭代》中描述的那样，next()方法没有检测也不知道是不是要停止了，它还要继续下去，当继续下一个的时候，才发现没有元素了，于是返回了StopIteration()。
为什么要将用这种可迭代的对象呢？就像上面例子一样，列表不是挺好的吗？
列表的确非常好，在很多时候效率很高，并且能够解决相当普遍的问题。但是，不要忘记一点，在某些时候，列表可能会给你带来灾难。因为在你使用列表的时候，需要将列表内容一次性都读入到内存中，这样就增加了内存的负担。如果列表太大太大，就有内存溢出的危险了。这时候需要的是迭代对象。比如斐波那契数列（在本教程多处已经提到这个著名的数列：《练习》的练习4，《函数(4)》中递归举例）:
#!/usr/bin/env python
# coding=utf-8
"""
compute Fibonacci by iterator
"""
__metaclass__ = type
class Fibs:
def __init__(self, max):
self.max = max
self.a = 0
self.b = 1
def __iter__(self):
return self
def next(self):
fib = self.a
if fib > self.max:
raise StopIteration
self.a, self.b = self.b, self.a + self.b
return fib
if __name__ == "__main__":
fibs = Fibs(5)
print list(fibs)
运行结果是：
$ python 21402.py
[0, 1, 1, 2, 3, 5]
给读者一个思考问题：要在斐波那契数列中找出大于1000的最小的数，能不能在上述代码基础上改造得出呢？
关于列表和迭代器之间的区别，还有两个非常典型的内建函数：range()和xrange()，研究一下这两个的差异，会有所收获的。
range(...)
range(stop) -> list of integers
range(start, stop[, step]) -> list of integers
>>> dir(range)
['__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)查看：
class xrange(object)
| xrange(stop) -> xrange object
| xrange(start, stop[, step]) -> xrange object
|
| Like range(), but instead of returning a list, returns an object that
| generates the numbers in the range on demand. For looping, this is
| slightly faster than range() and more memory efficient.
xrange()返回的是对象，并且进一步告诉我们，类似range()，但不是列表。在循环的时候，它跟range()相比“slightly faster than range() and more memory efficient”，稍快并更高的内存效率（就是省内存呀）。查看它的方法：
>>> dir(xrange)
['__class__', '__delattr__', '__doc__', '__format__', '__getattribute__', '__getitem__', '__hash__', '__init__', '__iter__', '__len__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']
看到令人兴奋的__iter__了吗？说明它是可迭代的，它返回的是一个可迭代的对象。
也就是说，通过range()得到的列表，会一次性被读入内存，而xrange()返回的对象，则是需要一个数值才从返回一个数值。比如这样一个应用：
还记得zip()吗？
>>> a = ["name", "age"]
>>> b = ["qiwsir", 40]
>>> zip(a,b)
[('name', 'qiwsir'), ('age', 40)]
如果两个列表的个数不一样，就会以短的为准了，比如：
>>> zip(range(4), xrange(100000000))
[(0, 0), (1, 1), (2, 2), (3, 3)]
第一个range(4)产生的列表被读入内存；第二个是不是也太长了？但是不用担心，它根本不会产生那么长的列表，因为只需要前4个数值，它就提供前四个数值。如果你要修改为range(100000000)，就要花费时间了，可以尝试一下哦。
迭代器的确有迷人之处，但是它也不是万能之物。比如迭代器不能回退，只能如过河的卒子，不断向前。另外，迭代器也不适合在多线程环境中对可变集合使用（这句话可能理解有困难，先混个脸熟吧，等你遇到多线程问题再说）。
总目录 | 上节：特殊方法(2) | 下节：生成器
如果你认为有必要打赏我，请通过支付宝：[email protected],不胜感激。