5四、用盡可能多的方法實現單例模式

1、模塊單例

Python 的模塊就是自然的單例模式，由於模塊在第一次導入時，會生成 .pyc 文件，當第二次導入時，就會直接加載 .pyc 文件，而不會再次執行模塊代碼。

#foo1.py
class Singleton(object):
    def foo(self):
        pass
singleton = Singleton()


#foo.py
from foo1 import singleton

直接在其餘文件中導入此文件中的對象，這個對象便是單例模式的對象

2、靜態變量方法

先執行了類的__new__方法（咱們沒寫時，默認調用object.__new__），實例化對象；而後再執行類的__init__方法，對這個對象進行初始化，全部咱們能夠基於這個，實現單例模式。

class Singleton(object):
    def __new__(cls,a):
        if not hasattr(cls, '_instance'):
            cls._instance = object.__new__(cls)
        return cls._instance
    def __init__(self,a):
        self.a = a
    def aa(self):
        print(self.a)


a = Singleton("a")

變種：利用類的靜態方法或者類方法，實現對函數初始化的控制。該方法須要手動調用靜態方法實現實例。本質上是手動版的__new__方法。

3、元類方法

此方法是在__new__方法的更上層對實例化過程進行控制。

原理：執行元類的 元類的__new__方法和__init__方法用來實例化類對象，__call__ 方法用來對實例化的對象的實例即類的對象進行控制。__call__方法會調用實例類的 __new__方法，用於建立對象。返回對象給__call__方法，而後調用類對象的 __init__方法，用於對對象初始化。

class Singleton1(type):
    def __init__(self, *args, **kwargs):
        self.__instance = None
        super(Singleton1,self).__init__(*args, **kwargs)

    def __call__(self, *args, **kwargs):
        if self.__instance is None:
            self.__instance = super(Singleton1,self).__call__(*args, **kwargs)
        return self.__instance

class Singleton2(type):
    _inst = {}
    def __call__(cls, *args, **kwargs):
        print(cls)
        if cls not in cls._inst:
            cls._inst[cls] = super(Singleton2, cls).__call__(*args)
        return cls._inst[cls]

class C(metaclass=Singleton1):
    pass

4、裝飾器

原理：裝飾器用來控制類調用__call__方法。

def singleton(cls, *args, **kw):
    instance = {}
    def _singleton(args):
        if cls not in instance:
            instance[cls] = cls(*args, **kw)
        return instance[cls]
    return _singleton

@singleton
class A:
    pass