单例模式是一种软件设计模式。
在面向对象编程中，通过单例模式只能创建一个类实例，也就是一个类永远只有一个实例对象。
在工作中，为了确保某一个类只会创建出一个实例，就需要使用单例模式。
在 Python 中，实现单例的方法有很多。
一、通过装饰器的方式实现单例
def singleton_func(cls):
instances = {}
def _singleton(*args, **kwargs):
if cls not in instances:
instances[cls] = cls(*args, **kwargs)
return instances[cls]
return _singleton
@singleton_func
class Phone(object):
def phone_id(self):
return id(self)
p1 = Phone()
p2 = Phone()
print(p1.phone_id())
print(p2.phone_id())运行结果：
44502488
44502488通过装饰器来实现单例，直接用装饰器装饰类，实例化两遍类对象，对象的id是相等的，说明并没有两个实例对象，只是两个变量指向一个单例。如果注释掉上面的装饰器，则创建的是两个不同的实例（id不相等）。
在 Python 中，一切皆对象，所以字典中的数据也是一个个的对象。
在装饰器的内函数中，判断字典是否已经有键值对。如果没有，则添加一个类和类实例的键值对，如果有，则不添加。最后返回字典中的类实例，可以保证每次返回的都是同一个实例。
要使用这个单例装饰器，只要将其装饰到需要实现单例的类上即可。
在单例的多种实现方式中，个人最推荐这种方式，因为装饰器的使用方式即方便又优雅。我们可以将以上装饰器写在一个py文件中，所有需要使用单例的地方，都可以使用，步骤就两个，导入，装饰，如果不需要单例了，注释掉装饰器即可。
装饰器参考：
二、使用实例化方式实现单例
class SingletonInstance(object):
def __call__(self, *args, **kwargs):
return self
SingletonInstance = SingletonInstance()
s1 = SingletonInstance()
s2 = SingletonInstance()
print(id(s1))
print(id(s2))运行结果：
51186264
51186264在类中，先重写类的 __call__ 方法，在 __call__ 方法中返回自己。先实例化一个类的对象，后面所有需要使用这个类的地方，都调用这个实例对象。这样，每次调用的都是同一个实例，所以也能实现单例。
其实 Python 中的模块默认是单例模式的，在其他py文件中导入这个实例，然后使用，也是满足单例模式的。
三、使用类装饰器实现单例
class SingletonDecorator(object):
_instance = None
def __init__(self, cls):
self._cls = cls
def __call__(self, *args, **kwargs):
if self._instance is None:
self._instance = self._cls(*args, **kwargs)
return self._instance
@SingletonDecorator
class Phone(object):
def phone_id(self):
return id(self)
p1 = Phone()
p2 = Phone()
print(p1.phone_id())
print(p2.phone_id())运行结果：
47898464
47898464使用装饰器实现单例，因为装饰器除了可以使用闭包实现，还可以使用类实现，所以也可以使用类装饰器来实现单例。
通过重写类的 __call__ 方法实现类装饰器，在 __call__ 方法中判断当前是否有类实例，没有才会创建，从而实现单例。
四、重写类的 __new__ 方法实现单例
class SingletonClass(object):
_instance = None
def __new__(cls, *args, **kwargs):
if cls._instance is None:
cls._instance = super(SingletonClass, cls).__new__(cls)
return cls._instance
_is_init = False
def __init__(self):
if self._is_init is False:
print('-*-')
self._is_init = True
s1 = SingletonClass()
s2 = SingletonClass()
print(id(s1))
print(id(s2))运行结果：
-*-
57946912
57946912在 Python 类中，每次实例化一个类对象时，都会自动先执行 __new__ 方法和 __init__ 方法。 __new__ 方法先在内存中为实例对象申请空间，然后 __init__ 方法初始化实例对象。
通过重写 __new__ 方法，如果这个类没有实例对象，则执行 __new__ 方法，有则返回已有的实例，这样就实现了单例。
但是，因为 __init__ 方法是在 __new__ 执行完成后自动执行的，每次实例类的对象时都会执行 __init__ 方法，所以也要对 __init__ 方法进行重写，只有第一次实例化类对象时才执行初始化操作。如果上面代码中不重写 __init__ 方法，则会执行两遍__init__ 方法。
五、通过元类实现单例
class SingletonMeta(type, object):
def __init__(self, *args, **kwargs):
self._instance = None
super(SingletonMeta, self).__init__(*args, **kwargs)
# _instance = None
def __call__(self, *args, **kwargs):
if self._instance is None:
self._instance = super(SingletonMeta, self).__call__(*args, **kwargs)
return self._instance
class Phone(object, metaclass=SingletonMeta):
def phone_id(self):
return id(self)
p1 = Phone()
p2 = Phone()
print(p1.phone_id())
print(p2.phone_id())运行结果：
2325532722344
2325532722344在 Python 中，元类是创建类的类，是创建类的工厂，所有类的元类都是 type 类，所有类都是 type 类的实例对象。
元类参考：
如果自定义一个元类，在元类中重写 __call__ 方法，判断当前是否有实例，没有实例才创建，有则不创建。对需要实现单例的类，指定类的元类是我们自定义的元类，从而实现单例。
不过，不推荐使用这种方式。