[Python设计模式] 第20章 挨个买票——迭代器模式

github地址:https://github.com/cheesezh/python_design_patterns

迭代器模式

迭代器模式，提供一种方法顺序访问一个聚合对象中各个元素，而又不暴露该对象的内部表示[DP]。

当需要访问一个聚集对象，而且不管这些对象是什么都需要遍历的时候，就应该考虑使用迭代器模式。

当需要对聚集有多种方式遍历时，也可以考虑使用迭代器模式。

迭代器为遍历不同的聚集结构提供如开始，下一个，是否结束，当前哪一项等统一接口。

from abc import ABCMeta, abstractmethod

class Iterator():
    """
    迭代器抽象类，定义得到开始对象，得到下一对象，判断是否结尾，得到当前对象等方法
    """
    __metaclass__ = ABCMeta

    @abstractmethod
    def first(self):
        pass

    @abstractmethod
    def next(self):
        pass

    @abstractmethod
    def is_done(self):
        pass

    @abstractmethod
    def current_item(self):
        pass

class Aggregate():
    """
    聚集抽象类
    """
    __metaclass__ = ABCMeta

    @abstractmethod
    def create_iterator(self):
        pass

class ConcreteIterator(Iterator):
    """
    具体迭代器类
    """
    def __init__(self, aggregate):
        # 定义一个具体的聚集对象，初始化时将具体的聚集对象传入
        self.aggregate = aggregate
        self.current = 0

    def first(self):
        # 得到聚集的第一个对象
        return self.aggregate.get_value(0)

    def next(self):
        # 得到聚集的下一个对象
        ret = None
        self.current += 1
        if self.current < self.aggregate.length:
            ret = self.aggregate.get_value(self.current)
        return ret

    def is_done(self):
        return True if self.current >= self.aggregate.length else False

    def current_item(self):
        return self.aggregate.get_value(self.current)

class ConcreteAggregate(Aggregate):
    """
    具体聚集类
    """
    def __init__(self):
        self.list = []
        self.length = 0

    def create_iterator(self):
        return ConcreteIterator(self)

    def create_iterator_desc(self):
        return ConcreteIteratorDesc(self)

    def insert_value(self, value):
        self.list.append(value)
        self.length += 1

    def get_value(self, index):
        return self.list[index]

def main():
    agg = ConcreteAggregate()
    agg.insert_value("aa")
    agg.insert_value("bb")
    agg.insert_value("cc")
    agg.insert_value("dd")
    agg.insert_value("ee")

    i = agg.create_iterator()

    item = i.first()
    while i.is_done() == False:
        print("{} 买车票".format(i.current_item()))
        i.next()

main()

aa 买车票
bb 买车票
cc 买车票
dd 买车票
ee 买车票

逆序遍历

class ConcreteIteratorDesc(Iterator):
    """
    具体迭代器类，逆序遍历
    """
    def __init__(self, aggregate):
        # 定义一个具体的聚集对象，初始化时将具体的聚集对象传入
        self.aggregate = aggregate
        self.current = self.aggregate.length-1

    def first(self):
        # 得到聚集的第一个对象
        return self.aggregate.get_value(self.aggregate.length-1)

    def next(self):
        # 得到聚集的下一个对象
        ret = None
        self.current -= 1
        if self.current >= 0:
            ret = self.aggregate.get_value(self.current)
        return ret

    def is_done(self):
        return True if self.current < 0 else False

    def current_item(self):
        return self.aggregate.get_value(self.current)

def main():
    agg = ConcreteAggregate()
    agg.insert_value("aa")
    agg.insert_value("bb")
    agg.insert_value("cc")
    agg.insert_value("dd")
    agg.insert_value("ee")

    i = agg.create_iterator_desc()

    item = i.first()
    while i.is_done() == False:
        print("{} 买车票".format(i.current_item()))
        i.next()

main()

ee 买车票
dd 买车票
cc 买车票
bb 买车票
aa 买车票

点评

总的来说，迭代器模式就是分离了集合对象的遍历行为，抽象出一个迭代器类来负责，这样既可以做到不暴露集合的内部结构，又可以让外部代码透明的访问集合内部的数据。