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

题目

用程序模拟以下不同情况：

• 男人成功时，背后多半有一个伟大的女人；
• 女人成功时，背后多半有一个失败的男人；
• 男人失败时，闷头喝酒，谁也不用劝；
• 女人失败时，眼泪汪汪，谁也劝不了；
• 男人恋爱时，凡事不懂也要装逼；
• 女人恋爱时，遇事懂也装作不懂；

基础版本

from abc import ABCMeta,abstractmethod

class Person():

    __metaclass__ = ABCMeta

    def __init__(self):

        self.action = None

    @abstractmethod

    def get_conclusion(self):

        pass

class Man(Person):

    def get_conclusion(self):

        if self.action == "成功":

            print("男人成功时，背后多半有一个伟大的女人")

        elif self.action == "失败":

            print("男人失败时，闷头喝酒，谁也不用劝")

        elif self.action == "恋爱":

            print("男人恋爱时，凡事不懂也要装逼")

class Woman(Person):

    def get_conclusion(self):

        if self.action == "成功":

            print("女人成功时，背后多半有一个失败的男人")

        elif self.action == "失败":

            print("女人失败时，眼泪汪汪，谁也劝不了")

        elif self.action == "恋爱":

            print("女人恋爱时，遇事懂也装作不懂")

def main():

    persons = []

    man1 = Man()

    man1.action = "成功"

    persons.append(man1)

    woman1 = Woman()

    woman1.action = "成功"

    persons.append(woman1)

    man2 = Man()

    man2.action = "失败"

    persons.append(man2)

    woman2 = Woman()

    woman2.action = "失败"

    persons.append(woman2)

    man3 = Man()

    man3.action = "恋爱"

    persons.append(man3)

    woman3 = Woman()

    woman3.action = "恋爱"

    persons.append(woman3)

    for p in persons:

        p.get_conclusion()

main()

男人成功时，背后多半有一个伟大的女人

女人成功时，背后多半有一个失败的男人

男人失败时，闷头喝酒，谁也不用劝

女人失败时，眼泪汪汪，谁也劝不了

男人恋爱时，凡事不懂也要装逼

女人恋爱时，遇事懂也装作不懂

点评

上述代码算是初步的面向对象编程，但是在“Man”和“Woman”中那些“if-else”判断很复杂，如果再增加“结婚”状态，那需要增加分支判断。

这里我们可以使用访问者模式。

访问者模式

访问者模式，表示一个作用于某对象结构中各元素的操作。它使你可以在不改变各元素的类的前提下，定义作用于这些元素的新操作。[DP]

访问者模式的基本代码如下：

from abc import ABCMeta, abstractmethod

class Visitor():

    """

    Visitor类，为该对象结构中ConcretElement的每一个类声明一个Visit操作。

    """

    __metaclass__ = ABCMeta

    @abstractmethod

    def visit_concret_element_a(self, concret_element_a):

        pass

    @abstractmethod

    def visit_concret_element_b(self, concret_element_b):

        pass

class ConcretVisitor1(Visitor):

    """

    ConcretVisitor类，具体访问者，实现每个由Visitor声明的操作。每个操作实现算法的一部分，

    而该算法片段乃是对应于结构中对象的类。

    """

    def visit_concret_element_a(self, concret_element_a):

        print("Visitor1 visit element A")

    def visit_concret_element_b(self, concret_element_b):

        print("Visitor1 visit element B")

class ConcretVisitor2(Visitor):

    """

    同上

    """

    def visit_concret_element_a(self, concret_element_a):

        print("Visitor2 visit element A")

    def visit_concret_element_b(self, concret_element_b):

        print("Visitor2 visit element B")

class Element():

    """

    Element类，定义一个Accept操作，它以一个访问者为参数

    """

    __metaclass__ = ABCMeta

    @abstractmethod

    def accept(self, visitor):

        pass

class ConcretElementA(Element):

    """

    具体元素类，实现Accept操作

    """

    def accept(self, visitor):

        visitor.visit_concret_element_a(self)

    def other_functions_a(self):

        pass

class ConcretElementB(Element):

    """

    具体元素类，实现Accept操作

    """

    def accept(self, visitor):

        visitor.visit_concret_element_b(self)

    def other_functions_b(self):

        pass

class ObjectStructure():

    """

    ObjectStructure类，能枚举他的元素，可以提供一个高层的接口以允许访问者访问它的元素。

    """

    def __init__(self):

        self.elements = []

    def accept(self, visitor):

        for element in self.elements:

            element.accept(visitor)

def main():

    o = ObjectStructure()

    o.elements.append(ConcretElementA())

    o.elements.append(ConcretElementB())

    v1 = ConcretVisitor1()

    v2 = ConcretVisitor2()

    o.accept(v1)

    o.accept(v2)

main()

Visitor1 visit element A

Visitor1 visit element B

Visitor2 visit element A

Visitor2 visit element B

改进版本——访问者模式

from abc import ABCMeta, abstractmethod

class Action():

    """

    状态抽象类，Visitor类，为该对象结构中ConcretElement的每一个类声明一个Visit操作。

    """

    __metaclass__ = ABCMeta

    @abstractmethod

    def get_man_conclusion(self, man):

        pass

    @abstractmethod

    def get_woman_conclusion(self, woman):

        pass

