python重温设计模式===>行为型

第三个模块。

observer.py

#!/usr/bin/env python# encoding: utf-8"""观察者模式定义类一种一对多的依赖关系, 让多个观察者对象同时监听某一个主题对象, 这个主题对象在发生变化时, 会通知所有观察者对象, 使它们能够自动干呢更新自己- 适用: 当一个对象的改变需要同时改变其他对象时- 解耦合, 让耦合的双方依赖于抽象, 而不是依赖于具体"""from abc import ABCMeta, abstractmethodclass Subject(object):    """    把所有对观察者对象的引用保存在一个聚集里    每个主题都可以有任意数量的观察者.    抽象主题提供了接口增加/删除观察者对象    """    def __init__(self):        self.__observers = []    def attach(self, observer):        self.__observers.append(observer)    def detach(self, observer):        self.__observers.remove(observer)    def notify(self):        for o in self.__observers:            o.update()class ConcreteSubject(Subject):    """    具体主题, 将有关状态存入具体的观察者对象    在具体主题的内部状态改变时, 给所有登记过的观察者发出通知    """    @property    def status(self):        return self.__status    @status.setter    def status(self, value):        self.__status = valueclass Observer(object):    """    抽象观察者, 位所有具体观察者定义接口, 在得到主题的通知时更新自己    """    __metaclass__ = ABCMeta    @abstractmethod    def update(self):        passclass ConcreteObserver(Observer):    """    具体观察者, 实现抽象观察者锁要求的更新接口    以使本身的状态与主题的状态相协调    """    def __init__(self, subject, name):        self.subject = subject        self.name = name        self.objserver_staus = None    def update(self):        self.objserver_staus = self.subject.status        print "the observer: %s status change to %s" % (self.name , self.objserver_staus)if __name__ == '__main__':    s = ConcreteSubject()    s.attach(ConcreteObserver(s, "X"))    s.attach(ConcreteObserver(s, "Y"))    s.attach(ConcreteObserver(s, "Z"))    s.status = "A"    s.notify()    s.status = "B"    s.notify()

abstract.py

#!/usr/bin/env python# encoding: utf-8"""模板方法模式定义一个操作中的算法的股价, 而将一些步骤的实现延迟到子类中这样, 可以使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤- 把不变行为放到超类, 去除子类中的重复代码- 提供了一个很好地代码复用平台"""from abc import ABCMeta, abstractmethodclass AbstractClass(object):    """    实现了一个模板方法, 定义了算法的挂架    """    __metaclass__ = ABCMeta    def say_hello(self):        print "begin..."        self.hello()        self.world()        print "end..."    @abstractmethod    def hello(self):        pass    @abstractmethod    def world(self):        passclass ConcreteClass(AbstractClass):    """    实现了特定的步骤    """    def hello(self):        print "hello"    def world(self):        print "world"if __name__ == '__main__':    c = ConcreteClass()    c.say_hello()

command.py

#!/usr/bin/env python# encoding: utf-8"""命令模式讲一个请求封装为一个对象, 从而使你可用不同的请求对客户进行参数化对请求排队或记录请求日志, 以及支持可撤销操作- 比较容易设计一个命令队列- 在需要情况下, 可以将命令计入日志- 允许接受请求的一方决定是否要否决请求- 可以容易的实现对请求的撤销和崇左- 由于加紧新的具体命令类不影响其他类,  可以很容易新增- 把请求一个操作的对象与指导怎么执行一个操作的对象分隔开"""from abc import ABCMeta, abstractmethodclass Command(object):    """    声明执行操作的接口    """    __metaclass__ = ABCMeta    def __init__(self, receiver):        self.receiver = receiver    @abstractmethod    def execute(self):        passclass ConcreteCommand(Command):    """    将一个接受着对象绑定于一个动作, 调用接收者相应的操作    """    def execute(self):        self.receiver.action()class Invoker(object):    @property    def command(self):        return self.__command    @command.setter    def command(self, value):        self.__command = value    def execute_command(self):        self.__command.execute()class Receiver(object):    def action(self):        print "execute command"if __name__ == '__main__':    r = Receiver()    cmd = ConcreteCommand(r)    invoker = Invoker()    invoker.command = cmd    invoker.execute_command()

