Python常用的设计模式

设计模式是软件设计中常见的各种问题的解决方案。每个设计模式系统地命名、解释和评估了面向对象系统中一个重要和重复的设计。

• 分类设计模式 创建模式：工厂方法模式、抽象工厂模式、创建者模式、原型模式、单例模式。隐藏底层模块的逻辑，注意如何创建对象。

结构模式：适配器模式、桥梁模式、组合模式、装饰模式、外观模式、享元模式、代理模式。如何协同工作，应该形成什么结构？。

行为模式：解释器模式、责任链模式、命令模式、迭代模式、中介模式、备忘录模式、观察者模式、状态模式、战略模式、访问者模式、模板方法模式。注意行为，也就是方法，应该怎么做？。

• 面向对象 设计模式解决了面向对象的问题。指导面向对象的三个特征是 包装、继承和多态 ，包装是将数据和方法包装到类中，继承是类之间的复用代码Python中默认支持，Python多态语言。

• 接口 接口是多种抽象方法的集合。接口的作用是限制接口类别的实现，这些方法必须按照接口给定的调用方法实现，类别的内部实现隐藏在高层模块中。以下是一个简单的例子来加强对接口的理解：

from abc import ABCMeta, abstractmethod  # 具有抽象方法的类是接口类， class Payment(metaclass=ABCMeta):     @abstractmethod     def pay(self, money):         """ 在实现的类别中必须实现抽象方法。限制实现接口的类别必须按照接口给定的调用方法实现 :param money: :return: """         pass  # 不能说是继承接口，应该说是实现接口 class Alipay(Payment):     def pay(self, money):         """ 接口类中必须实现的方法 :param money: :return: """         print("支付宝支付{0}元！".format(money))  class WechatPay(Payment):     def pay(self, money):         """ 接口类中必须实现的方法 :param money: :return: """         print("微信支付%%d元!" % (money))  # 以下是高层代码，调用时看不到底层内部实现。 a = Alipay()/span> w = WechatPay() a.pay(100) w.pay(100) 

• 开放封闭原则 一个软件实体如类、模块和函数应该对扩展开放，对修改关闭。即软件实体应该在不修改原代码的情况下进行修改。
• 里氏替换原则 所有引用父类的地方必须能透明地使用其子类的对象，即能调用父类就一定能调用其子类，一个简单的例子加强理解

class User(object):
    def print_name(self):
        pass

class VipUser(User):
    def print_name(self):
        """ 保证参数和返回值类型需要和父类一样 :return: """
        pass
def print_name(u):
    """ 不论使用User还是继承User的VipUser，调用的方式是一样的。这就要求User和VipUser的方法参数和返回值类型是一样的 :param u: :return: """
    u.print_name()
    

# 无论是实现User()还是VipUser()都是可以的
u = User()
# u = VipUser()
print_name(u)

• 依赖倒置原则 高层模块不应该依赖底层模块，二者都应该依赖抽象。抽象不应该依赖细节，细节应该应该依赖抽象。要针对接口编程，而不是针对实现变成。通过例子加强理解：

from abc import ABCMeta, abstractmethod

# 接口，抽象不应该依赖细节
class Payment(metaclass=ABCMeta):
    @abstractmethod
    def pay(self, money):
        pass
        
# 底层代码和高层代码都是细节，细节应该依赖抽象
# 底层代码
class Alipay(Payment):
    def pay(self, money):
        print("支付宝支付了{0}元!".format(money))

class WechatPay(Payment):
    def pay(self, money):
        print("微信支付了%d元!" % (money))

# 高层代码，高层模块不应该依赖底层模块，二者都应该依赖抽象
a = Alipay()
w = WechatPay()
a.pay(100)
w.pay(100)

• 接口隔离原则 使用多个专门的接口，而不使用单一的总结口，高层的代码不应该依赖那些它不需要的接口。通过例子加强理解：

from abc import ABCMeta, abstractmethod

class LandAnimal(metaclass=ABCMeta):
    @abstractmethod
    def walk(self):
        pass

class WaterAnimal(metaclass=ABCMeta):
    @abstractmethod
    def swim(self):
        pass

class SkyAnimal(metaclass=ABCMeta):
    @abstractmethod
    def fly(self):
        pass

# 高层的代码不应该依赖那些它不需要的接口
class Tiger(LandAnimal):
    def walk(self):
        pass

# 高层的代码不应该依赖那些它不需要的接口
class Frog(LandAnimal, WaterAnimal):
    def walk(self):
        pass

• 单一职责原则 不要存在多于一个导致类变更的原因，一个类只负责一项职责，一个类只做一件事。把面向过程的代码放到类中，虽然用到了类，但不是面向对象。

简单工厂模式不是23中设计模式中的，但是必须要知道。简单工厂模式不直接向客户端暴露对象创建的细节，而是通过一个工厂类来负责创建产品类的实例。简单工程模式的角色有：工厂角色（工厂类）、抽象产品角色（接口类）、具体产品角色（实现类）。通过例子来加深理解：

from abc import ABCMeta, abstractmethod