class Success(Action):

    """

    成功状态类，ConcretVisitor类，具体访问者，实现每个由Visitor声明的操作。每个操作实现算法的一部分，

    而该算法片段乃是对应于结构中对象的类。

    """

    def get_man_conclusion(self, man):

        print("男人成功时，背后多半有一个伟大的女人")

    def get_woman_conclusion(self, woman):

        print("女人成功时，背后多半有一个失败的男人")

class Failing(Action):

    """

    失败状态类，ConcretVisitor类，具体访问者，实现每个由Visitor声明的操作。每个操作实现算法的一部分，

    而该算法片段乃是对应于结构中对象的类。

    """

    def get_man_conclusion(self, man):

        print("男人失败时，闷头喝酒，谁也不用劝")

    def get_woman_conclusion(self, woman):

        print("女人失败时，眼泪汪汪，谁也劝不了")

class Amativeness(Action):

    """

    恋爱状态类，ConcretVisitor类，具体访问者，实现每个由Visitor声明的操作。每个操作实现算法的一部分，

    而该算法片段乃是对应于结构中对象的类。

    """

    def get_man_conclusion(self, man):

        print("男人恋爱时，凡事不懂也要装逼")

    def get_woman_conclusion(self, woman):

        print("女人恋爱时，遇事懂也装作不懂")

class Person():

    """

    人抽象类，Element类，定义一个Accept操作，它以一个访问者为参数

    """

    __metaclass__ = ABCMeta

    @abstractmethod

    def accept(self, visitor):

        pass

class Man(Person):

    """

    男人类，具体元素类，实现Accept操作

    """

    def accept(self, visitor):

        """

        双分派技术：

        第一次分派：首先在客户端程序中将具体状态作为参数传递给“男人”类完成一次分派；

        第二次分派：然后“男人”类调用作为参数的“具体状态”中的方法“男人反应”，同事将自己(self)作为参数传递进去；

        """

        visitor.get_man_conclusion(self)

    def other_functions_a(self):

        pass

class Woman(Person):

    """

    女人类，具体元素类，实现Accept操作

    """

    def accept(self, visitor):

        visitor.get_woman_conclusion(self)

    def other_functions_b(self):

        pass

class ObjectStructure():

    """

    ObjectStructure类，能枚举他的元素，可以提供一个高层的接口以允许访问者访问它的元素。

    """

    def __init__(self):

        self.elements = []

    def accept(self, visitor):

        for element in self.elements:

            element.accept(visitor)

def main():

    o = ObjectStructure()

    o.elements.append(Man())

    o.elements.append(Woman())

    v1 = Success()

    v2 = Failing()

    v3 = Amativeness()

    o.accept(v1)

    print("-"*10)

    o.accept(v2)

    print("-"*10)

    o.accept(v3)

main()

print()

print("由于使用了双分派技术，当新增`结婚`状态时，只需要新增一个状态子类，然后修改客户端即可。")

print()

class Marriage(Action):

    def get_man_conclusion(self, man):

        print("男人结婚时，有妻徒刑遥无期")

    def get_woman_conclusion(self, woman):

        print("女人结婚时，婚姻保险保平安")

def main():

    o = ObjectStructure()

    o.elements.append(Man())

    o.elements.append(Woman())

    v1 = Success()

    v2 = Failing()

    v3 = Amativeness()

    v4 = Marriage()

    o.accept(v1)

    print("-"*10)

    o.accept(v2)

    print("-"*10)

    o.accept(v3)

    print("-"*10)

    o.accept(v4)

main()

男人成功时，背后多半有一个伟大的女人

女人成功时，背后多半有一个失败的男人

----------

男人失败时，闷头喝酒，谁也不用劝

女人失败时，眼泪汪汪，谁也劝不了

----------

男人恋爱时，凡事不懂也要装逼

女人恋爱时，遇事懂也装作不懂

由于使用了双分派技术，当新增`结婚`状态时，只需要新增一个状态子类，然后修改客户端即可。

男人成功时，背后多半有一个伟大的女人

女人成功时，背后多半有一个失败的男人

----------

男人失败时，闷头喝酒，谁也不用劝

女人失败时，眼泪汪汪，谁也劝不了

----------

男人恋爱时，凡事不懂也要装逼

女人恋爱时，遇事懂也装作不懂

----------

男人结婚时，有妻徒刑遥无期

女人结婚时，婚姻保险保平安

点评

访问者模式适用于数据结构相对稳定的系统，它把数据结构和作用于数据结构上的操作之间的耦合解脱开，使得操作结合可以相对*地演化。

访问这模式的目的是要把处理从数据结构分离出来。很多系统可以按照算法和数据结构分开，如果这样的系统有比较稳定的数据结构，又有易于变化的算法的话，那就比较适合使用访问者模式，因为访问者模式使得算法操作的增加变得容易。反之，如果系统的数据结构对象易于变化，经常要有新的数据对象增加进来，就不适合使用访问者模式。

访问者模式的优点就是增加新的操作很容易，因为增加新的操作就意味着增加一个新的访问者。访问者模式将有关的行为集中到一个访问者对象中。

访问者模式的缺点其实就是增加新的数据结构变得困难了。

GoF四人中的一个作者说过，大多数时候并不需要访问者模式，但当一旦需要访问者模式时，那就是真的需要它了。因为我们很难找到数据结构不变化的情况，所以用访问者模式的机会也就不太多。