python的几种设计模式

1.单例模式

#第一种，重写__new__方法
class Singleton(object):
    _instance = None
    
    def __new__(cls,*args,**kwargs):
        if cls._instance is None:
            cls._instance = object.__new__(cls,*args,**kwargs)
        return cls._instance
    
if __name__ == '__main__':
    #构建3个实例
    instance1 = Singleton()
    instance2 = Singleton()
    instance3 = Singleton()
     
    #打印实例的内存地址
    print(id(instance1))
    print(id(instance2))
    print(id(instance3))

输出结果：

#第二种方法：闭包定义装饰器，将类的定义隐藏到闭包函数中
def singleton(cls):
    '''
        定义单例的装饰器（闭包）
        :param cls
        :return
    '''
    _instance = {}
    
    def _singleton(*args,**kwargs):
        if cls not in _instance:
            _instance[cls] = cls(*args,**kwargs)
        return _instance[cls]
    
    return _singleton

@singleton
class Singleton(object):
    '''
    单例模式
    '''
    def __init__(self,arg1):
        self.arg1 = arg1
    
    
if __name__ == "__main__":
    instance1 = Singleton("caicai")
    instance2 = Singleton("zhuzhu")
    
    print(id(instance1))
    print(id(instance2))

输出结果：

# 注意：上面两种方式创建的单例并不适用于多线程
import threading


class Singleton(object):
    """
        实例化一个对象
    """

    _instance_lock = threading.Lock()

    def __init__(self):
        pass

    def __new__(cls, *args, **kwargs):
        if not hasattr(Singleton, "_instance"):
            with Singleton._instance_lock:
                if not hasattr(Singleton, "_instance"):
                    Singleton._instance = object.__new__(cls)
        return Singleton._instance


def task(arg):
    instance = Singleton()
    print(id(instance), '\n')


if __name__ == "__main__":
    # 3个线程
    for i in range(3):
        t = threading.Thread(target=task, args=[i,])
        t.start()

输出结果：

2.工厂模式：简单工厂、工厂方法、抽象工厂

#第一种，简单工厂

#定义3种水果
class Apple(object):
    """苹果"""
    def __repr__(self):
        return "苹果"

class Banana(object):
    """香蕉"""
    def __repr__(self):
        return "香蕉"

class Orange(object):
    """橘子"""
    def __repr__(self):
        return "橘子"
    
class FactorSimple(object):
    """简单工厂模式"""
    
    @staticmethod
    def get_fruit(fruit_name):
        if 'a'==fruit_name:
            return Apple()
        elif 'b'==fruit_name:
            return Banana()
        elif 'o'==fruit_name:
            return Orange()
        else:
            return "没有这种水果"

if __name__ =="__main__":
    
    instance_apple = FactorSimple.get_fruit('a')
    instance_banana = FactorSimple.get_fruit('b')
    instance_orange = FactorSimple.get_fruit('o')
    print(instance_apple,instance_banana,instance_orange)

输出结果：

第二种：工厂方法

先把以下三个水果类放在一个与主函数文件在同一个文件夹下，即同一个父路径，并命名为fruit.py

#定义3种水果
class Apple(object):
    """苹果"""
    def __repr__(self):
        return "苹果"

class Banana(object):
    """香蕉"""
    def __repr__(self):
        return "香蕉"

class Orange(object):
    """橘子"""
    def __repr__(self):
        return "橘子"

然后执行以下主函数程序

#工厂方法将创建对象的工作让相应的工厂子类去实现，保证在新增工厂类时，不用修改原有代码
#首先创建一个抽象公共工厂类，并定义一个生产对象的方法
import abc
from fruit import *


class AbstractFactory(object):
    """抽象工厂"""
    __metaclass__ = abc.ABCMeta

    @abc.abstractmethod
    def get_fruit(self):
        pass


class AppleFactory(AbstractFactory):
    """生产苹果"""

    def get_fruit(self):
        return Apple()


