python设计模式（一）创建型模式

创建型模式（5种）：工厂方法模式、抽象工厂模式、创建者模式、原型模式、单例模式

https://www.bilibili.com/video/BV19541167cn?spm_id_from=333.999.0.0

1、面向对象

"""
SOLID原则：
    - 开放封闭原则
    - 里氏替换原则
    - 依赖倒置原则
    - 接口隔离原则
    - 单一职责原则
"""
from abc import ABCMeta, abstractmethod


class Payment(metaclass=ABCMeta):
    # abstract class
    @abstractmethod
    def pay(self, money):
        pass


class Aipay(Payment):
    def pay(self, money):
        print('支付宝支付%d元.' % money)


class WechatPay(Payment):
    def pay(self, money):
        print('微信支付%d元.' % money)


p = Aipay()
p.pay(100)

2、简单工厂模式（不属于23种）

• 简单工厂模式
  • 内容：不直接向客户端暴露创建的实现细节，而是通过一个工厂类来复制创建产品类的实现
  • 角色：
    • 工厂角色
    • 抽象产品角色
    • 具体产品角色
  • 优点：
    • 隐藏了对象创建的实现细节
    • 客户端不需要修改代码
  • 缺点
    • 违反了单一职责原则，将创建逻辑集中到一个工厂类里
    • 当添加新厂品时，需要修改工厂类代码，违反了开闭原则

from abc import ABCMeta, abstractmethod


class Payment(metaclass=ABCMeta):
    # abstract class
    @abstractmethod
    def pay(self, money):
        pass


class Alipay(Payment):
    def __init__(self, use_huabei=False):
        self.use_huabei = use_huabei

    def pay(self, money):
        if self.use_huabei:
            print('花呗支付%d元.' % money)
        else:
            print("支付宝余额支付%d元" % money)


class WechatPay(Payment):
    def pay(self, money):
        print('微信支付%d元.' % money)


class PaymentFactory:
    def create_payment(self, method):
        if method == 'alipay':
            return Alipay()
        elif method == 'wechat':
            return WechatPay()
        elif method == 'huabei':
            return Alipay(use_huabei=True)
        else:
            return TypeError("No such payment named %s" % method)


# client
pf = PaymentFactory()
p = pf.create_payment('huabei')
p.pay(100)

3、工厂方法模式

• 工厂方法模式
  • 内容：定义一个用于创建对象的接口（工厂接口），让子类决定实例化哪一个产品类
  • 角色：
    • 抽象工厂角色
    • 具体工厂角色
    • 抽象产品角色
    • 具体产品角色
  • 优点：
    • 每个具体产品都对应一个具体工厂类，不需要修改工厂类代码
    • 隐藏了对象创建的实现细节
  • 缺点：
    • 每增加一个具体类，就必须增加一个相应的具体工厂类

from abc import ABCMeta, abstractmethod


class Payment(metaclass=ABCMeta):
    # abstract class
    @abstractmethod
    def pay(self, money):
        pass


class Alipay(Payment):
    def __init__(self, use_huabei=False):
        self.use_huabei = use_huabei

    def pay(self, money):
        if self.use_huabei:
            print('花呗支付%d元.' % money)
        else:
            print("支付宝余额支付%d元" % money)


class WechatPay(Payment):
    def pay(self, money):
        print('微信支付%d元.' % money)


class PaymentFactory(metaclass=ABCMeta):
    @abstractmethod
    def create_payment(self):
        pass


class AlipayFactory(PaymentFactory):
    def create_payment(self):
        return Alipay()


class WechatpayFactory(PaymentFactory):
    def create_payment(self):
        return WechatPay()


class HuabeiFactory(PaymentFactory):
    def create_payment(self):
        return Alipay(use_huabei=True)


pf = HuabeiFactory()
p = pf.create_payment()
p.pay(100)

4、抽象工厂模式

• 抽象工厂模式：
  • 内容：定义一个工厂类接口，让工厂子类来创建一系列相关或相互依赖的对象
  • 相比工厂方法模式，抽象工厂模式中的每个具体工厂都生产一套产品
  • 角色：
    • 抽象工厂角色
    • 具体工厂角色
    • 抽象产品角色
    • 具体产品角色

5、建造者模式

• 建造者模式
  • 内容：将一个复杂对象的构建与他的表示分离，使得同样的构建过程可以创建不同的表示
  • 角色：
    • 抽象创建者
    • 具体创建者
    • 指挥者
    • 产品
  • 建造者模式和抽象工厂模式相似，也用来创建复杂对象，主要区别是建造者模式注重一步一步构建一个
    复杂对象，而抽象工厂模式注重多个系列的产品对象

from abc import ABCMeta, abstractmethod


class Player:
    def __init__(self, face=None, body=None, arm=None, leg=None):
        self.face = face
        self.body = body
        self.arm = arm
        self.leg = leg

    def __str__(self):
        return "%s %s %s %s" % (self.face, self.body, self.arm, self.leg)


class PlayBuilder(metaclass=ABCMeta):
    @abstractmethod
    def build_face(self):
        pass

    @abstractmethod
    def build_body(self):
        pass

    @abstractmethod
    def build_arm(self):
        pass

    @abstractmethod
    def build_leg(self):
        pass


class SexyGirlBuilder(PlayBuilder):
    def __init__(self):
        self.player = Player()

    def build_face(self):
        self.player.face = "脸蛋"

    def build_body(self):
        self.player.body = "苗条"

    def build_arm(self):
        self.player.arm = "胳膊"

    def build_leg(self):
        self.player.leg = "大长腿"


class Monster(PlayBuilder):
    def __init__(self):
        self.player = Player()

    def build_face(self):
        self.player.face = "怪兽脸"

    def build_body(self):
        self.player.body = "怪兽身材"

    def build_arm(self):
        self.player.arm = "怪兽胳膊"

    def build_leg(self):
        self.player.leg = "怪兽腿"


class PlayerDirector:  # 控制组装顺序
    def build_player(self, builder):
        builder.build_body()
        builder.build_face()
        builder.build_arm()
        builder.build_leg()
        return builder.player


# client
builder = SexyGirlBuilder()
director = PlayerDirector()
p = director.build_player(builder)

6、单例模式

• 单例模式
  • 内容：保证一个类只有一个实例，并提供一个访问它的全局访问点
  • 角色：单例
  • 优点：
    • 对唯一实例的受控访问
    • 单例相当于全局变量，但防止了命名空间被污染

class Singleton:
    def __new__(cls, *args, **kwargs):
        if not hasattr(cls, "_instance"):
            cls._instance = super(Singleton, cls).__new__(cls)
        return cls._instance


class MyClass(Singleton):
    def __init__(self, a):
        self.a = a


a = MyClass(10)
b = MyClass(20)