单例模式

只允许一个类只有一个实例。

先了解一下下python 的 init()方法和 new()方法

init不是实例化一个类第一个调用的方法，
第一个调用的方法是new方法，new方法返回一个实例对象，
然后实例对象调用init方法。
new是类级别的方法。
init是实例级别的方法。

class Single:

    _instance = None 

    def __new__(cls, *args, **kwargs):
        if not cls._instance:
            # instance未实例化 
            # object.__new__(cls)
            cls._instance = super().__new__(cls)
        return cls._instance 

s1 = Single()
s2 = Single() 
print(id(s1), id(s2))

简单工厂

隐藏了创建对象的实现细节。哭护短不需要修改代码。
新增对象，需要修改工厂代码。

class Payment(metaclass=ABCMeta):

    @abstractmethod
    def pay(self, money):
        pass 

class WechatPayment(Payment):

    def pay(self, money):
        print("微信支付")

class AliPayment(Payment):

    def pay(self, money):
        print("阿里支付")

class PaymentFactory:

    def create_payment(self, method):

        if method == "ali":
            return AliPayment()
        elif method == "wechat":
            return WechatPayment()

pf = PaymentFactory()
pay = pf.create_payment('ali')
pay.pay(1)

工厂方法模式

一个工厂生产一个产品。 不需要修改工厂类代码。
每增加一个产品，需要增加一个工厂。

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

class WechatFactory(PaymentFactory):
    def create_payment(self):
        return WechatPayment() 

抽象工厂模式

定义一个工厂类接口，让工厂类子类创建一系列相关或者相互依赖的对象。

抽象工厂模式中，每个具体工厂都生产一套产品。

 # 抽象产品
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 PhoneFactory(metaclass=ABCMeta):

    @abstractmethod
    def make_shell(self):
        pass 

    @abstractmethod
    def make_cpu(self):
        pass 
    
    @abstractmethod
    def make_os(self):
        pass 

# 具体产品
class AppleShell(PhoneShell):
    def show_shell(self):
        print("苹果手机壳")
class SanShell(PhoneShell):
    def show_shell(self):
        print("三星手机壳")

class DragonCPU(CPU):
    def show_cpu(self):
        print("梦龙CPU")

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

class LinuxOS(OS):
    def show_os(self):
        print("linux os")

class WindowOS(OS):
    def show_os(self):
        print("window os")

# 具体工厂

class LLFactory(PhoneFactory):

    def make_shell(self):
        return AppleShell()

    def make_cpu(self):
        return DragonCPU()

    def make_os(self):
        return WindowOS()

class MMFactory(PhoneFactory):
    
    def make_shell(self):
        return SanShell()

    def make_cpu(self):
        return DragonCPU()

    def make_os(self):
        return LinuxOS()

# 客户端
class Phone:
    def __init__(self, cpu, os, shell):
        self.cpu = cpu 
        self.os = os 
        self.shell = shell 
    
    def show_info(self):
        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)

p1 = make_phone(LLFactory())
p1.show_info() 

建造者模式

将一个复杂对象的构建与它的表示分离。使得同样的构建过程可以创建不同的表示。
和抽象工厂有点像。着重于 顺序， 抽象工厂着重于 系列产品。

• 抽象建造者
• 具体建造者
• 指挥者
• 产品

# 产品
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 self.face + self.body + self.leg + self.arm
# 抽象建造者
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 GirlBuilder(PlayBuilder):

    def __init__(self):
        self.player = Player()

    def build_face(self):
        self.player.face = "女"
    
    def build_body(self):
        self.player.body = "170"
    
    def build_arm(self):
        self.player.arm = "俩个胳膊"
    
    def build_leg(self):
        self.player.leg = "大长腿"

# 指挥者
class PlayerDirector:
    def build_player(self, builder: PlayBuilder):
        builder.build_body()
        builder.build_arm()
        builder.build_face()
        builder.build_leg() 

        return builder.player

builder = GirlBuilder()
director = PlayerDirector()
player = director.build_player(builder)
print(player)