我要评论★ 单例模式基本介绍
单例模式是一种设计模式，用于确保一个类只有一个实例，并提供全局访问点以获取该实例。它是一种创建型模式，通常用于需要严格控制某个类的实例数量的情况。单例模式确保一个类在整个应用程序生命周期中只有一个实例，因此可以节省系统资源，同时提供了一个集中的访问点，以便在需要时获取该实例。
★ 实现单例的几种方式：
- 模块导入
- 添加装饰器(类装饰器和函数装饰器)
- 重写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 singletonfile1.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
到此这篇关于python的四种单例模式实现方式的文章就介绍到这了,更多相关python单例模式内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！
发表评论