44、Python之面向对象：孔乙己，实现单例模式，我有4种方法-CSDN博客

本文链接：https://blog.csdn.net/dqrcsc/article/details/141227098

引言

前面的一系列文章中，已经花了很大的篇幅来介绍Python中面向对象的内容，实际场景中高频使用的、不那么高频使用的，基本都介绍到了。我打算把今天这篇文章作为面向对象模块的收尾。

本文将首先回顾一下面向对象模块的主要内容，然后重点介绍基于前面介绍的知识，实现单例模式。

面向对象内容梳理

关于面相对象的内容，其实我们主要介绍了三大特性、四种数据封装、三种方法、三种类。其中：

三大特性：
1、封装：将数据与算法封装为一个整体，也可以理解为状态与操作的封装。

2、继承：更高级别的代码复用，子类直接拿来即用，强调一组类的共性的部分。

3、多态：子类对父类的方法的不同实现，强调子类可以丰富多彩的个性的部分。

四种数据封装：

1、实例属性：每个实例对象相互独立，可以进行私有化，虽然是“名称混淆”的实现机制。

2、类属性：归属于类对象，所有实例对象共享该实例，同样可以私有化。

3、property：实现数据保护、添加新的校验、处理逻辑，同时兼容直接基于属性名访问的历史接口。

4、属性描述符：更加底层的一种数据封装机制，适用于很多个属性都要进行类似的封装逻辑的复用。

三种方法：

1、实例方法：通过实例对象进行调用，默认将实例对象作为方法的第一个参数进行自动传递，通常以self作为第一个形参的名字。

2、类方法：@classmethod，通过类名进行调用，与实例对象无关，不存在实例时，也是可以调用的，默认将类对象作为方法的第一个参数进行自动传递，通常以cls作为第一个形参的名字。

3、静态方法：从抽象、设计的角度，与类本身无太大关联，更多的是作为工具方法的一种抽离，所以，不会自动传递实例对象或者类对象，可以理解为类中定义的普通函数。

三种类：

1、普通类：通常定义的类，都是普通的类，可以随意进行实例化对象的创建，完成基础的数据和算法逻辑的封装。

2、抽象基类（abc）：不能进行实例化操作，通常作为基类使用，定义相关协议，具体实现延迟到各个子类中。

3、元类：继承自type及其子类的类，用于创建类对象的类，通过元类，可以规范类定义以及完成类对象的动态增强。

其实，大部分内容都是在以不同的方式帮我们完成代码的复用，只是复用的颗粒度有所不同。毕竟，编程本身在于将重复工作的自动化转换，是帮助人们更好地偷懒。而编程语言中的各种代码复用的思想，其实是对如何偷懒的偷懒实现，似乎有点“元偷懒”的意味。

虽然花了很多的篇幅去讲解面向对象的内容，但是，真正梳理一下，也就这些东西。

单例模式的4种实现方法

抽象基类不能进行实例化，普通类可以随意进行实例化。其实，关于实例化，现实场景中，还有一种只能实例化一个对象的需求，应运而生的设计模式就是“单例模式”。

所谓“单例模式”，简单来说，就是一种设计模式，确保某个类中只能有一个实例对象，并提供一个全局访问点。

单例模式通常在资源管理、全局配置、日志记录、缓存等场景中被频繁使用，更多的是可以有效节省计算及存储资源。

方法1：使用类属性

直接看代码：

class King:
    _instance = None

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


if __name__ == '__main__':
    king1 = King()
    king2 = King()
    print(king1)
    print(king2)
    print(king1 is king2)

执行结果：

从执行结果，可以看到每次实例化，确实都是返回同一个实例化对象。

这种方式，其实是基于实例化对象之前，首先是需要调用__new__()方法的机制进行单例模式的，所以，需要对__new__()和__init__()方法的区别和触发机制有一个比较清晰的理解。如果单例的实例对象有状态（属性），稍不留意，可能会导致奇怪的事情的发生。

直接看代码：

class King:
    _instance = None

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

    def __init__(self):
        print(f"虽然是同一个实例，不会被重复创建，但是初始化操作会重复")
        self.name = '老虎'


if __name__ == '__main__':
    king1 = King()
    print(king1)
    king1.name = '猴子'
    print(king1.name)
    king2 = King()
    print(king2)
    print(king1.name)

执行结果：

代码的本意是，既然是同一个实例，我如果修改了实例中的属性，返回的同一个实例，应该是修改后的属性。但是，__init__()方法会被重复调用的。

可以调整为以下的做法，从而避免重复初始化导致的状态丢失：

class King:
    _instance = None

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

    def __init__(self):
        if not hasattr(self, 'initialized'):
            self.initialized = True
            print(f"虽然是同一个实例，不会被重复创建，但是初始化操作会重复")
            self.name = '老虎'


if __name__ == '__main__':
    king1 = King()
    print(king1)
    king1.name = '猴子'
    print(king1.name)
    king2 = King()
    print(king2)
    print(king1.name)

执行结果：

通过在实例中维持一个实例化的状态属性，从而确保实例对象只被创建一次的同时，也只实例化一次，从而避免实例对象状态的丢失。

方法2：使用元类

使用类属性的方法实现元类，比较清晰，但是，每次创建一个单例模式的类，都要重复写单例的处理逻辑，为了更好的复用，可以使用元类来介入类对象的创建过程，从而复用单例的逻辑。

直接看代码：

class SingletonMeta(type):
    _instances = {}

    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super().__call__(*args, **kwargs)
        return cls._instances[cls]


class King(metaclass=SingletonMeta):
    pass


if __name__ == '__main__':
    king1 = King()
    print(king1)
    king1.name = '猴子'
    print(king1.name)
    king2 = King()
    print(king2)
    print(king1.name)

执行结果：

通过以上两种实现方法，可以顺便回顾一下实例化对象的创建机制及元类的使用。

接下来的两种方法，涉及到我们暂未提及的Python中的内容，对新手看，可能有点超纲，所以，只是演示代码，不做过多的展开了。

方法3：使用装饰器

直接看代码：

def singleton(cls):
    instances = {}

    def get_instance(*args, **kwargs):
        if cls not in instances:
            instances[cls] = cls(*args, **kwargs)
        return instances[cls]

    return get_instance


@singleton
class King:
    pass


@singleton
class Queen:
    pass


if __name__ == '__main__':
    king1 = King()
    print(king1)
    king2 = King()
    print(king2)
    queen1 = Queen()
    print(queen1)
    queen2 = Queen()
    print(queen2)

执行结果：

方法4：使用模块的加载特性

首先在模块中定义King类，并实例化一个对象，假设模块名是singletong_module.py：

class King:
    pass


king_instance = King()
print(f"模块中的king实例: {king_instance}")

然后，在需要使用该实例对象的地方进行导入：

from singleton_module import king_instance

print(f"导入的king实例: {king_instance}")

执行结果：

需要说明的是，后面的两种实现方法，分别涉及到装饰器和模块，之所以在这里也提及一下，其实，是作为后面内容的一个提前引入。

总结

本文首先回顾了Python中面向对象的相关内容，可以简单概括为：三大特性、四种数据封装、三种方法、三种类。其实，这些内容始终围绕着一个基本点：代码复用（如何更好地偷懒）。其次，通过介绍单例模式的实现方法，对面向对象的实例化对象构建及元类的核心内容进行了复习，并对后续要介绍的装饰器、模块的内容做了一个引入。

感谢您的拨冗阅读，如果对您学习Python有所帮助，欢迎点赞、关注。