python基础常用的设计模式

1 单例模式

保证只有一个对象。

注意：在python中导入模块就是一种单例模式。

class Sun(object):
    #定义一个变量
    __instance = None

    def __new__(cls, *args, **kwargs):
        if not cls.__instance:
            # 如果__instance还没有值，就给__intance变量赋值
            cls.__instance = object.__new__(cls)
            return cls.__instance
        else:
            #如果__instance有值 ,ze直接返回
            return cls.__instance

sun = Sun()  
print(id(sun))    #12322520
sun1 = Sun()
print(id(sun1))   #12322520

练习 2 优化练习1 的写法

class Sun(object):
    #定义一个变量
    __instance = None

    def __new__(cls, *args, **kwargs):
        if not cls.__instance:
            cls.__instance = object.__new__(cls)
        return cls.__instance

sun = Sun()
print(id(sun))    #12322520
sun1 = Sun()
print(id(sun1))   #12322520

2 工厂模式

工厂模式是一个在软件开发中用来创建对象的设计模式。

当程序运行输入一个“类型”的时候，需要创建于此相应的对象。这就用到了工厂模式。在如此情形中，实现代码基于工厂模式，可以达到可扩展，可维护的代码。当增加一个新的类型，不在需要修改已存在的类，只增加能够产生新类型的子类。

使用工厂模式应用场景：

不知道用户想要创建什么样的对象

练习1 创建 CarFactory 工厂类

一般的思维模式：

class Car(object):
    def run(self):
        print('跑车。。。')
    def stop(self):
        print('停车。。。')

class BMW(Car):
    pass

class Benz(Car):
    pass

class CarStore(object):
    def order(self,name):
        if name == 'BMW':
            return BMW()
        if name == 'Benz':
            return Benz()

car_store = CarStore()
car = car_store.order('BMW')
car.run()
car.stop()

工厂模式 ：

    def run(self):
        print('跑车。。。')
    def stop(self):
        print('停车。。。')

class BMW(Car):
    def run(self):
        print('宝马跑车。。。')
    def stop(self):
        print('宝马停车。。。')

class Benz(Car):
    def run(self):
        print('奔驰跑车。。。')
    def stop(self):
        print('奔驰停车。。。')

class CarFactory():
    def new_car(self,name):
        if name == 'BMW':
            bmw = BMW()
            return  bmw
        if name == 'Benz':
            benz = Benz()
            return benz

class CarStore(object):
    def __init__(self,factory):
        self.factory = factory

    def order(self,name):
        new_car = self.factory.new_car(name)
        return new_car

car_factory = CarFactory()
car_store = CarStore(car_factory)
car = car_store.order('Benz')
car.run()
car.stop()

3 策略模式

策略指的就是为了达到某一目的而采取的多种手段或者方法。

为了实现软件设计，对象可能会用到多种多样的算法(逻辑)。这些算法甚至会经常改变。如果将这些算法都硬编码到对象中，将会使得对象本身变得臃肿不堪，

策略模式很好的实现了将算法与本身对象解耦，从而避免出现上述的问题。

因此策略模式可以定义为：　定义一系列算法(逻辑)，将每一个算法封装起来(一个算法创建一个类)，并让它们可以相互替换。此模式让算法的变化,不会影响到使用算法的客户.

练习1：假设某司维护着一些客户资料，需要在该司有新产品上市或者举行新活动时通知客户。

现通知客户的方式有两种：短信通知、邮件通知。应如何设计该系统的客户通知部分？

为解决该问题，我们先构造客户类，包括客户常用的联系方式和基本信息，同时也包括要发送的内容。

#具体发送方式
class PhoneSender(MsgSender):
    def send(self):
        print('给{}打电话说：{}'.format(self.type,self.info))

class EmailSender(MsgSender):
    def send(self):
        print('给{}发邮件说：{}'.format(self.type, self.info))
#用户群体
class Customer(object):
    # def __init__(self,name,phone,email):
    name = ''
    phone = ''
    email = ''

    send_way = None   #发送方式

    def set_send_way(self,send_way):
        self.send_way = send_way

    def send_msg(self):
        self.send_way.send()

if __name__ == '__main__':
    # 创建用户
    customer = Customer()
    customer.name = 'zs'
    customer.phone = '110'
    customer.email = '[email protected]'

    #以电话访问形式发送
    phone_sender = PhoneSender()
    phone_sender.info = '快点呀  造作呀 新品上市了。。'
    phone_sender.type = customer.phone
    
    customer.set_send_way(phone_sender)  # 设置发送方式
    customer.send_msg()  # 发送信息
    
    #创建邮箱发送方式
    email_sender = EmailSender()
    email_sender.info = '欢迎看新产品'
    email_sender.type = customer.email

    customer.set_send_way(email_sender)  # 设置发送方式
    customer.send_msg()