Python的四种单例模式实现方式

★ 单例模式基本介绍

单例模式是一种设计模式,用于确保一个类只有一个实例,并提供全局访问点以获取该实例。它是一种创建型模式,通常用于需要严格控制某个类的实例数量的情况。单例模式确保一个类在整个应用程序生命周期中只有一个实例,因此可以节省系统资源,同时提供了一个集中的访问点,以便在需要时获取该实例。

★ 实现单例的几种方式:

  • 模块导入
  • 添加装饰器(类装饰器和函数装饰器)
  • 重写new方法
  • 元类继承

★ 方式一: 模块导入

  • 文件结构
    单例
    ├───file1.py
    ├───file2.py
    ├───readme
    ├───单例实现1_模块导入.py
    └───模块导入实现单例测试.py
    
  • 单例实现1_模块导入.py
    """
    模块导入实现单例模式步骤:
    1. 在模块中定义类
    2. 实例化类并返回
    3. 在其他文件中导入实例对象使用, 每个文件导入的对象实际是同一个
    """
    
    
    class Singleton:
        def __init__(self, name):
            self.name = name
    
        def do_something(self):
            pass
    
    
    singleton = Singleton('模块单例')
    
    # 在其他py文件中
    # from my_singleton import singleton
    
  • file1.py
    from 单例实现1_模块导入 import singleton
    
    print(singleton)
    
  • file2.py
    from 单例实现1_模块导入 import singleton
    
    print(singleton)
    
  • 模块导入实现单例测试.py
    import file1
    import file2
    
    print(file1.singleton is file2.singleton)
    
  • 执行结果
    <单例实现1_模块导入.Singleton object at 0x0000021B2B81F400>
    <单例实现1_模块导入.Singleton object at 0x0000021B2B81F400>
    True
    

★ 方式二: 装饰器

  • 单例实现2_装饰器.py
    # -------------------函数装饰器---------------------------
    def Singleton1(cls):
        instance = {}
    
        def _singleton_wrapper(*args, **kargs):
            if cls not in instance:
                instance[cls] = cls(*args, **kargs)
            return instance[cls]
    
        return _singleton_wrapper
    
    
    # -------------------类装饰器---------------------------
    class Singleton2:
    
        def __init__(self, cls):
            self.cls = cls
            self._instance = None
    
        def __call__(self, *args, **kwargs):
            if not self._instance:
                self._instance = self.cls(*args, **kwargs)
            return self._instance
    
    
    # SingletonTest = Singleton1(SingletonTest) =_singleton_wrapper
    # SingletonTest = Singleton2(SingletonTest) = Singleton2实例对象
    @Singleton1
    class SingletonTest(object):
        def __init__(self, name):
            print(">>> 初始化 <<<")
            self.name = name
    
    
    s1 = SingletonTest('s1')
    s2 = SingletonTest('s2')
    print(s1, s2)
    print(s1 is s2)
    
    
    
  • 执行结果
    >>> 初始化 <<<
    <__main__.SingletonTest object at 0x000001E6A2FF73D0> <__main__.SingletonTest object at 0x000001E6A2FF73D0>
    True
    

★ 方式三: 重写new方法

  • 单例实现3_重写new方法.py
    class Singleton(object):
    
        def __new__(cls, *args, **kwargs):
            if not hasattr(Singleton, "_instance"):
                Singleton._init_flag = True
                Singleton._instance = super().__new__(cls)
            return Singleton._instance
    
        def __init__(self, name):
            if not hasattr(Singleton, "_init"):
                Singleton._init = True
                print(">>> 初始化 <<<")
                self.name = name
    
    
    s1 = Singleton('s1')
    s2 = Singleton('s2')
    print(s1, s2)
    print(s1 is s2)
    
  • 执行结果
    >>> 初始化 <<<
    <__main__.Singleton object at 0x0000016663140760> <__main__.Singleton object at 0x0000016663140760>
    True
    

★ 方式四: 元类继承

  • 单例实现4_元类继承.py
    class Singleton(type):
    
        def __call__(cls, *args, **kwargs):
            if not hasattr(Singleton, "_instance"):
                # cls 是 Singleton 创建的类
                Singleton._instance = cls.__new__(cls, *args, **kwargs)
                cls.__init__(Singleton._instance, *args, **kwargs)
            return Singleton._instance
    
    
    class SingletonTest(metaclass=Singleton):
        pass
    
    
    class A(SingletonTest):
        def __init__(self, name):
            print(">>> 初始化 <<<")
            self.name = name
    
    
    s1 = A('s1')
    s2 = A('s2')
    print(s1, s2)
    print(s1 is s2)
    
  • 执行结果
    >>> 初始化 <<<
    <__main__.A object at 0x000001687C79D5E0> <__main__.A object at 0x000001687C79D5E0>
    True
    

热门相关:学霸你女朋友掉了   美漫之大冬兵   强宠头号鲜妻:陆少,滚!   医门宗师   我在镇夜司打开地狱之门