PythonTip >> 博文 >> chinaunix

【python那些事儿之十一】聊聊iterable,sequence和iterators

zihua 2014-03-26 18:03:28 点击: 2638 | 收藏


聊聊iterable,sequence和iterators 【1】

by Harrison Feng in Python

想必Python的老鸟们对于Python里的iterable,sequence和iterators应该是非常了解,且能做到运用自如。
但是对于刚刚开始学习Python的菜鸟们来说,这三个玩意儿估计够让他们抓狂的。
先看一段有趣的代码:

  1. >>> l = ['a', 'b', 'c']

  2. >>> l_iter = l.__iter__()

  3. >>> l

  4. ['a', 'b', 'c']

  5. >>> l_iter

  6. <list_iterator object at 0x7f40f2c46668>

  7. >>> for e in l: print(e)

  8. ...

  9. a

  10. b

    c

  11. >>> for e in l: print(e)

  12. ...

  13. a

  14. b

  15. c

  16. >>> l_iter.__next__()

  17. 'a'

  18. >>> l_iter.__next__()

  19. 'b'

  20. >>> for e in l_iter: print(e)

  21. ...

  22. c

  23. >>> l_iter.__next__()
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    StopIteration

  24. >>> list(l_iter)

  25. []

从这段代码,可以看出一些特点:

  1. list和由list生成的list_iterator都可以遍历。

  2. list可以无限次的使用,而list_iterator只能使用一次。

  3. list_iterator通过__next__()方法来获取下一个元素,且只能获取一次。

  4. 当最后一个元素被获取后,如果想继续,StopIteration将会抛出

其实在这里,list就是iterable(也是sequence),而l_iter则是iterator,为什么它们会有那些特点呢?下面将

详细介绍它们及其之间的关系。

Iterable

在Python里iterable被认为是一类对象,这类对象能够一次返回它的一个成员(也就是元素)。抽象一点就是
适合迭代的对象。实际上,任何具有__iter__()或__getitem__()方法的对象,Python就认为它是一个iterable。
Python里有大量内置的iterable类型,如: list,str,tuple,dict,file,xrange等。使用内置的iter()函数来生成
iterator。即:
iter(iterable)   ->  iterator object

Sequence

Sequence的字面意思是序列。既然是序列,那么就应该有成员,成员之间是有序的且包含了若干成员。当然
从理论上讲,序列的成员数可以是无限制的。那么将其抽象成数据类型后,便可定义为有序对象
的集合。维基
百科是这样定义sequence的:

A sequence is an ordered list. Like a set, it contains members (also called elements, or terms). The number of ordered elements (possibly
infinite) is called the
length of the sequence.
从定义可以看出sequence有三个特性:

  1. 包含成员(元素)

  2. 有序成员(有序)

  3. 成员数量(大小)

Python里这样定义sequence:

An iterable which supports efficient element access using integer indices via the __getitem__() special method and defines a __len__()
method that returns the length of the sequence.

从定义里可以看出,sequence首先是iterable。如果这个iterable可以通过整数索引来访问其元素并可以获
得其大
小,那
么它是sequence很显然,dict是iterable,但不是sequence,即使它有__getitem__() 和 __len__()
这两种方
法。因为它不是通过整数索引而是通过key来获取元素的。Python将sequence对象的三个特性变成了两
个方法__getitem__()
和 __len__()。通过这两个方法我们可以获得sequence对象的元素和大小。

Iterator

Iterator(迭代器)存在于众多面向对象的程序设计语言中,它是一种经典的设计模式。迭代器模式提供一种访问
有序访问聚合对象里元素的方法。具体到Python语言里,正如在我的前一篇博文《Iterators详解》介绍的,iterator
对象就是且必须实现了迭代协议(iterator protocol【1】【2】)的对象。Python里的iterator实现了两个方法:

  1. __iter__()                                         # 返回迭代器本身

  2. __next__() (Python2使用next()) 

通过iterable, sequence和iterator的定义可以看出这三者的密切关系。下图很好的诠释了它们之间的关系