# 抽象产品角色，以什么样的表现去使用
class Payment(metaclass=ABCMeta):
    @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 == True:
            print("花呗支付了{0}元!".format(money))
        else:
            print("支付宝余额支付了{0}元!".format(money))

# 产品角色
class WechatPay(Payment):
    def pay(self, money):
        print("微信支付了%d元!" % (money))

# 工厂类角色
class PaymentFactory:
    def ctreate_payment(self, method):
        if method == 'Alipay':
            return Alipay()
        elif method == 'WechatPay':
            return WechatPay()
        elif method == 'HuabeiPay':
            return Alipay(use_huabei=True)
        else:
            raise TypeError('No such payment named %s' % method)

# 客户端调用。不直接向客户端暴露对象创建的实现细节，而是通过一个工厂类来负责创建产品类的实例
pf = PaymentFactory()
p = pf.ctreate_payment('HuabeiPay')
p.pay(100)

简单工厂模式只创建一个工厂类，当有新的产品时，需要修改工厂类代码。而 工厂方法模式的每个具体产品对应一个具体的工厂类，不需要修改工厂类代码，并且同时也能满足隐藏对象创建的细节。但是工厂方法模式也是有缺点的，就是 每增加一个具体产品类，就必须增加一个相应的具体方法。 工厂模式方法模式的概念是定义了一个用于创建对象的接口(工厂接口)，让子类决定实例化那一个产品类。角色有抽象工厂角色、具体工厂角色、抽象产品角色和具体产品角色。通过例子来加深理解，每个具体产品对应一个具体的工厂类：

from abc import ABCMeta, abstractmethod

# 抽象产品角色
class Payment(metaclass=ABCMeta):
    @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 == True:
            print("花呗支付了{0}元!".format(money))
        else:
            print("支付宝余额支付了{0}元!".format(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 Alipay()

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

hfp = HuabeiFactory().create_payment()
hfp.pay(100)  # 花呗支付了100元!

缺点是每增加一个具体产品类，就必须增加一个相应的具体方法：

from abc import ABCMeta, abstractmethod

class Payment(metaclass=ABCMeta):
    @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 == True:
            print("花呗支付了{0}元!".format(money))
        else:
            print("支付宝余额支付了{0}元!".format(money))

class WechatPay(Payment):
    def pay(self, money):
        print("微信支付了%d元!" % (money))

class BankPay(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 WechatPayPayFactory(PaymentFactory):
    def create_payment(self):
        return Alipay()

# 工厂类
class HuabeiPayFactory(PaymentFactory):
    def create_payment(self):
        return Alipay(use_huabei=True)

# 新增加银行支付的工厂类
class BankPayFactory(PaymentFactory):
    def create_payment(self):
        return BankPay()

bfp = BankPayFactory().create_payment()
bfp.pay(100)  # 银行支付了100元!

抽象工厂模式：定义一个工厂类的接口让工厂子类来创建一系列相关或者相互依赖的对象。相比工厂方法模式，抽象工厂模式中的每一个具体工厂都生产一套产品。下面是生产厂商生产一部手机的例子：生产一部手机如果说只需要手机壳、CPU和操作系统这三个类对象，其中每个类对象都有不同的种类。对每个具体工厂，分别生产一部手机需要的三个对象。通过例子来加深理解：

from abc import ABCMeta, abstractmethod

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

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

class PhoneOS(metaclass=ABCMeta):
    @abstractmethod
    def show_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(PhoneCPU):
    def show_cpu(self):
        print('骁龙CPU')

class HuaweiCPU(PhoneCPU):
    def show_cpu(self):
        print('化为CPU')

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

class AndroidOS(PhoneOS):
    def show_os(self):
        print('IOS系统')

class AppleOS(PhoneOS):
    def show_os(self):
        print('安卓系统')

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

    @abstractmethod
    def make_cpu(self):
        pass

    @abstractmethod
    def make_os(self):
        pass

# ------具体的工厂------
class HuaweiFactory(PhoneFactory):
    def make_shell(self):
        return SmallShell()

    def make_cpu(self):
        return HuaweiCPU()

    def make_os(self):
        return AndroidOS()

class AppleFactory(PhoneFactory):
    def make_shell(self):
        return AppleShell()

    def make_cpu(self):
        return AppleCPU()

    def make_os(self):
        return AppleOS()

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

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

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

p = make_phone(HuaweiFactory())
p.show_info()
""" 手机信息： 普通手机小手机壳 化为CPU IOS系统 """

抽象工厂模式的角色有：抽象工厂角色、具体工厂角色、抽象产品角色、具体产品角色和客户端。抽象工厂模式的优点是：将客户端和类的具体实现相分离；每个工厂创建了一个完整的产品系列，使得易于交换产品系列；有利于产品的一致性，即产品之间的约束关系。缺点是：难以支持新种类抽象产品。

建造者模式是将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。角色有抽象创建者、具体创建者、指挥者和产品。建造者模式与抽象工厂模式相似，也用来创建复杂的对象。主要区别是 建造者模式着重一步步构造一个复杂对象(控制顺序)。而抽象工厂模式着重于多个系列的产品对象，写个例子来加强理解：