【设计模式·Python】创建型模式

设计模式中，创建型模式主要由以下几种：

• 工厂方法模式
• 抽象工厂模式
• 建造者模式
• 原型模式
• 单例模式

简单工厂模式

• 不直接向客户暴露对象的实现细节，而是通过一个工厂类来负责创建产品的实例。
• 角色：
  工厂角色（Creator）
  抽象产品角色（Product）
  具体产品角色（Concrete Product）

# class Payment:
#     def pay(self, money):
#         raise NotImplementedError

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:
    @staticmethod
    def create_payment(method):
        if method == 'alipay':
            return Alipay()
        elif method == 'huabei':
            return Alipay(use_huabei=True)
        elif method == 'wechat':
            return WechatPay()
        else:
            raise TypeError("No such payment named %s" % method)


# client
pf = PaymentFactory()
pm = pf.create_payment('huabei')
pm.pay(300)

工厂方法模式

• 定义一个用于创建对象的接口（工厂接口），让子类决定实例化哪一个产品类。
• 角色：
  抽象工厂角色（Creator）
  具体工厂角色（Concrete Creator）
  抽象产品角色（Product）
  具体产品角色（Contrete Product）

# class Payment:
#     def pay(self, money):
#         raise NotImplementedError

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 YinlianPay(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 WechatFactory(PaymentFactory):
    def create_payment(self):
        return WechatPay()


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


class YinlianFactory(PaymentFactory):
    def create_payment(self):
        return YinlianPay()


# client
pf = YinlianFactory()
pm = pf.create_payment()
pm.pay(300)

抽象工厂模式：

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

from abc import abstractmethod, ABCMeta


# --- 抽象产品
class PhoneShell(metaclass=ABCMeta):
    @abstractmethod
    def show_shell(self):
        pass


class CPU(metaclass=ABCMeta):
    @abstractmethod
    def show_cpu(self):
        pass


class OS(metaclass=ABCMeta):
    @abstractmethod
    def show_os(self):
        pass


# ---- 抽象工厂
class Phone_Factory(metaclass=ABCMeta):
    @abstractmethod
    def make_shell(self):
        pass

    @abstractmethod
    def make_cpu(self):
        pass

    @abstractmethod
    def make_os(self):
        pass


# ----  具体产品
class SmallShell(PhoneShell):
    def show_shell(self):
        print("普通手机小手机壳")


class BigShell(PhoneShell):
    def show_shell(self):
        print("普通手机大手机壳")


class AplShell(PhoneShell):
    def show_shell(self):
        print("苹果手机壳")


class SnapDragonCPU(CPU):
    def show_cpu(self):
        print("骁龙CPU")


class MediaTekCPU(CPU):
    def show_cpu(self):
        print("联发科CPU")


class AplCPU(CPU):
    def show_cpu(self):
        print("苹果CPU")


class AndrodOS(OS):
    def show_os(self):
        print("安卓系统")


class AplOS(OS):
    def show_os(self):
        print("IOS")


# ---- 具体工厂
class IPhoneFactory(Phone_Factory):
    def make_shell(self):
        return AplShell()

    def make_cpu(self):
        return AplCPU()

    def make_os(self):
        return AplOS()


# ---- 客户端
class Phone:
    def __init__(self, cpu, os, shell):
        self.cpu = cpu
        self.os = os
        self.shell = shell

    def show_info(self):
        print("手机信息:")
        self.cpu.show_cpu()
        self.os.show_os()
        self.shell.show_shell()


def make_phone(factory):
    cpu = factory.make_cpu()
    os = factory.make_os()
    shell = factory.make_shell()
    return Phone(cpu, os, shell)


phone = make_phone(IPhoneFactory())
phone.show_info()

建造者模式：

• 将一个复杂对象的构建与他的表示分离，使得同样的构建过程可以创建不同的表示

• 角色：
  抽象建造者（Builder）
  具体建造者（Concrete Builder）
  指挥者（Director）
  产品（Product）

• 建造者模式与抽象工程模式相似，也用来创建复杂对象。主要区别是建造者模式着重一步步构造一个复杂对象，

• 而抽象工厂模式着重于多个系列的产品对象。

# 建造者模式

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 PlayerBuilder(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(PlayerBuilder):
    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 MonsterBuilder(PlayerBuilder):
    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 = MonsterBuilder()
director = PlayerDirector()
p = director.build_player(builder)
print(p)

单例模式：

• 保证一个类只有一个实例，并提供一个访问他的全局访问点。

# 单例模式
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)
print(a)
b = Myclass(20)
print(b)
print(a.a)
print(id(a), id(b))