您现在的位置是：首页 > Python

当前栏目

Python 实现单例

Python 对象

2023-03-02 11:23:05 时间

# Python 实现单例 #

### 文章目录 ###

*  Python 实现单例
 *   *  起步
     *  \_\_new\_\_函数
     *  元类 metaclass
     *  装饰器
     *   *  函数装饰器
         *  类装饰器
     *  方法
     *   *  静态方法 staticmethod
         *  类方法 classsmethod
     *  名字覆盖
     *  属性共享

## 起步 ##

单例模式是一种常用的软件设计模式，用来确保一个类只会有一个实例存在。

以下是 Python 中实现单例模式的多种方法，环境基于 Python3.6.6。

## \_\_new\_\_函数 ##

class Singleton(object):
        _instance = None
    
        def __new__(cls, *args, **kwargs):
            if cls._instance is None:
                cls._instance = super().__new__(cls)
            return cls._instance
    
    # 示例：
    a = Singleton()
    b = Singleton()
    # id(a) == id(b)

每次实例化一个对象时，都会先调用 `__new__()` 创建一个对象，再调用 `__init__()` 函数初始化数据。因而，在 new 函数中判断 Singleton类 是否已经实例化过，如果不是，调用父类的 new 函数创建实例；否则返回之前创建的实例。

**\_instance** 作为类属性，保证了所有对象的 \_instance 都是同一个。

## 元类 metaclass ##

class SingletonMetaClass(type):
        _instance = None
    
        def __call__(self, *args, **kwargs):
            if self._instance is None:
                self._instance = super().__call__(*args, **kwargs)
            return self._instance
    
    class Singleton(metaclass=SingletonMetaClass):
        pass
    
    # 示例：
    a = Singleton()
    b = Singleton()
    # id(a) == id(b)

当一个类设置了元类以后，创建对象是通过调用元类中的 `__call__()` 函数实现。这一点你可以通过对以下代码做断点运行来理解：

class SigletonMetaClass(type):
        _instance = None
    
        def __new__(cls, *args, **kwargs):
            return super().__new__(cls, *args, **kwargs)  # 断点1
    
        def __call__(self, *args, **kwargs):
            if self._instance is None:
                self._instance = super().__call__(*args, **kwargs)
            return self._instance  # 断点2
    
    class Singleton(metaclass=SigletonMetaClass):
        def __new__(cls, *args, **kwargs):
            return super().__new__(cls)  # 断点3

因此，用元类实现单例时仍需按照三步骤：1. 拦截 2. 判断是否已经创建过对象 3. 返回对象。与上个方法相比，区别在于拦截的地点不同。

## 装饰器 ##

用装饰器实现单例，思路与其他一致，改变的同样是拦截地点与记录位置。

### 函数装饰器 ###

def SingletonDecorator(cls):
        _instance = None
    
        def get_instance(*args, **kwargs):
            nonlocal _instance
            if _instance is None:
                _instance = cls(*args, **kwargs)
            return _instance
        return get_instance
    
    @SingletonDecorator
    class Singleton(object):
        pass
    
    # 示例：
    a = Singleton()
    b = Singleton()
    # id(a) == id(b)

### 类装饰器 ###

class SingletonDecorator(object):
        _instance = None
    
        def __init__(self, cls):
            self._cls = cls
    
        def __call__(self, *args, **kwargs):
            if self._instance is None:
                self._instance = self._cls(*args, **kwargs)
            return self._instance
    
    @SingletonDecorator
    class Singleton(object):
        pass
    
    # 示例：
    a = Singleton()
    b = Singleton()
    # id(a) == id(b)

## 方法 ##

### 静态方法 staticmethod ###

class Singleton(object):
        _instance = None
    
        @staticmethod
        def get_instance():
            cls = __class__
    
            if cls._instance is None:
                cls._instance = super(cls, cls).__new__(cls)
            return cls._instance
    
    # 示例：
    a = Singleton.get_instance()
    b = Singleton.get_instance()
    # id(a) == id(b)

在静态函数中，既不会传入 **cls** 也不会有 **self**。为了在静态函数中使用 cls 的同时，避免硬编码，可使用内置变量 `__class__`。在一个类的作用域中，`__class__` 等于类对象，即：`__class__ == Singleton`。

### 类方法 classsmethod ###

class Singleton(object):
        _instance = None
    
        @classmethod
        def get_instance(cls):
            if cls._instance is None:
                cls._instance = super().__new__(cls)
            return cls._instance
    
    # 示例：
    a = Singleton.get_instance()
    b = Singleton.get_instance()
    # id(a) == id(b)

与静态函数类似。

## 名字覆盖 ##

class Singleton(object):
        def __call__(self):
            return self
    
    Singleton = Singleton()
    
    # 示例：
    a = Singleton()
    b = Singleton()
    # id(a) == id(b)

用**实例名**覆盖**类名**后，执行 `Singleton()` 就是在调用 `__call__()` 函数，总是返回自身。

## 属性共享 ##

class Singleton(object):
        _state = { }
    
        def __new__(cls, *args, **kwargs):
            obj = super().__new__(cls)
            obj.__dict__ = cls._state
            return obj
    
        def __init__(self, name):
            self.name = name
    
    # 示例：
    a = Singleton()
    b = Singleton()
    # id(a) != id(b)

实例对象的私有属性存放在 `__dict__` 中。因此，将所有对象指向同一个属性 Singleton.\_state，即便它们的 id值 不同，由于共享属性仍实现了单例效果。

猜你喜欢

最长无重复子串
写技术博客的一些心得分享
Java 多线程（七）：线程池
Java 多线程（五）：锁（三）
Java 多线程（四）：锁（二）
Java 多线程（三）：锁（一）
Java 多线程（二）：并发编程的三大特性
线性时间非比较类排序
Java 多线程（一）：基础
合并k个已排序的链表
HDFS 高可用分布式环境搭建
合并两个有序数组
连续子数组的最大和
HDFS 分布式环境搭建
容器盛水问题
大数加法
HDFS 伪分布式环境搭建
设计LRU缓存结构
两数之和
使用单调栈来解决的一些问题

zl程序教程

当前栏目

Python 实现单例

相关文章