Python 中，单例模式的5种实现方式(使用模块、使用装饰器、使用类方法、基于new方法实现、基于metaclass方式实现)

单例模式的5种实现方式
1 使用模块
2 使用装饰器
3 使用类方法
4.基于new方法实现
5 基于metaclass方式实现

单例模式的5种实现方式

什么是单例模式？
单例模式是指：保证一个类仅有一个实例，并提供一个访问它的全局访问点# 线程1 执行：
cursor.excute('select * from user')# 线程2执行 
cursor.excute('select * from books')# 线程1 执行
cursor.fetchAll() # 拿出查询到的数据# django ，每个线程，一个连接对象---》 连接池

1 使用模块

其实，Python 的模块就是天然的单例模式，因为模块在第一次导入时，会生成 .pyc 文件，当
第二次导入时，就会直接加载 .pyc 文件，而不会再次执行模块代码。
因此，我们只需把相关的函数和数据定义在一个模块中，就可以获得一个单例对象了。
如果我们真的想要一个单例类，可以考虑这样做：1.新建一个mysingleton.pyclass Singleton(object):def foo(self):passsingleton = Singleton()2.将上面的代码保存在文件 mysingleton.py 中，要使用时，直接在其他文件中导入此文件中的对象，
这个对象即是单例模式的对象：
from a import singleton

2 使用装饰器

   def Singleton(cls):instance = Nonedef _singleton(*args, **kargs):nonlocal instanceif not instance:instance = cls(*args, **kargs)return instancereturn _singleton@Singletonclass A(object):def __init__(self, x=0):self.x = xa1 = A(2)a2 = A(3)print(a1.x)print(a2.x)print(a1 is a2)  # True

回顾装饰器是什么

import time# 装饰器是什么?装饰器的作用是什么？
'''
装饰器是闭包函数的一个典型应用它是什么？在不改变函数源代码和调用方式idea基础上，为函数增加新功能
'''# def add(a, b):
#     time.sleep(2)
#     return a + bdef time_total(func):def inner(a, b):start = time.time()res = func(a, b)print('运行时间是：', time.time() - start)return resreturn inner# add = time_total(add)
# res = add(3, 4)
# print(res)@time_total  # 原理就是 add=time_total(add)
def add(a, b):time.sleep(2)return a + bres = add(3, 4)
print(res)
print(add.__name__)  # 就是inner# 什么是闭包函数？参数不是传进来的，是用了它上一层作用域范围的变量
'''1 定义在函数内部2 对外部作用域有引用(如果使用外部的可变类型，则直接使用；如果是不可变类型，需要使用nonlocal)例如：def add():a = 10def inner():nonlocal aa += 1print('闭包内部的值是：', a)  # 11inner()print('闭包外部的值是：', a)  # 11add()
'''

3 使用类方法

class Singleton(object):_instance=Nonedef __init__(self):pass@classmethoddef instance(cls, *args, **kwargs):if not cls._instance:cls._instance=cls(*args, **kwargs)return cls._instancea1=Singleton.instance()
a2=Singleton().instance()print(a1 is a2)

4 基于new方法实现

class Singleton(object):_instance=Nonedef __init__(self):passdef __new__(cls, *args, **kwargs):if not cls._instance:cls._instance = object.__new__(cls)return cls._instanceobj1 = Singleton()
obj2 = Singleton()
print(obj1 is obj2)

5 基于metaclass方式实现

# 产生类这个对象的类，称之为元类
# 类中的 __call__什么时候回触发？对象()会触发
class SingletonType(type):_instance = Nonedef __call__(cls, *args, **kwargs):if not cls._instance:cls._instance = object.__new__(cls)cls._instance.__init__(*args, **kwargs)return cls._instanceclass Foo(metaclass=SingletonType):def __init__(self, name):self.name = nameobj1 = Foo('name')
obj2 = Foo('name')
print(obj1.name)
print(obj1 is obj2)  # True# __init__ 和 __new__ 区别是什么？
# 1 类()--->触发类中的__init__---->对象已经创建出来了，不能拦截住，做成单例了
# 2 类（）----》触发类中的__new__----》真正的创建对象，判断之前有没有创建过，如果创建过，直接返回
# 3元类---》类()--->触发元类的__call__---》判断之前有没有创建过，如果有，直接返回