流畅的迭代器(一)

流畅的迭代器01.png

通过一个简单类的实现及优化过程,慢慢深入迭代的概念。

该类的主要功能如下:

  • 传入一段话
  • 可以迭代输出这段话的中所包含的每个词

第一版单词序列

这一版的单词序列实现如下两个接口:

  • __getitem__ 根据索引获取数据
  • __len__ 获取序列的长度
import re
import reprlib

RE_WORD = re.compile(r'\w+')


class Sentence(object):
    def __init__(self, text):
        self.text = text
        self.words = RE_WORD.findall(text)

    def __getitem__(self, index):
        # 根据索引获取数据
        return self.words[index]

    def __len__(self):
        # 获取序列的长度
        return len(self.words)

    def __repr__(self):
        # reprlib.repr(xxx) 当xxx长度过长时会用...自动省略
        return 'Sentence(%s)' % reprlib.repr(self.text)
In [1]: s = Sentence('"The time has come," the Walrus said,')          
                                                                       
In [2]: s                                                              
Out[2]: Sentence('"The time ha... Walrus said,')                       
                                                                       
In [3]: s[0]                                                           
Out[3]: 'The'                                                          
                                                                       
In [4]: for word in s:                                                
   ...:     print(word)                                               
   ...:                                                               
The                                                                    
time                                                                   
has                                                                    
come                                                                   
the                                                                    
Walrus                                                                 
said                                                                   

当我们使用 for 循环去迭代的时候,for 循环会先去使用 iter() 函数从目标对象中获取一个迭代器,然后对此迭代器进行迭代。

所以,我们还可以这么去做迭代:

In [5]: sw = Sentence('"The time has come," the Walrus said,')

In [6]: sw_it = iter(sw)

In [7]: while True:
   ...:     try:
   ...:         print(next(sw_it))
   ...:     except StopIteration:
   ...:         del sw_it
   ...:         break
   ...:
The
time
has
come
the
Walrus
said

这种写法,把 for 循环背后的迭代器显式地展现了出来。

iter() 获取迭代器的过程中会进行如下几个主要的操作:

  • 检查有没有实现 __iter__ 方法,如果有则通过该方法获取一个迭代器对象。
  • 如果没有实现 __iter__ 方法,那就会去找有没有实现 __getitem__ 方法,如果实现了,Python 会创建一个迭代器,该迭代器尝试从索引0开始返回数据(必须从0开始)。
  • 如果 __getitem__ 也没有实现,那就抛出 TypeError 异常,表明 C object is not iterable

注意: 如果我们需要自己实现一个迭代器,尽量去实现它的 __iter__ 方法,这是现在的标准做法,__getitem__ 只是为了兼容以前的代码做的补丁。

其实看源码中,对于迭代器对象的检查是这么做的:

class Iterator(Iterable):

    __slots__ = ()

    @abstractmethod
    def __next__(self):
        'Return the next item from the iterator. When exhausted, raise StopIteration'
        raise StopIteration

    def __iter__(self):
        return self

    @classmethod
    def __subclasshook__(cls, C):
        if cls is Iterator:
            return _check_methods(C, '__iter__', '__next__')
        return NotImplemented

__subclasshook__ 方法所示,通过检查有没有 __iter____next__ 两个方法来判断是否为迭代器。

因为我们的 Sentence 类是通过实现 __getitem__ 的接口来获取迭代器的,所以虽然既能使用 for 循环迭代,又可以通过索引获取对应值,但是它本身并不可迭代,无法通过以下代码的验证:

from collections.abc import Iterable


issubclass(list, Iterable)  # True
issubclass(Sentence, Iterable)  # False

isinstance(list(), Iterable)  # True
isinstance(Sentence(''), Iterable)  # False

s_it = iter(Sentence(''))
isinstance(s_it, Iterable)  # True

总结

  1. 使用 iter() 内置函数可以获取迭代器的对象。
  2. 如果对象实现了能返回迭代器的
    __iter__ 方法,那么对象就是可迭代的。
  3. 另外,如果实现了 __getitem__
    法,而且其参数是从零开始的索引,这种对象也可以迭代,但不属于可迭代对象。