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

最新推荐文章于 2023-02-21 21:19:46 发布

langb2014

最新推荐文章于 2023-02-21 21:19:46 发布

阅读量778

点赞数

分类专栏： C++设计模式 Python

本文链接：https://blog.csdn.net/langb2014/article/details/54893501

版权

Python 同时被 2 个专栏收录

75 篇文章 4 订阅

订阅专栏

C++设计模式

25 篇文章 1 订阅

订阅专栏

前面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()

abstract_factory.py

#!/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

builder.py

#!/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()

factory_method.py

#!/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()

prototype.py

#!/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

singleton.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]


#Python2
class MyClass(object):
    __metaclass__ = Singleton

if __name__ == '__main__':
    a = MyClass()
    b = MyClass()
    print a == b
    print a is b