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