很显然,Python认为sequence和iterator都是iterable。当然还有一部分non-sequence也被认为是iterable。例如,
dictionary,set等。定义了__getitem__()和__len__()方法的non-sequence对象和sequence对象都可以用iter()来
返回一个iterator。iter(X)是这样工作的(X是一个iterable):

  1. 调用X的__iter__()方法来生成一个iterator。

  2. 如果X没有__iter__()方法,Python将会自动构建一个iterator,并尝试通过X[0], X[1], X[2] ... 或X[key1],x[key2] ... 来获取元素。

Iterable里,sequence和non-sequence的区别就在于访问元素的方式,通过整数索引(index)访问的是seqence,
而不
能通过整数索引访问的是
non-sequence。其实,我们完全可以通过对象定义的方法来区分一个对象到底是iterable,
sequence还是iterator。

  • iterable: 至少定义了__iter__()或__getitem__()方法的对象。

  • sequence: 至少定义了__len__()或者__getitem__()方法的对象。

  • iterator:至少定义__iter__()和__next__()法的对象。

下面来看一些实例:

  1. #!/usr/bin/env python

  2. # -*- coding: utf -*-


  3. class Train(object):


  4.     def __init__(self, cars):

  5.         self.cars = cars


  6.     def __len__(self):

  7.         return self.cars


  8.     def __getitem__(self, key):

  9.         if key >= 0:

  10.             index = key

            else:

  11.             index = self.cars + key

  12.         if 0 <= index < len(self):

  13.             return 'Carriage #%s' % (index + 1)

            else:

  14.             raise IndexError('No carriage at #%s' % key)

这里,我们定义了一个名为Train的类实现了一个火车的sequence。这个实现了sequence的两个关键的方法:

__len__()和__getitem__(),实际上这两个方法被叫作sequence protocol。实现了这两个方法,也就实现了

个immutable 【4】的seqence。

  1. >>> from train import Train

  2. >>> t = Train(4)

  3. >>> t

  4. <train.Train object at 0x7f491e457080>

    >>> t[0]

  5. 'Carriage #1'

  6. >>> len(t)

    4

  7. >>> t.__len__()

  8. 4

  9. >>> t.__getitem__(2)

  10. 'Carriage #3'

  11. >>> t[3]

  12. 'Carriage #4'

  13. >>> t[-3]
    'Carriage #2'

  14. >>> for i in t:
    ...     print(i)
    ...
    Carriage #1
    Carriage #2
    Carriage #3
    Carriage #4

从上面的实验代码可以看出,我们可以对 t 进行遍历,获取元素和大小毫无疑问,这个t对象有__getitem__()

方法,所以它也是iterable。我们可以将用t来生成新的list,tuple等对象,也可生成iterator对象。请看下面的代码:

  1. >>> list(t)

  2. ['Carriage #1', 'Carriage #2', 'Carriage #3', 'Carriage #4'] # 生成了一个list对象

  3. >>> iter(t)

  4. <iterator object at 0x7f491e4755f8>

  5. >>> tuple(t)

  6. ('Carriage #1', 'Carriage #2', 'Carriage #3', 'Carriage #4') # 生成了一个tuple对象

  7. >>> t_iter = iter(t)          
    >>> t_iter
    <iterator object at 0x7f491e475da0>                          # 生成了一个iterator对象
    >>> "__iter__" and "__next__" in dir(t_iter) #
    True
    >>>

那么iterator和iterable(非iterator的iterable)到底有什么区别呢?我先看下面的代码:

  1. >>> t

  2. <train.Train object at 0x7f491e457080>

  3. >>> t[0]

  4. 'Carriage #1'

  5. >>> t[3]

  6. 'Carriage #4'

  7. >>> t[4]

  8. Traceback (most recent call last):

  9.   File "<stdin>", line 1, in <module>

  10.   File "/home/pygeek/DEV/pyprj/reading/train.py", line 22, in __getitem__

  11.     raise IndexError('No carriage at #%s' % key)

  12. IndexError: No carriage at #4

  13. >>> t[2]

  14. 'Carriage #3'

  15. >>> t[1]

  16. 'Carriage #2'

  17. >>> for i in t:             # 第一次遍历

  18. ... print(i)

  19. ...

  20. Carriage #1

  21. Carriage #2

  22. Carriage #3

  23. Carriage #4

  24. >>> for i in t:             # 第二次遍历

    ...     print(i)

    ...

    Carriage #1

    Carriage #2

    Carriage #3

    Carriage #4

