程序中设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案，这些解决方案是众多软件按开发人员经过相当长的一段时间的实验和错误总结出来的。使用设计模式是为了重用代码、让代码更容易被他人理解、保证代码的可靠性。

一、单例模式

标题	解释
使用	该模式的目的是确保某一个类只有一个实例存在
适用场景	当一个类只能有一个实例而客户可以从一个众所周知的访问点访问它时
优点	对唯一实例的受控访问,相当于全局变量,但是又可以防止此变量被篡改

class A:
    a = None

    def __new__(cls, *args, **kwargs):
        if cls.a is None:
            cls.a = object.__new__(cls)
        return cls.a

    def __init__(self, name):
        self.name = name

    def __call__(self, *args, **kwargs):
        print(self.name)


if __name__ == '__main__':
    a = A('张三')
    b = A('李四')
    a()
    b()

结果：

图示一下：

二、工厂模式

标题	解释
使用	定义一个创建对象的接口，让子类决定实例化哪个接口
适用场景	需要生产多种,大量复杂对象的时候,需要降低代码耦合度的时候,当系统中的产品类经常需要扩展的时候
优点	每个具体的产品都对应一个具体工厂,不需要修改工厂类的代码,工厂类可以不知道它所创建的具体的类,隐藏了对象创建的实现细节
缺点	每增加一个具体的产品类,就必须增加一个相应的工厂类

代码示例：

class BC:
    def run(self):
        print('奔驰在此')


class AD:
    def run(self):
        print('奥迪在此')


class BMW:
    def run(self):
        print('宝马在此')


class Factory:
    def whatcar(self, name):
        if name == '奔驰':
            return BC()
        elif name == '奥迪':
            ad = AD()
            return ad
        else:
            return BMW()


if __name__ == '__main__':
    a = Factory().whatcar('奔驰').run()
    b = Factory().whatcar('宝马').run()
    c = Factory().whatcar('奥迪').run()

结果：

---

三、策略模式

标题	解释
使用	定义一系列的算法把它们一个个封装起来,并且使它们可相互替换.该模式使得算法可独立于使用它的客户而变化
适用场景:	许多相关的类仅仅是行为有异,需使用一个算法的不同变体,算法使用了客户端无需知道的数据,一个类中的多个行为以多个条件语句存在可以将其封装在不同的策略类中
优点	定义了一系列可重用的算法和行为,消除了一些条件语句,可提供相同行为的不同实现
缺点	客户必须了解不同的策略,策略与上下文之间的通信开销,增加了对象的数目

代码示例：

class c1:
    def go(self):
        return 1


class c2:
    def go(self):
        return 2


if __name__ == '__main__':
    type = int(input('请输入要用的算法(1/2)：'))
    if type == 1:
        print(c1().go())
    elif type == 2:
        print(c2().go())

结果：

---

四、观察者模式

标题	解释
定义:	定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖它的对象都会得到通知并被自动更新.观察者模式又称为’发布订阅’模式
适用场景:	当一个抽象模型有两个方面,其中一个方面依赖于另一个方面，这时候将两者封装在独立的对象中以使它们各自独立的改变和复用 ① 当一个对象的改变需要同时改变其他对象,而且不知道具体有多少对象以待改变 ②当一个对象必须通知其他对象,而又不知道其他对象是谁,即这些对象之间是解耦的
优点:	目标和观察者之间的耦合最小,支持广播通信
缺点：	多个观察者之间互不知道对方的存在,因此一个观察者对主题的修改可能造成错误的更新

class Boss:
    def __init__(self):
        self.observers = []
        self.command = ''

    def attach(self, ob):
        self.observers.append(ob)

    def notify(self):
        for ob in self.observers:
            ob.message()  # 调用对象的update方法


class Employee():
    def __init__(self, name, boss):
        self.name = name
        self.boss = boss

    def message(self):
        print(f'{self.name}，你的老板发来命令：{self.boss.command}')


if __name__ == '__main__':
    boss = Boss()
    zs = Employee('张三', boss)
    boss.attach(zs)
    boss.command = '你被开除了'
    boss.notify()

结果：