python 单例设计模式_python设计模式之单例模式
无论是在python代码中，还是面试中单例设计模式都是经常被问到和使用的，例如面试中会让你用代码实现单例模式分几种不同的方式，或者问你在平常工作中哪些地方有用到单例设计模式，然后深入探讨。
在本文中我将针对这两个问题来回答和用python代码来编写我们的单例模式。
首先，我们要了解什么是单例模式--官方解释是：确保一个类只有一个实例（也就是类的对象），并且提供一个全局的访问点（外部通过这个访问点来访问该类的唯一实例）。通俗的说就是，无论类实例化多少次，都只有一个相同的对象产生，并且可以通过一个具柄去访问这个这个唯一实例。
其次，我们平时代码中碰到是用单例模式设计的代码有哪些呢？
应用框架的配置文件config（如flask，django框架的配置文件）
线程池，数据库连接池的创建
应用程序的日志应用
这些应用都有一个共性那就是：他们都是全局共享的对象不会发生变化，不希望重复创建，这样有利于节省空间和减少性能消耗。
python实现单例模式的几种方式分别有：
一、类方法实现
classSingleType:
_instance=None
@classmethoddefinstance(cls):if notcls._instance:
cls._instance=SingleType()returncls._instancefor i in range(100):print(SingleType.instance())
看一下打印结果：
返回的都是同一个对象，实现了我们说的，无论调用多少次，都只返回同一个实例，但是这在多线程的环境中，可能会存在返回多个实例，我们实验一下。
import threading
import time
class SingleType:
_instance = None
def __init__(self):
time.sleep(1)
super().__init__()
@classmethod
def instance(cls):
if not cls._instance:
cls._instance = SingleType()
return cls._instance
def task():
obj = SingleType.instance()
print(obj)
for i in range(10):
t = threading.Thread(target=task).start()
print(SingleType.instance())
这是多线程环境测试的代码结果如下：
可以看到在多线程的环境中，我们产生了两个2个对象，这就违背了我们的单例原则了，那怎么解决它呢，答案是加锁。
importthreadingimporttimeclassSingleType:
_instance=None
_lock=threading.Lock()def __init__(self):
time.sleep(1)
super().__init__()
@classmethoddefinstance(cls):if notcls._instance:
with SingleType._lock:if notcls._instance:
cls._instance=SingleType()returncls._instancedeftask():
obj=SingleType.instance()print(obj)for i in range(10):
t= threading.Thread(target=task).start()
加锁后我们看运行结果：
这样就成功解决在多线程环境下单例的问题了， 至于问什么在最外层还要加一个if判断，是为了提高程序的性能。
二、装饰器模式实现
这种实现方式在我上一片将装饰器一文中是有提及的，在这我们再实现一次
defdecorator(cls):def wrap(*args, **kwargs):if notcls._instance:
cls._instance=cls()returncls._instancereturnwrap
@decoratorclassSingleType:
_instance=Nonedef __init__(self):
super().__init__()for i in range(10):
obj=SingleType()print(obj)
当然这里也会出现多线程创建多个实例的问题，可以参照上一个例子自行去实现多线程的版本。
三、使用__new__方法实现
在说__new__方法实现之前，我们需要有个前提知识，我们对象在实例话时会调用__init__方法，但是在调用__init__方法之前，类会先调用__new__方法，__new__方法中决定实例化怎样的对象（可以是调用object的__new__方法正常接着实例话，可以生成其他类的实例等）具体知识可以自行去补充，本文主要讲单例模式。
classSingleType:
_instance=Nonedef __new__(cls, *args, **kwargs):if notcls._instance:
cls._instance= super().__new__(cls)returncls._instancedef __init__(self):
super().__init__()for i in range(10):
obj=SingleType()print(obj)
查看运行结果：
四、使用元类实现单例模式
前提知识： 实例化对象时方法调用顺序是： type类的__cal__方法，其中会调用__new__方法和__init__方法
importthreadingclassSingleType(type):
lock=threading.Lock()def __call__(cls, *args, **kwargs):if notcls._instance:
with SingleType.lock:if notcls._instance:
cls._instance= super().__call__(*args, **kwargs) # 这个地方也可以替换成 obj = cls.__new__(cls) --> cls.__init__(onj) --> cls._instance=objreturncls._instanceclass Test(metaclass=SingleType):
_instance=Nonefor i in range(10):
obj=Test()print(obj)
在代码注释部分的作用相当于自己实现type.__call__的功能。
至此python实现单例设计模式所有的实现方式已经讲完，既然说的是设计模式就要把设计模式的八大准则贴出来，时常警醒自己。
1、依赖倒置原则（DIP）:高层模块不依赖于低层模块，而是都依赖于抽象；抽象不依赖于实现细节，实现细节应该依赖于抽象。
2、开放封闭原则（OCP）:对扩展开放，对依赖关闭；类的模块是可扩展的，但是不可修改。
3、单一职责原则（SRP）:一个类仅有一个能引起他的变化，变化的方向隐含着类的责任。
4、LisKov替换原则：派这类能够替换他的基类，继承表达了类的抽象。
5、接口隔离原则（ISP）:不应该强迫客户程序依赖他们不用的方法，接口应该小而强大。
6、优先使用对象组合，而不是类继承：类的继承破坏了封装性，子类父类耦合度高，类继承通常称为“白箱复用和“，对象组合称为”黑箱复用”。并且对象组合只需要有良好的定义的接口，且耦合度低。
7、封装变化点：使用封装来创建对象之间的分界层，让设计者可以在分界层的一侧修改，而不会对另一侧产生不良影响。
8、针对接口编程，而不是针对实现编程：减少系统中个部分的依赖关系，从而实现”高内聚，松耦合“的类型设计方案；不将变量类型声明为某个特定的具体类，而是声明为某个接口。