state.py

#!/usr/bin/env python# encoding: utf-8"""状态模式当一个对象的内在状态改变时, 允许改变其行为. 这个对象看起来更像是改变了其类- 解决: 当控制一个对象状态转换的条件表达式过于复杂的情况,        把状态的判断逻辑转移到表示不同状态的一系列类中, 可以把复杂的判断逻辑简单化- 好处: 将与特定状态相关的行为局部化, 并且将不同状态的行为分割开来- 通过定义新的子类, 可以很容易地增加新的状态和转换- 消除庞大的条件分支语句, 减少相互间的依赖, 把各种状态转移逻辑分布到了State的子类之间- 适用: 当一个对象的行为取决于它的状态, 并且它必需在运行时刻根据状态改变其行为时, 使用状态模式"""from abc import ABCMeta, abstractmethodclass State(object):    """    抽象状态类, 定义一个接口以封装与Context的一个特定状态相关的行为    """    __metaclass__ = ABCMeta    @abstractmethod    def handle(self, context):        passclass ConcreteStateA(State):    def handle(self, context):        """        设定下一个状态是        """        context.state = ConcreteStateB()class ConcreteStateB(State):    def handle(self, context):        """        设定下一个状态是        """        context.state = ConcreteStateA()class Context(object):    """    维护一个ConcreteState子类的实例, 这个实例定义当前的状态    """    def __init__(self, state):        self.__state = state    @property    def state(self):        return self.__state    @state.setter    def state(self, value):        print "current status:", value.__class__.__name__        self.__state = value    def request(self):        self.__state.handle(self)if __name__ == '__main__':    c = Context(ConcreteStateA())    c.request()    c.request()    c.request()    c.request()

chain_of_responsibility.py

#!/usr/bin/env python# encoding: utf-8"""责任链模式使多个对象都以机会处理请求, 从而避免请求的发送者和接受者之间的耦合关系将这个对象连成一条链, 沿着这条链传递请求, 直到有一个对象处理它为止- 可以随意增加或修改处理一个请求的链式结构"""from abc import ABCMeta, abstractmethodclass Handler(object):    """    定义一个处理请求的接口    """    __metaclass__ = ABCMeta    def __init__(self):        self.__successor = None    @property    def successor(self):        return self.__successor    @successor.setter    def successor(self, value):        self.__successor = value    @abstractmethod    def handle_request(self, request):        passclass ConcreteHandlerA(Handler):    """    具体处理类, 处理它所负责的请求    如果可以处理该请求, 处理之, 否则转给后继者    """    def handle_request(self, request):        if 0 <= request < 10:            print "%s process %s" % (self.__class__.__name__, request)        else:            self.successor.handle_request(request)class ConcreteHandlerB(Handler):    """    具体处理类, 处理它所负责的请求    如果可以处理该请求, 处理之, 否则转给后继者    """    def handle_request(self, request):        if 10 <= request < 20:            print "%s process %s" % (self.__class__.__name__, request)        else:            self.successor.handle_request(request)class ConcreteHandlerC(Handler):    """    具体处理类, 处理它所负责的请求    如果可以处理该请求, 处理之, 否则转给后继者    """    def handle_request(self, request):        if 20 <= request < 30:            print "%s process %s" % (self.__class__.__name__, request)        else:            self.successor.handle_request(request)if __name__ == '__main__':    h1 = ConcreteHandlerA()    h2 = ConcreteHandlerB()    h3 = ConcreteHandlerC()    h1.successor = h2    h2.successor = h3    for req in [2, 14, 22]:        print req        h1.handle_request(req)

