Python作为最热门的语言，使我们每个人应该学习的一门技术！
本文针对初学者，我会用最容易的方式告诉你如何入门python！

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

一、单例模式

• 单例模式是种常用的软件设计模式，该模式的目的是确保某一个类只有一个实例存在！
• 适用场景:当一个类只能有一个实例而客户可以从一个众所周知的访问点访问它时
• 优点:对唯一实例的受控访问,相当于全局变量,但是又可以防止此变量被篡改

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)


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():
    @staticmethod
    def whatcar(name):
        if name == '奔驰':
            return BC()  # 返回对应车的一个对象
        elif name == '奥迪':
            ad = AD()
            return ad
        else:
            return BMW()


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

结果：

三、策略模式

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

#===============用策略模式创建一个手动选择优惠方式付钱的实例
class CashNorm():#原价
    def accept_mpney(self,money):
        return money
class Cash_rate():#打折
    def __init__(self,rate):
        self.rate=rate
    def accept_money(self,money):
        return self.rate*money
class Cash_condition():#满减
    def __init__(self,condition,ret):
        self.condition=condition
        self.ret=ret
    def accept_money(self,money):
        if money2:
            style=0
        money=float(input('请输入金额：'))
        print(a[style].getResult(money))

结果：

四、观察者模式

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

class Boss():
    def __init__(self):
        self.observers=[]#observers观察者的意思
        self.status=''
    def attach(self,ob):#attach追加的意思
        self.observers.append(ob)#添加一个对象进入列表
    def notify(self):
        for ob in self.observers:
            ob.update()#调用对象的update方法
class Employee():
    def __init__(self,name,boss):
        self.name=name
        self.boss=boss
    def update(self):#创造方法来发话
        print('{}{}不要再玩游戏了，赶快工作！'.format(self.boss.status,self.name))

if __name__=='__main__':
    ljc=Boss()
    zs=Employee('张三',ljc)
    ljc.attach(zs)
    ljc.status='李嘉诚回来了'
    ljc.notify()

结果：