python-迭代器模式

源码地址:https://github.com/weilanhanf/PythonDesignPatterns

说明：

集合是用来管理和组织数据对象的数据结构的。集合有两项基本职能：一、批量的存储数据对象，二、在不暴露集合内部结构的条件下向外界提供访问内部元素的接口（可能存在的遍历方式：顺序、逆序遍历，二叉树的广度优先，先序后序中序遍历等）。要使得集合保持整洁和优雅，而不是说令集合内部包含着各种遍历的方法。因此要求将遍历的方法从集合的指责中分离出来，按照不同的遍历需求分别封装成一个个专门遍历集合内部数据的迭代器。这种思想可以最大限度的减少彼此之间的耦合程度，从而建立一个松散耦合的对象网络。职责分离的要点就是要对分离的职责进行封装，并以抽象对象的方式建立彼此之间的关系。

迭代器模式：提供一种方法顺序访问一个聚合对象中各个元素，且不用暴露该对象的内部表示

聚合对象的两个职责： 存储数据，聚合对象的基本职责 遍历数据，既是可变化的，又是可分离的。将遍历数据的行为从聚合对象中分离出来，封装在迭代器对象中。由迭代器来提供遍历聚合对象内部数据的行为，简化聚合对象的设计，更符合单一职责原则。

迭代器模式包含以下4个角色：

Iterator（抽象迭代器） ConcreteIterator（具体迭代器） Aggregate（抽象聚合类） ConcreteAggregate（具体聚合类）

实例：

#迭代器抽象类
class Iterator(object):
    def First(self):
        pass

    def Next(self):
        pass

    def Isdone(self):
        pass

    def CurrItem(self):
        pass

#聚集抽象类
class Aggregate(object):

    def CreateIterator(self):
        pass

#具体迭代器类
class ConcreteIterator(Iterator):

    def __init__(self, aggregate):
        self.aggregate = aggregate
        self.curr = 0

    def First(self):
        return self.aggregate[0]

    def Next(self):
        ret = None
        self.curr += 1
        if self.curr < len(self.aggregate):
            ret = self.aggregate[self.curr]
        return ret

    def Isdone(self):
        return True if self.curr+1 >= len(self.aggregate) else False

    def CurrItem(self):
        return self.aggregate[self.curr]

#具体聚集类
class ConcreteAggregate(Aggregate):

    def __init__(self):
        self.ilist = []

    def CreateIterator(self):
        return ConcreteIterator(self)

class ConcreteIteratorDesc(Iterator):
    def __init__(self, aggregate):
        self.aggregate = aggregate
        self.curr = len(aggregate)-1

    def First(self):
        return self.aggregate[-1]

    def Next(self):
        ret = None
        self.curr -= 1
        if self.curr >= 0:
            ret = self.aggregate[self.curr]
        return ret

    def Isdone(self):
        return True if self.curr-1<0 else False

    def CurrItem(self):
        return self.aggregate[self.curr]

if __name__=="__main__":
    ca = ConcreteAggregate()
    ca.ilist.append("大鸟")
    ca.ilist.append("小菜")
    ca.ilist.append("老外")
    ca.ilist.append("小偷")

    itor = ConcreteIterator(ca.ilist)
    print(itor.First())
    while not itor.Isdone():
        print(itor.Next())
    print("————倒序————")
    itordesc = ConcreteIteratorDesc(ca.ilist)
    print(itordesc.First())
    while not itordesc.Isdone():
        print(itordesc.Next())

#源码出处http://www.cnblogs.com/onepiece-andy/p/python-iterator-pattern.html

打印结果：

大鸟
小菜
老外
小偷
————倒序————
小偷
老外
小菜
大鸟

模式优点

支持以不同的方式遍历一个聚合对象，在同一个聚合对象上可以定义多种遍历方式 简化了聚合类 由于引入了抽象层，增加新的聚合类和迭代器类都很方便，无须修改原有代码，符合开闭原则

模式缺点

在增加新的聚合类时需要对应地增加新的迭代器类，类的个数成对增加，这在一定程度上增加了系统的复杂性 抽象迭代器的设计难度较大，需要充分考虑到系统将来的扩展。在自定义迭代器时，创建一个考虑全面的抽象迭代器并不是一件很容易的事情

模式适用环境

访问一个聚合对象的内容而无须暴露它的内部表示 需要为一个聚合对象提供多种遍历方式 为遍历不同的聚合结构提供一个统一的接口，在该接口的实现类中为不同的聚合结构提供不同的遍历方式，而客户端可以一致性地操作该接口