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) | 下节:生成器