class BananaFactory(AbstractFactory):
    """生产香蕉"""

    def get_fruit(self):
        return Banana()


class OrangeFactory(AbstractFactory):
    """生产橘子"""

    def get_fruit(self):
        return Orange()


if __name__ == "__main__":
    # 每个工厂负责生产自己的产品也避免了我们在新增产品时需要修改工厂的代码，而只要增加相应的工厂即可
    instance_apple = AppleFactory().get_fruit()
    instance_banana = BananaFactory().get_fruit()
    instance_orange = OrangeFactory().get_fruit()

    print(instance_apple)
    print(instance_banana)
    print(instance_orange)

输出结果：

第三种：抽象工厂

import abc

# 如果一个工厂要生产多个产品，使用工厂方法的话，就需要编写很多工厂类，不太实用，使用抽象工厂就可以很好的解决这个问题

class MaoXW_CC(object):
    """川菜-毛血旺"""

    def __str__(self):
        return "川菜-毛血旺"


class XiaoCR_CC(object):
    """川菜-小炒肉"""

    def __str__(self):
        return "川菜-小炒肉"


class MaoXW_XC(object):
    """湘菜-毛血旺"""

    def __str__(self):
        return "湘菜-毛血旺"


class XiaoCR_XC(object):
    """湘菜-小炒肉"""

    def __str__(self):
        return "湘菜-小炒肉"


# 定义一个抽象工厂类，内部定义两个方法，可以生成毛血旺和小炒肉
class AbstractFactory(object):
    """
    抽象工厂
    既可以生产毛血旺，也可以生成小炒肉
    """
    __metaclass__ = abc.ABCMeta

    @abc.abstractmethod
    def product_maoxw(self):
        pass

    @abc.abstractmethod
    def product_xiaocr(self):
        pass


# 创建抽象工厂类的两个子类，川菜工厂和湘菜工厂，重写方法，然后创建对应的实例对象返回
class CCFactory(AbstractFactory):
    """川菜馆"""

    def product_maoxw(self):
        return MaoXW_CC()

    def product_xiaocr(self):
        return XiaoCR_CC()


class XCFactory(AbstractFactory):
    """湘菜馆"""

    def product_maoxw(self):
        return MaoXW_XC()

    def product_xiaocr(self):
        return XiaoCR_XC()


if __name__ == '__main__':
    # 川菜炒两个菜，分别是：毛血旺和小炒肉
    maoxw_cc = CCFactory().product_maoxw()
    xiaocr_cc = CCFactory().product_xiaocr()

    print(maoxw_cc, xiaocr_cc)

    maoxw_xc = XCFactory().product_maoxw()
    xiaocr_xc = XCFactory().product_xiaocr()

    print(maoxw_xc, xiaocr_xc)

输出结果：

3.构建者模式

"""
构建者模式
是将一个复杂对象的构造与表现进行分离，利用多个步骤进行创建，同一个构建过程可用于创建多个不同的表现
简单来说，就是将一个复杂对象实例化的过程，按照自己的想法，一步步设置参数，定制一个我们需要的对象
构建者模式一般由 Director（指挥官）和 Builder（建设者）构成
Builder 用于定义目标对象部件的方法和参数
Director 用于构造一个 Builder 的接口，由 Director 去指导 Builder 生成一个复杂的对象
以购买一辆车（ 包含：准备钱、看车、试驾、购买 4 个步骤）为例

"""
from time import sleep

#首先，定义一个车的实体，并定义属性变量
class Car(object):
    def __init__(self):
        # 准备的钱
        self.money = None

        # 去哪里看车
        self.address = None

        # 试驾什么车
        self.car_name = None

        # 购买时间是
        self.buy_time = None
    def __str__(self):
        return "准备了：%s,去%s看车，试驾了%s,下单了，购买时间是：%s" % (self.money, self.address, self.car_name, self.buy_time)
    