interpreter.py

#!/usr/bin/env python# encoding: utf-8"""解释器模式给定一个语言, 定义他的文法的一种表示, 并定义一个解释器, 这个解释器使用该表示来解释语言中的句子- 解决: 如果一种特定类型问题发生的频率足够高, 那么可能就值得将该问题的各个实例表述为一个简单语言中的句子,        这样就可以构建一个解释器, 该解释其通过解释这些句子来解决该问题- 适用: 当有一个语言需要解释执行, 并且你可以将该语言中的句子表示为一个抽象语法树时- 好处: 容易改变和扩展文法- 不足: 需要为文法中的每一条规则至少定义一个类, 可能难以维护和管理"""from abc import ABCMeta, abstractmethodclass AbstractExpression(object):    """    抽象表达式, 声明一个抽象的解释操作    这个接口被抽象语法书中的所有节点所共享    """    __metaclass__ = ABCMeta    @abstractmethod    def interpret(self, context):        passclass TerminalExpression(AbstractExpression):    """    终结符表达式    实现与文法中的终结符相关联的解释操作    """    def interpret(self, context):        print "terminal"class NoterminalExpression(AbstractExpression):    """    非终结符表达式    为文法中的非终结符实现解释操作, 对文法中每一条规则R1/R2...Rn都需要一个具体的非终结符表达式    """    def interpret(self, context):        print "no terminal"class Context(object):    """    包含解释器之外的一些全局信息    """    def __init__(self, input, output):        self.__input = input        self.__output = output    @property    def input(self):        return self.__input    @input.setter    def input(self, value):        self.__input = value    @property    def output(self):        return self.__output    @output.setter    def output(self, value):        self.__output = valueif __name__ == '__main__':    context = Context("in", "out")    l = []    l.append(TerminalExpression())    l.append(TerminalExpression())    l.append(NoterminalExpression())    for i in l:        i.interpret(context)

mediator.py

#!/usr/bin/env python# encoding: utf-8"""中介者模式用一个中介对象来封装一系列的对象交互中介者使各对象不需要显示的相互引用, 从而使耦合松散, 可以独立地改变他们之间的交互- 多对多交互- 把对象如何写作进行了抽象"""from abc import ABCMeta, abstractmethodclass Mediator(object):    """    抽象中介者, 定义了同事对象到中介者对象的接口    """    __metaclass__ = ABCMeta    @abstractmethod    def send(self, msg, colleague):        passclass ConcreteMediator(Mediator):    """    具体中介者对象, 实现抽象类的方法    需要知道所有具体的同事类, 并从具体的同事类接收消息, 想具体同事对象发出命令    """    @property    def colleague1(self):        return self.__colleague1    @colleague1.setter    def colleague1(self, value):        self.__colleague1 = value    @property    def colleague2(self):        return self.__colleague2    @colleague2.setter    def colleague2(self, value):        self.__colleague2 = value    def send(self, msg, colleague):        if colleague == self.__colleague1:            self.__colleague2.notify(msg)        else:            self.__colleague1.notify(msg)class Colleague(object):    """    抽象同事类    """    __metaclass__ = ABCMeta    def __init__(self, mediator):        self.__mediator = mediator    @property    def mediator(self):        return self.__mediator    @abstractmethod    def send(self, message):        pass    @abstractmethod    def notify(self, message):        passclass ConcreteColleague1(Colleague):    def send(self, message):        self.mediator.send(message, self)    def notify(self, message):        print "colleageu 1 get message: ", messageclass ConcreteColleague2(Colleague):    def send(self, message):        self.mediator.send(message, self)    def notify(self, message):        print "colleageu 2 get message: ", messageif __name__ == '__main__':    m = ConcreteMediator()    c1 = ConcreteColleague1(m)    c2 = ConcreteColleague2(m)    m.colleague1 = c1    m.colleague2 = c2    c1.send("hello, I am C1")    c2.send("Hey, I am C2")

