04：设计模式

算法其他篇

目录：

• 1.1 单例模式（只能创建一个对象）
• 1.2 简单工厂模式
• 1.3 工厂方法模式
• 1.4 抽象工厂模式（解决多类产品）

1.1 单例模式（只能创建一个对象）     返回顶部

　　1、单例模式介绍

　　　　　　1. 内容：保证一个类只有一个实例，并提供一个访问他的全局访问点
　　　　　　2. 使用场景：当类只能有一个实例而且客户可以从一个总所周知的访问点访问他
　　　　　　3. 例： 比如Test是一个类，你创建两个对象a=Test(), b=Test()在单例模式下a,b两个对象相同
　　　　　　4. 优点：
　　　　　　　　1、 对唯一实例的受控访问（比如写日志时的日志句柄）
　　　　　　　　2、 单例模式相当于全局变量，单例模式防止了命名空间被污染

from abc import abstractmethod, ABCMeta

class Singleton(object):
    def __new__(cls, *args, **kwargs):           #new方法最后返回的是一个实例
        if not hasattr(cls, "_instance"):       #如果没有这个字段就调用父类创建
            cls._instance = super(Singleton, cls).__new__(cls)
        return cls._instance                     #永远返回的就是第一次创建的对象

class MyClass(Singleton):
    def __init__(self, name=None):
        if name:        #如果不传参数就不必赋值
            self.name = name
a = MyClass("a")        #第一次创建对象时传入的是"a",所以a.name=a
print(a)
print(a.name)

b = MyClass('b')       #第二次创建对象时传入的是"b"，所以将name改成了b,所以b.name=b
print(b)
print(b.name)

print(a)                #在b创建实例化后name值已经改成了b所以 a.name=b
print(a.name)

# 注：可以看到实例a和b内存地址相同时一个实例
# <__main__.MyClass object at 0x00FBACB0>
# a
# <__main__.MyClass object at 0x00FBACB0>
# b
# <__main__.MyClass object at 0x00FBACB0>
# b

1.2 简单工厂模式     返回顶部

　　内容：不直接向客户端（创建的对象）暴露对象创建的细节，而是通过一个工厂类来负责创建各种类的实例
　　优点：
　　　　　　1、 隐藏了对象创建的实现细节
　　　　　　2、 客户端不需要修改代码
　　缺点：
　　　　　　1、 违反了单一职责原则，将创建逻辑集中到一个工厂类里
　　　　　　2、 当添加一个新产品时，需要修改工厂类代码，违法了开闭原则

from abc import abstractmethod, ABCMeta

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

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

    def pay(self, money):
        if self.enable_yuebao:
            print("余额宝支付%s元" % money)
        else:
            print("支付宝支付%s元" % money)

class ApplePay(Payment):
    def pay(self, money):
        print("苹果支付%s元" % money)

#作用：用户在创建对象时不必关心需要传递那些参数
class PaymentFactory:
    def create_payment(self, method):
        if method == "alipay":
            return Alipay()
        elif method == "yuebao":
            return Alipay(True)
        elif method == "applepay":
            return ApplePay()
        else:
            raise NameError(method)

f = PaymentFactory()
p = f.create_payment("alipay")    #创建一个Alipay对象，这里创建对象时不必关心需要传递那些参数
p.pay(100)

1.3 工厂方法模式     返回顶部

　　内容：定义一个用于创建对象的接口（工厂接口），让子类决定实例化那个参品类
　　角色：
　　　　　　1、 抽象工厂角色；
　　　　　　2、 具体工厂角色；
　　　　　　3、 抽象产品角色；
　　　　　　4、 具体产品角色；
　　　　　　特点：工厂方法模式相比简单工厂模式将每个具体参品都对应了一个具体工厂

　　适用场景：
　　　　　　1、 需要生产多种、大量复杂对象得时候
　　　　　　2、 需要降低耦合度的时候
　　　　　　3、 当系统中的参品类需要经常扩展的时候
　　优点：
　　　　　　1、 每个具体产品都对应一个具体工厂类，不需要修改工厂类代码
　　　　　　2、 隐藏了对象创建的实现细节
　　缺点：
　　　　　　每增加一个具体的产品类，就必须增加一个对应的具体工厂类

from abc import abstractmethod, ABCMeta
class Payment(metaclass=ABCMeta):        #
    @abstractmethod
    def pay(self, money):
        pass
class Alipay(Payment):
    def pay(self, money):
        print("支付宝支付%s元" % money)
class ApplePay(Payment):
    def pay(self, money):
        print("苹果支付%s元"%money)

class PaymentFactory(metaclass=ABCMeta):
    @abstractmethod
    def create_payment(self):
        pass
class AlipayFactory(PaymentFactory):
    def create_payment(self):
        return Alipay()
class ApplePayFactory(PaymentFactory):
    def create_payment(self):
        return ApplePay()

af = AlipayFactory()
ali = af.create_payment()
ali.pay(120)

1.4 抽象工厂模式（解决多类产品）     返回顶部

　　内容： 定义一个工厂接口，让工厂子类来创建一系列相关或相互依赖的对象
　　例： 生产一部手机，需要手机壳，CPU，操作系统三类对象进行组装，其中每类对象都有不同的种类。
　　　　   对每个具体工厂分别生产一部手机所需要的三个对象
　　特点：相比工厂方法模式，抽象工厂模式中的每个具体工厂都生产一套产品

　　适用场景： 强调一系类相关的产品对象得设计以便进行联合使用时
　　优点：
　　　　　　1、 将客户端与具体类的实现相分离
　　　　　　2、 每个工厂创建了一个完整的产品系列，使得易于交换产品系列
　　　　　　3、 有利于产品的一致性（即：产品间的约束关系）
　　缺点： 难以支持新种类的（抽象）产品

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 PhoneFactory(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 AppleShell(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 AppleCPU(CPU):
    def show_cpu(self):
        print("苹果CPU")

class Android(OS):
    def show_os(self):
        print("Android系统")

class IOS(OS):
    def show_os(self):
        print("iOS系统")

# ------具体工厂------
class MiFactory(PhoneFactory):
    def make_cpu(self):
        return SnapDragonCPU()
    def make_os(self):
        return Android()
    def make_shell(self):
        return BigShell()

class HuaweiFactory(PhoneFactory):
    def make_cpu(self):
        return MediaTekCPU()
    def make_os(self):
        return Android()
    def make_shell(self):
        return SmallShell()

class IPhoneFactory(PhoneFactory):
    def make_cpu(self):
        return AppleCPU()
    def make_os(self):
        return IOS()
    def make_shell(self):
        return AppleShell()

# ------客户端------
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)

p1 = make_phone(IPhoneFactory())
p1.show_info()

# 手机信息:
# 苹果CPU
# iOS系统
# 苹果手机壳