python重温设计模式===>创建型

前面c++粗略学习过一次，忘记了，现在回想回想。

Github:https://github.com/faif/python-patterns

simple_factory.py

#!/usr/bin/env python# encoding: utf-8"""简单工厂模式增加操作:    1. 增加对应子类    2. 修改工厂类"""class Operation(object):    @PRoperty    def number_a(self):        return self.__number_a    @number_a.setter    def number_a(self, value):        self.__number_a = value    @property    def number_b(self):        return self.__number_b    @number_b.setter    def number_b(self, value):        self.__number_b = valueclass OperationAdd(Operation):    def get_result(self):        return self.number_a + self.number_bclass OperationSub(Operation):    def get_result(self):        return self.number_a - self.number_bclass OperationFactory(object):    @staticmethod    def create_operation(operate):        if operate == "+":            return OperationAdd()        elif operate == "-":            return OperationSub()if __name__ == '__main__':    op = OperationFactory.create_operation('+')    op.number_a = 10    op.number_b = 5    print op.get_result()abstract_factory.py
#!/usr/bin/env python# encoding: utf-8"""抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口, 而无需指定他们具体的类- 优点: 易于交换产品, 具体工厂配置不同的产品- 优点: 让具体的创建实例过程与客户端分离, 客户端是通过它们的抽象接口操纵实例, 产品的具体类名也被具体工厂的实现分离, 不会出现在客户端的代码中"""from abc import ABCMeta, abstractmethodclass AbstractProductA(object):    """    抽象产品, 可能拥有多种实现    """    def __init__(self, name):        self.name = name    def __str__(self):        return "ProductA: %s" % self.nameclass ConcreteProductA1(AbstractProductA):    passclass ConcreteProductA2(AbstractProductA):    passclass AbstractProductB(object):    """    抽象产品, 可能拥有多种实现    """    def __init__(self, name):        self.name = name    def __str__(self):        return "ProductB: %s" % self.nameclass ConcreteProductB1(AbstractProductB):    passclass ConcreteProductB2(AbstractProductB):    passclass AbstractFactory(object):    """    抽象工厂接口, 包含所有产品创建的抽象方法    """    __metaclass__ = ABCMeta    @abstractmethod    def create_product_a(self):        pass    @abstractmethod    def create_product_b(self):        passclass ConcreteFactory1(AbstractFactory):    """    具体工厂, 创建具有特定实现的产品对象    """    def create_product_a(self):        return ConcreteProductA1("PA1")    def create_product_b(self):        return ConcreteProductB1("PB1")class ConcreteFactory2(AbstractFactory):    def create_product_a(self):        return ConcreteProductA2("PA2")    def create_product_b(self):        return ConcreteProductB2("PB2")if __name__ == '__main__':    factory = ConcreteFactory2()    product_a = factory.create_product_a()    print product_abuilder.py
#!/usr/bin/env python# encoding: utf-8"""建造者模式将一个复杂对象的构建与它的表示分离, 使得同样的构建过程可以创建不同的表示- 用户只需指定需要建造的类型, 不需要知道具体地建造过程和细节- 建造者模式是在当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时适用的模式"""from abc import ABCMeta, abstractmethodclass Product(object):    """    具体产品    """    def __init__(self):        self.__parts = []    def add(self, part):        self.__parts.append(part)    def show(self):        print '-'.join(self.__parts)class Builder(object):    """    为创建一个product对象的各个部件指定的抽象接口    """    __metaclass__ = ABCMeta    @abstractmethod    def build_part_1(self):        pass    @abstractmethod    def build_part_2(self):        pass    @abstractmethod    def get_result(self):        passclass BuilderA(Builder):    def __init__(self):        self.__product = Product()    def build_part_1(self):        self.__product.add("partA1")    def build_part_2(self):        self.__product.add("partA2")    def get_result(self):        return self.__productclass BuilderB(Builder):    def __init__(self):        self.__product = Product()    def build_part_1(self):        self.__product.add("partB1")    def build_part_2(self):        self.__product.add("partB2")    def get_result(self):        return self.__productclass Director(object):    @staticmethod    def construct(builder):        builder.build_part_1()        builder.build_part_2()if __name__ == '__main__':    ba = BuilderA()    bb = BuilderB()    Director.construct(ba)    product = ba.get_result()    product.show()    Director.construct(bb)    product = bb.get_result()    product.show()factory_method.py
#!/usr/bin/env python# encoding: utf-8"""工厂方法定义一个用于创建对象的接口, 让子类决定实例化哪个类工厂方法使一个类的实例化延迟到其子类如果存在变更, 改creator即可"""from abc import ABCMeta, abstractmethodclass Product(object):    """    定义工厂方法所创建的对象接口    """    __metaclass__ = ABCMeta    @abstractmethod    def echo(self):        passclass ConcreteProductA(Product):    """    具体的产品, 实现了product的接口    """    def echo(self):        print "product A"class ConcreteProductB(Product):    """    具体的产品, 实现了product的接口    """    def echo(self):        print "product B"class Creator(object):    """    声明了工厂方法, 该方法返回一个Product类型的对象    """    __metaclass__ = ABCMeta    @abstractmethod    def create(self):        passclass ConcreteCreatorA(Creator):    """    重定义, 返回一个ConcreteProduct实例    """    def create(self):        return ConcreteProductA()class ConcreteCreatorB(Creator):    def create(self):        return ConcreteProductB()if __name__ == '__main__':    factory_a = ConcreteCreatorA()    product = factory_a.create()    product.echo()    factory_b = ConcreteCreatorB()    product = factory_b.create()    product.echo()prototype.py
#!/usr/bin/env python# encoding: utf-8"""原型模式用原型实例指定创建对象的种类, 并且通过拷贝这些原型创建新的对象- 原型模型其实是从一个对象再创建另外一个可定制的对象, 而且不需要知道任何创建细节- 一般在初始化信息不发生变化的情况下, 克隆是最好的办法, 既隐藏了对象创建的细节, 有提高了性能"""import copyfrom abc import ABCMeta, abstractmethodclass Prototype(object):    """    原型类, 声明一个克隆自身的接口    """    __metaclass__ = ABCMeta    def __init__(self, id):        self.__id = id    @property    def id(self):        return self.__id    @id.setter    def id(self, value):        self.__id = value    @abstractmethod    def clone(self):        passclass ConcretePrototypeA(Prototype):    """    具体原型类, 实现一个克隆自身的操作    """    def clone(self):        # 浅拷贝        return copy.copy(self)class ConcretePrototypeB(Prototype):    """    具体原型类, 实现一个克隆自身的操作    """    def clone(self):        return copy.copy(self)if __name__ == '__main__':    ca = ConcretePrototypeA(1)    c2 = ca.clone()    print c2.idsingleton.py
#!/usr/bin/env python# encoding: utf-8"""单例模式保证一个类仅有一个实例, 并提供一个访问他的全局访问点TODO: 如果是多线程, 要考虑加锁"""class Singleton(type):    _instances = {}    def __call__(cls, *args, **kwargs):        if cls not in cls._instances:            cls._instances[cls] = super(Singleton, cls).__call__(*args, **                                                                 kwargs)        return cls._instances[cls]#Python2class MyClass(object):    __metaclass__ = Singletonif __name__ == '__main__':    a = MyClass()    b = MyClass()    print a == b    print a is b