[Python] 实现单例模式的四种方式及单例模式日志
0. 前情提要
我们知道类 __init__ 方法，还应该知道类的 __new__方法，和元类的 __call__ 方法。这三个方法的执行顺序是：
元类的
__call__方法 ==> 类的__new__方法 == > 类的__init__方法
只要利用三者的执行顺序，我们就可以在创建实例对象的时候，判断实例对象是否已经创建，如果是，则返回已经创建好的实例对象，否则新建一个实例对象并返回。这样就可以实现单例模式了。
如果你还不知道 cls、__new__、__call__ ，那么你可能无法理解它们在单例模式的应用。可以参考：
[Python] 深入理解 self、cls、__call__、__new__、__init__、__del__、__str__、__class__、__doc__等
1. 使用__new__实现单例模式
利用运行 __init__ 方法，初始化实例之前，会运行类的 __new__方法，我们可以在 __new__ 方法判断类是否已经创建过实例对象，如果是，则返回已经创建好的实例对象，否则新建一个实例对象并返回。
class Singleton(object):
def __new__(cls, *args, **kwargs):
if not hasattr(cls, "_instance"): # hasatter() 判断一个对象是否有某个属性
cls._instance = super().__new__(cls, *args, **kwargs)
return cls._instance
print(Singleton() is Singleton()) # True
注意：__new__方法无法避免触发__init__()，初始的成员变量会进行覆盖。
class Singleton(object):
def __new__(cls, *args, **kwargs):
if not hasattr(cls, "_instance"): # hasatter() 判断一个对象是否有某个属性
cls._instance = super().__new__(cls)
return cls._instance
def __init__(self, name=None):
self.name = name
def print_name(self):
print(self.name)
a1, a2 = Singleton('a1'), Singleton('a2')
a1.print_name() # a2
a2.print_name() # a2
我们发现 a1 对象的 name 被覆盖掉了。
2. 使用__call__方法实现单例模式
简单点说，就是元类的__call__ 方法在类的 __new__ 方法和 __init__ 方法之前执行。
class SingletonType(type):
_instances = {}
def __call__(cls, *args, **kwargs):
if cls not in cls._instances:
cls._instances[cls] = super(SingletonType, cls).__call__(*args, **kwargs)
return cls._instances[cls]
class A(metaclass=SingletonType):
pass
print(A() is A()) # True
还可以这样：
class Singleton(type):
def __init__(self, *args, **kwargs):
self.__instance = None
super().__init__(*args, **kwargs)
def __call__(self, *args, **kwargs):
if self.__instance is None:
self.__instance = super().__call__(*args, **kwargs)
return self.__instance
class A(metaclass=Singleton):
pass
print(A() is A()) # True
3. 使用装饰器实现单例模式
用装饰器来控制调用__call__方法。
def singleton(cls):
instances = {}
def _singleton(*args, **kwargs):
if cls not in instances:
instances[cls] = cls(*args, **kwargs)
return instances[cls]
return _singleton
@singleton
class A:
pass
print(A() is A()) # True
4. 模块单例
Python 的模块就是天然的单例模式，因为模块在第一次导入时，会生成 .pyc 文件，当第二次导入时，就会直接加载 .pyc 文件，而不会再次执行模块代码。
# single.py
class Singleton:
pass
singleton = Singleton()
# other.py
from single import singleton
5. 简单总结
除了模块单例外，其他几种模式的本质都是通过设置中间变量，来判断类是否已经拥有实例对象。区别就是中间变量或设置在元类中，或封装在函数中，或设置在类中作为静态变量。
中间变量的访问和更改存在线程安全的问题：在开启多线程模式的时候需要加锁处理。
6. 使用单例模式实现的日志模块
"""
我们的目的是借助单例模式，只生成一个logger。
当日志文件已经存在时，默认以追加方式写入。
"""
import logging
import os
import time
import sys
class SingletonType(type):
_instances = {}
def __call__(cls, *args, **kwargs):
if cls not in cls._instances:
cls._instances[cls] = super(SingletonType, cls).__call__(*args, **kwargs)
return cls._instances[cls]
class Logger(metaclass=SingletonType):
def __new__(cls, log_file=None, file_output=True, standard_output=True):
"""
1. Logger的__new__只在创建第一个实例的时候被调用。
2. 我们要返回的不是Logger类实例，而是使用内置logging模块创建的实例。
"""
# 日志文件的路径
if log_file is None:
# 文件的当前目录
current_path = os.path.dirname(os.path.realpath(__file__))
current_time = time.strftime("%Y-%m-%d-%H%M%S", time.localtime())
log_file = os.path.join(current_path, 'log_output', f'{current_time}.txt')
os.makedirs(os.path.dirname(log_file), exist_ok=True)
cls.logger = logging.getLogger(__name__)
formater = logging.Formatter('%(asctime)s %(name)s [%(filename)s %(lineno)s] %(message)s')
# 如果既不使用标准输出，也不使用日志文件输出，则选择标准输出
if not file_output and not standard_output:
standard_output = True
if standard_output:
# 标准输出
standard_out = logging.StreamHandler(sys.stdout)
standard_out.setFormatter(formater)
cls.logger.addHandler(standard_out) # 添加标准输出
if file_output:
# 日志文件输出
file_out = logging.FileHandler(log_file, encoding='utf-8')
file_out.setFormatter(formater)
cls.logger.addHandler(file_out) # 添加文件输出
cls.logger.setLevel(logging.INFO)
return cls.logger
if __name__ == '__main__':
logger = Logger("Logger1") # 只第一个名称有效
logger2 = Logger("Logger2")
logger3 = Logger("Logger3")
logger.info("This is a info")
print(logger is logger2, logger2 is logger3)
print(not False and not False)