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 = value
class OperationAdd(Operation):
def get_result(self):
return self.number_a + self.number_b
class OperationSub(Operation):
def get_result(self):
return self.number_a - self.number_b
class 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()#!/usr/bin/env python
# encoding: utf-8
"""
抽象工厂模式
提供一个创建一系列相关或相互依赖对象的接口, 而无需指定他们具体的类
- 优点: 易于交换产品, 具体工厂配置不同的产品
- 优点: 让具体的创建实例过程与客户端分离, 客户端是通过它们的抽象接口操纵实例, 产品的具体类名也被具体工厂的实现分离, 不会出现在客户端的代码中
"""
from abc import ABCMeta, abstractmethod
class AbstractProductA(object):
"""
抽象产品, 可能拥有多种实现
"""
def __init__(self, name):
self.name = name
def __str__(self):
return "ProductA: %s" % self.name
class ConcreteProductA1(AbstractProductA):
pass
class ConcreteProductA2(AbstractProductA):
pass
class AbstractProductB(object):
"""
抽象产品, 可能拥有多种实现
"""
def __init__(self, name):
self.name = name
def __str__(self):
return "ProductB: %s" % self.name
class ConcreteProductB1(AbstractProductB):
pass
class ConcreteProductB2(AbstractProductB):
pass
class AbstractFactory(object):
"""
抽象工厂接口, 包含所有产品创建的抽象方法
"""
__metaclass__ = ABCMeta
@abstractmethod
def create_product_a(self):
pass
@abstractmethod
def create_product_b(self):
pass
class 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_a#!/usr/bin/env python
# encoding: utf-8
"""
建造者模式
将一个复杂对象的构建与它的表示分离, 使得同样的构建过程可以创建不同的表示
- 用户只需指定需要建造的类型, 不需要知道具体地建造过程和细节
- 建造者模式是在当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时适用的模式
"""
from abc import ABCMeta, abstractmethod
class 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):
pass
class 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.__product
class 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.__product
class 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()#!/usr/bin/env python
# encoding: utf-8
"""
工厂方法
定义一个用于创建对象的接口, 让子类决定实例化哪个类
工厂方法使一个类的实例化延迟到其子类
如果存在变更, 改creator即可
"""
from abc import ABCMeta, abstractmethod
class Product(object):
"""
定义工厂方法所创建的对象接口
"""
__metaclass__ = ABCMeta
@abstractmethod
def echo(self):
pass
class 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):
pass
class 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()#!/usr/bin/env python
# encoding: utf-8
"""
原型模式
用原型实例指定创建对象的种类, 并且通过拷贝这些原型创建新的对象
- 原型模型其实是从一个对象再创建另外一个可定制的对象, 而且不需要知道任何创建细节
- 一般在初始化信息不发生变化的情况下, 克隆是最好的办法, 既隐藏了对象创建的细节, 有提高了性能
"""
import copy
from abc import ABCMeta, abstractmethod
class 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):
pass
class 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.id#!/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]
#Python2
class MyClass(object):
__metaclass__ = Singleton
if __name__ == '__main__':
a = MyClass()
b = MyClass()
print a == b
print a is b