#创建一个 Builder，实例化一个 Car 对象
class CarBuilder(object):
    def __init__(self):
        self.car = Car()

    def ready_money(self, money):
        """
        准备的金额
        :param money:
        :return:
        """
        self.car.money = money
        sleep(0.5)
        return self

    def see_car(self, address):
        """
        去哪里看车
        :param address:
        :return:
        """
        self.car.address = address
        sleep(0.5)
        return self

    def test_drive(self, car_name):
        """
        试驾了什么车
        :param car_name:
        :return:
        """
        self.car.car_name = car_name
        sleep(0.5)
        return self

    def buy_car(self, buy_time):
        """
        下单时间
        :param buy_time:
        :return:
        """
        self.car.buy_time = buy_time
        sleep(0.5)
        return self
    
#创建 Director，创建 build 方法，使用 Builder 一步步构建一个车对象并返回
class Director(object):
    def __init__(self):
        self.builder = None

    def build(self, builder):
        self.builder = builder
        self.builder. \
            ready_money("30万"). \
            see_car("4S店"). \
            test_drive("奥迪A4L"). \
            buy_car("2022年8月1日")

        # 返回构建的对象
        return self.builder.car
    
if __name__ == '__main__':
    # 实例化一个构建者对象
    car_builder = CarBuilder()
    # 实例化一个负责人
    director = Director()

    # 构建的对象
    car = director.build(car_builder)

    print(car)

输出结果：

4.代理模式：

"""
代理模式，会引入一个代理对象以代替真实的对象，解耦调用方和被调用方之间的联系
"""

#首先，我们定义一个真实对象实体类，并定义一个方法
class RealObject(object):
    """
    实际对象
    """
    def __init__(self, arg):
        self.arg = arg

    def foo(self):
        print('参数值为:', self.arg)
        
#创建一个代理对象，在初始化函数 __init__ 中拿到真实对象的实例，定义一个相同的方法，并调用真实对象的方法
class ProxyObject(object):
    """
    代理对象
    """
    def __init__(self, real_object):
        self.real_object = real_object

    def foo(self):
        # 实际对象调用
        self.real_object.foo()
        
if __name__ == '__main__':
    # 实例化代理对象
    proxy_object = ProxyObject(RealObject('塔塔的守护者'))
    # 调用方法
    proxy_object.foo()

输出结果：

5.观察者模式：

"""
会定义了对象之间的一对多依赖关系，当被观察者（也称为主体对象）改变状态时，其他所有观察者都会收到事件并处理预定的事情
"""

#首先，我们创建一个观察者，在初始化函数中注册到被观察对象上，并且自定义一个更新函数
class Observer(object):

    def __init__(self, subject):
        # 初始化观察者，并注册
        #subject为被观察对象
        subject.register(self)

    def update(self, arg1):
        """获取通知"""
        print('观察者收到监听消息，参数为：', arg1)
        
#然后，新建一个被观察对象，创建注册观察者、注销观察者方法
class Subject(object):

    def __init__(self):
        # 所有的观察者
        self.observers = []
        self.foo = None

    def register(self, observer):
        """添加观察者"""
        if observer not in self.observers:
            self.observers.append(observer)
        else:
            print('已经存在，添加失败！')

    def unregister(self, observer):
        """注销观察者"""
        try:
            self.observers.remove(observer)
        except ValueError:
            print('注销观察者失败')
            
    #接着，通过模拟修改变量的值，通知给所有的观察者
    def notify(self):
        """通知所有的观察者"""
        for item in self.observers:
            item.update(self.foo)

    def modify_value(self):
       """
       修改变量的值
       :return:
       """
       self.foo = "你好，Lolita"

       # 修改后，通知所有观察者
       self.notify()
        
if __name__ == '__main__':
    # 主体对象
    subject = Subject()
    # 观察者
    observer1 = Observer(subject)
    observer2 = Observer(subject)
    observer3 = Observer(subject)
    # 测试
    subject.modify_value()

 输出结果：

 

 

最后感谢微信号AirPython的分享！