t 对象是sequence,当然它也是iterable,但是它不是iterator。我们通过索引或遍历访问元素。当索引超出t对象

的长度范围时,IndexError将会被抛出。t对象可以被多次甚至无限次的使用但是,iterator确实有些不一样了。

  1. >>> t_iter = iter(t)

  2. >>> t_iter

  3. <iterator object at 0x7f491c9ac4e0>

  4. >>> t_iter[0]

    Traceback (most recent call last):

  5.   File "<stdin>", line 1, in <module>

  6. TypeError: 'iterator' object is not subscriptable

  7. >>> t_iter.__next__()

  8. 'Carriage #1'

  9. >>> t_iter.__next__()

  10. 'Carriage #2'

  11. >>> t_iter.__next__()

  12. 'Carriage #3'

  13. >>> t_iter.__next__()

  14. 'Carriage #4'

  15. >>> t_iter.__next__()

  16. Traceback (most recent call last):

  17.   File "<stdin>", line 1, in <module>

  18. StopIteration

  19. >>> for i in t_iter:

  20. ... print(i)

  21. ...

  22. >>>

上面的代码说明,iterator不能通过索引来访问元素,但是可以用它的__next__()方法来访问元素;可进行遍历,

但是只能完整遍历一次。当所有的元素都被访问过后,再调用__next__(),抛出的异常是StopIteration,而不是

IndexError。此时,我们称iterator已经被耗尽,不能再进行遍历。实际上,iterator存储了元素的位置状态并可以

通过调用__next__()访问下一个元素并更新内部的位置状态直到所有的元素都被访问。这些不同使得iterator对象

会比list,tuple这样的iterable更有效率并占用更少的内存空间。我们可以用sys.getsizeof()来做一粗略的测试:

  1. >>> t_iter = iter(t)

  2. >>> t_iter

  3. <iterator object at 0x7f491e479780>

  4. >>> t_list = list(t)

  5. >>> t_list

  6. ['Carriage #1', 'Carriage #2', 'Carriage #3', 'Carriage #4']

  7. >>> t_tuple = tuple(t)

  8. >>> t_tuple

  9. ('Carriage #1', 'Carriage #2', 'Carriage #3', 'Carriage #4')

  10. >>> sys.getsizeof(t), sys.getsizeof(t_iter), sys.getsizeof(t_list), sys.getsizeof(t_tuple)

  11. (56, 56, 120, 80)

我们可以看到list对象比iterator对象的两倍还要大。所以,如果我们仅仅只是需要iterable的元素,而不需要一个

完整的list的话,那么用iterator将更有效率并节省空间。

简单总结一下:

iterable: 实现了__iter__()或__getitem__()方法的对象。

sequence:实现是了sequence protocol(即方法: __getitem__()和__len__()),并能使用整数索引访问元素的iterable对象。

iterator: 实现了iterator protocol(即方法:__next__()和__iter__())的iterable对象。

通过iterable创建iterator的方法:

iter(iterable) -> iterator 

iterable.__iter__()  -> iterator 【5】

注:

【1】所有的代码都在Python 3.4.0下测试通过。
【2】protocol: a synonym  for interface used in dynamic languages like Python,Ruby,...

【3】iterator protocol: The iterator protocol consists of two methods. The __iter__() method, which must return the iterator object and the __next__() method, which returns the next element.

【4】immutable: An object with a fixed value. Such an object cannot be altered. A new object has to be created if a different value has to be stored.
【5】iterable.__iter__()返回的是一个新的iterator,而iterator.__iter__()返回的iterator对象本身。
原文链接:http://blog.chinaunix.net/uid-15174104-id-4172583.html

作者:zihua | 分类: chinaunix | 标签: python | 阅读: 2638 | 发布于: 2014-03-26 18时 |