python单数 python的单例

转载

epeppanda 2023-09-20 17:28:28

文章标签 python单数单例模式 python 装饰器实例化 文章分类 Python 后端开发

在Python中如何实现单例模式

单例模式（Singleton Pattern）：是一种常用的软件设计模式，该模式的主要目的是确保某一个类只有一个实例存在。当你希望在整个系统中，某个类只能出现一个实例时，单例对象就能派上用场。

方法一

实例化一个的对象，要用时直接 import 导如这个对象，而不是再实例化一个，这样就做到了单例模式了，每次都用的是同一个对象。

方法二

我们知道，当我们实例化一个对象时，是先执行了类的 __new__ 方法（我们没写时，默认调用 object.new），实例化对象；然后再执行类的 __init__ 方法，对这个对象进行初始化，所有我们可以基于这个，实现单例模式。

class Count(object):
    def __init__(self):
        print('将对象初始化')

    def __new__(cls, *args, **kwargs):
        print('new一个对象')
        cls.obj = object.__new__(cls)
        return cls.obj

Count()

python单数 python的单例_python单数

从以上结果中我们看到，使用类创建对象时，先自动执行了 new 方法创建对象，然后返回给 init 进行初始化操作。

接下来进行改写。

class Count(object):
    # 设置一个类属性来判断这个类是否实例化过对象
    instance = None

    def __init__(self):
        pass

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

t1 = Count()
t2 = Count()
t3 = Count()
print(t1)
print(t2)
print(t3)

python单数 python的单例_单例模式_02

以上，通过 new 方法内判断是否创建过对象，来实现单例模式，我们实例化三个对象 t1，t2，t3 三个对象内存地址都是一样的，这就说明他们是同一个对象。

方法三

通过装饰器实现单例模式，任意一个类使用了该装饰器就会变成一个单例模式的类。

装饰器是 Python 中非常有特色的语法，用一个函数去装饰另一个函数或类，为其添加额外的能力。通常通过装饰来实现的功能都属横切关注功能，也就是跟正常的业务逻辑没有必然联系，可以动态添加或移除的功能。装饰器可以为代码提供 缓存、代理、上下文环境 等服务，它是对设计模式中代理模式的践行。

装饰器的作用和功能：

引入日志
函数执行时间统计
执行函数前预备处理
执行函数后的清理功能
权限校验等场景
缓存

总的来说，装饰器 wrapper 是一个函数的工厂，他接收一个函数参数，返回的也是一个函数。一般其作用是将原有函数添加上新的一些功能，然后将新的功能更强的函数返回。

def Single_Class(cls):
    instance = {}

    def single(*args, **kwargs):
        if cls not in instance:
            # 如果类没有创建过，那就new一个新的，并保存在字典里
            instance[cls] = cls(*args, **kwargs)
            return instance[cls]
        else:
            return instance[cls]
    return single

@Single_Class
class A():
    pass

t1 = A()
t2 = A()
print(t1)
print(t2)

python单数 python的单例_单例模式_03

以上，我们写了一个装饰器，该装饰器将所有的对象都存储到字典里，如果之前创建过的对象就直接返回，如果没有创建过的对象那就 new 一个，同一个类我们实例化了 t1 和 t2，但是他们的内存地址都是同一个，说明我们已经实现了单例模式的类装饰器。

接下来对上述代码做一些小的改动。

from functools import wraps

def Single_Class(cls):
    instance = {}

    @wraps(cls) # wraps是在装饰器中使用，保留原来函数的属性
    def single(*args, **kwargs):
        if cls not in instance:
            # 如果类没有创建过，那就new一个新的，并保存在字典里
            instance[cls] = cls(*args, **kwargs)
            return instance[cls]
        else:
            return instance[cls]
    return single

@Single_Class
class A():
    pass

在写装饰器的时候，带装饰功能的函数（上面代码中的 single 函数）通常都会用functools模块中的 wraps 再加以装饰，这个装饰器最重要的作用是给被装饰的类或函数动态添加一个 __wrapped__ 属性，这个属性会将被装饰之前的类或函数保留下来，这样在我们不需要装饰功能的时候，可以通过它来取消装饰器，例如可以使用 A = A.__wrapped__ 来取消对 A 类做的单例处理。

需要提醒大家的是：上面的单例并不是线程安全的，如果要做到线程安全，需要对创建对象的代码进行加锁的处理。在 Python 中可以使用 threading 模块的 RLock 对象来提供锁，可以使用锁对象的 acquire 和 release 方法来实现加锁和解锁的操作。当然，更为简便的做法是使用锁对象的 with 上下文语法来进行隐式的加锁和解锁操作。

方法四

使用元类实现单例模式。这个方法和方法二其实思想上是一致的。

class SingletonMeta(type):
    """自定义单例元类"""

    def __init__(cls, *args, **kwargs):
        cls.__instance = None
        super().__init__(*args, **kwargs)  # 继承父类中的__init__

    def __call__(cls, *args, **kwargs):
        if cls.__instance is None:
            cls.__instance = super().__call__(*args, **kwargs)
        return cls.__instance

class President(metaclass=SingletonMeta):
    pass

t1 = President()
t2 = President()
print(t1)
print(t2)

python单数 python的单例_python单数_04

Python 是面向对象的编程语言，在面向对象的世界中，一切皆为对象。对象是通过类来创建的，而类本身也是对象，类这样的对象是通过元类来创建的。我们在定义类时，如果没有给一个类指定父类，那么默认的父类是 object；如果没有给一个类指定元类，那么默认的元类是 type。通过自定义的元类，我们可以改变一个类默认的行为，就如同上面的代码中，我们通过元类的 __call__ 魔术方法，改变了 President 类的构造器那样。

单例模式的优点：