visitor.py

#!/usr/bin/env python# encoding: utf-8"""访问者模式标识一个作用于某对象结构中的各元素的操作可以使你在不改变各元素类的前提下定义作用于这些元素的新操作- 适用于数据结构相对稳定的系统, 把数据结构和作用于结构上的操作之间的耦合解脱开, 是的操作集合可以相对自由地演化- 目的是: 把处理从数据结构分离出来, 有比较稳定的数据结构, 又有易于变化的算法- 优点: 增加新的操作很容易, 等同于增加一个新的访问者"""from abc import ABCMeta, abstractmethodclass Visitor(object):    """    为该对象结构中concreteelement的每一个类声明一个visit操作    """    __metaclass__ = ABCMeta    @abstractmethod    def visitor_concrete_element_a(self, concrete_element_a):        pass    @abstractmethod    def visitor_concrete_element_b(self, concrete_element_b):        passclass ConcreteVisitor1(Visitor):    """    具体访问者, 实现每个声明的操作    每个操作实现算法的一部分, 而该算法片段乃是对应于结构中对象的类    """    def visitor_concrete_element_a(self, concrete_element_a):        print "%s visit %s" % (self.__class__.__name__,                               concrete_element_a.__class__.__name__)    def visitor_concrete_element_b(self, concrete_element_b):        print "%s visit %s" % (self.__class__.__name__,                               concrete_element_b.__class__.__name__)class ConcreteVisitor2(Visitor):    """    具体访问者, 实现每个声明的操作    每个操作实现算法的一部分, 而该算法片段乃是对应于结构中对象的类    """    def visitor_concrete_element_a(self, concrete_element_a):        print "%s visit %s" % (self.__class__.__name__,                               concrete_element_a.__class__.__name__)    def visitor_concrete_element_b(self, concrete_element_b):        print "%s visit %s" % (self.__class__.__name__,                               concrete_element_b.__class__.__name__)class Element(object):    """    定义一个accept操作, 以一个访问者为参数    """    __metaclass__ = ABCMeta    @abstractmethod    def accept(self, visitor):        passclass ConcreteElementA(Element):    """    具体元素, 实现accept操作    """    def accept(self, visitor):        visitor.visitor_concrete_element_a(self)class ConcreteElementB(Element):    """    具体元素, 实现accept操作    """    def accept(self, visitor):        visitor.visitor_concrete_element_b(self)class ObjectStructure(object):    """    能枚举它的元素, 可以提供一个高层的接口以允许访问者访问它的元素    """    def __init__(self):        self.__elements = []    def attach(self, element):        self.__elements.append(element)    def detach(self, element):        self.__element.remove(element)    def accept(self, visitor):        for e in self.__elements:            e.accept(visitor)if __name__ == '__main__':    os = ObjectStructure()    os.attach(ConcreteElementA())    os.attach(ConcreteElementB())    v1 = ConcreteVisitor1()    os.accept(v1)    v2 = ConcreteVisitor2()    os.accept(v2)

strategy.py

#!/usr/bin/env python# encoding: utf-8"""策略模式它定义了算法家族, 分别封装起来, 让他们之间可以互相替换, 此模式让算法的变化, 不会影响到使用算法的客户- 策略模式是一种定义一系列算法的方法, 从概念上来讲, 所有算法完成的都是相同的工作, 只是实现不同,  它可以以相同的方式调用所有的算法, 减少各种算法与算法类之间的耦合- 策略模式的Strategy类层次位Context定义了一系列的可供重用的算法或行为, 继承有助于析取出这些算法中的公用功能- 优点: 简化了单元测试, 每个算法有自己的类, 可以通过自己的接口单独测试- 解决: 不同行为堆砌在同一个类中, 很难避免使用条件语句, 通过Strategy消除之- 作用: 封装算法/业务规则等"""from abc import ABCMeta, abstractmethodclass Strategy(object):    """    策略类, 定义所有支持的算法的公共接口    """    __metaclass__ = ABCMeta    @abstractmethod    def calculate(self):        passclass StrategyA(Strategy):    """    具体策略类, 封装了具体的算法和行为    """    def calculate(self):        print "calculate A"class StrategyB(Strategy):    """    具体策略类, 封装了具体的算法和行为    """    def calculate(self):        print "calculate B"class Context(object):    """    上下文, 维护一个对strategy对象的引用    """    def __init__(self, strategy):        self.__strategy = strategy    def do_calculate(self):        self.__strategy.calculate()if __name__ == '__main__':    c1 = Context(StrategyA())    c1.do_calculate()    c2 = Context(StrategyB())    c2.do_calculate()

