[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 买车票

点评

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