memento.py

#!/usr/bin/env python# encoding: utf-8"""备忘录在不破坏封装性的前提下, 捕获一个对象的内部状态, 并在该对象之外保存这个状态这样以后可以将该对象恢复到原先保存的状态- 将要保存的细节封装到memento中- 比较适合功能比较复杂, 需要维护或记录属性的历史类, 或者需要保存部分属性- 例如: 保存历史命令,  并执行撤销操作- 备忘录可以把复杂的对象内部信息对其他对象屏蔽起来"""class Originator(object):    """    创建一个备忘录Memento, 用以记录当前时刻的内部状态, 并可以使用备忘录恢复内部状态    """    def __init__(self, state):        self.__state = state    @property    def state(self):        return self.__state    @state.setter    def state(self, value):        self.__state = value    def create_memento(self):        return Memento(self.__state)    def set_memento(self, memento):        self.__state = memento.state    def show(self):        print "State:", self.__stateclass Memento(object):    """    负责存储Originator的内部状态, 并可以防止除Originator以外的其他对象访问    """    def __init__(self, state):        self.__state = state    @property    def state(self):        return self.__stateclass Caretaker(object):    """    负责保存好备忘录Memento    """    def __init__(self):        self.__memento = None    @property    def memento(self):        return self.__memento    @memento.setter    def memento(self, value):        self.__memento = valueif __name__ == '__main__':    o = Originator("init")    o.show()    o.state = "begin"    o.show()    mem = o.create_memento()    # save it    c = Caretaker()    c.memento = mem    o.state = "change"    o.show()    # recover    o.set_memento(c.memento)    o.show()

iterator.py

#!/usr/bin/env python# encoding: utf-8"""迭代器模式提供一种方法顺序地访问一个聚合对象中的各个元素, 而又不暴露改对象的内部表示- 无差别遍历聚合对象- 需要对聚集进行多种方式遍历时- 分离了集合对象的遍历行为, 做到不暴露集合内部结构, 又可以让外部代码透明的访问集合内部的数据"""# 不考虑默认的迭代器from abc import ABCMeta, abstractmethodclass Iterator(object):    """    迭代抽象类    定义迭代器抽象方法    """    __metaclass__ = ABCMeta    @abstractmethod    def first(self):        pass    @abstractmethod    def next(self):        pass    @abstractmethod    def is_done(self):        pass    @abstractmethod    def current_item(self):        passclass ConcreteIterator(Iterator):    def __init__(self, aggregate):        self.__aggregate = aggregate        self.current = 0    def first(self):        return self.__aggregate[0]    def next(self):        result = None        self.current += 1        if self.current < len(self.__aggregate):            result = self.__aggregate[self.current]        return result    def is_done(self):        return self.current >= len(self.__aggregate)    def current_item(self):        return self.__aggregate[self.current]if __name__ == '__main__':    aggregate = [0] * 3    aggregate[0] = 'a'    aggregate[1] = 'b'    aggregate[2] = 'c'    it = ConcreteIterator(aggregate)    i = it.first()    while not it.is_done():        print "current:", it.current_item()        it.next()