Python的6種方式實現單例模式

單例模式是一個軟件的設計模式，爲了保證一個類，不管調用多少次產生的實例對象，都是指向同一個內存地址，僅僅只有一個實例（只有一個對象）。

實現單例模式的手段有不少種，但總的原則是保證一個類只要實例化一個對象，下一次再實例的時候就直接返回這個對象，再也不作實例化的操做。因此這裏面的關鍵一點就是，如何判斷這個類是否實例化過一個對象。

這裏介紹兩類方式：

• 一類是經過模塊導入的方式；
• 一類是經過魔法方法判斷的方式；

# 基本原理：
- 第一類經過模塊導入的方式，借用了模塊導入時的底層原理實現。
- 當一個模塊（py文件）被導入時，首先會執行這個模塊的代碼，而後將這個模塊的名稱空間加載到內存。
- 當這個模塊第二次再被導入時，不會再執行該文件，而是直接在內存中找。
- 因而，若是第一次導入模塊，執行文件源代碼時實例化了一個類，那再次導入的時候，就不會再實例化。

- 第二類主要是基於類和元類實現，在'對象'的魔法方法中判斷是否已經實例化過一個對象
- 這類方式，根據實現的手法不一樣，又分爲不一樣的方法，如：
- 經過類的綁定方法；經過元類；經過類下的__new__；經過裝飾器（函數裝飾器，類裝飾器）實現等。

下面分別介紹這幾種不一樣的實現方式，僅供參考實現思路，不作具體需求。

經過模塊導入

# cls_singleton.py
class Foo(object):
    pass

instance = Foo()

# test.py
import cls_singleton

obj1 = cls_singleton.instance
obj2 = cls_singleton.instance
print(obj1 is obj2)

# 原理：模塊第二次導入從內存找的機制

經過類的綁定方法

class Student:
    _instance = None	# 記錄實例化對象

    def __init__(self, name, age):
        self.name = name
        self.age = age

    @classmethod
    def get_singleton(cls, *args, **kwargs):
        if not cls._instance:
            cls._instance = cls(*args, **kwargs)
        return cls._instance

stu1 = Student.get_singleton('jack', 18)
stu2 = Student.get_singleton('jack', 18)
print(stu1 is stu2)
print(stu1.__dict__, stu2.__dict__)

# 原理：類的綁定方法是第二種實例化對象的方式，
# 第一次實例化的對象保存成類的數據屬性 _instance，
# 第二次再實例化時，在get_singleton中判斷已經有了實例對象，直接返回類的數據屬性 _instance

經過魔法方法__new__

class Student:

    _instance = None

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __new__(cls, *args, **kwargs):
        # if cls._instance:
        #     return cls._instance	# 有實例則直接返回
        # else:
        #     cls._instance = super().__new__(cls)	# 沒有實例則new一個並保存
        #     return cls._instance	# 這個返回是給是給init，再實例化一次，也沒有關係

        if not cls._instance:	# 這是簡化的寫法，上面註釋的寫法更容易提現判斷思路
            cls._instance = super().__new__(cls)
        return cls._instance


stu1 = Student('jack', 18)
stu2 = Student('jack', 18)
print(stu1 is stu2)
print(stu1.__dict__, stu2.__dict__)

# 原理：和方法2相似，將判斷的實現方式，從類的綁定方法中轉移到類的__new__中
# 歸根結底都是 判斷類有沒有實例，有則直接返回，無則實例化並保存到_instance中。

經過元類

class Mymeta(type):

    def __init__(cls, name, bases, dic):
        super().__init__(name, bases, dic)
        cls._instance = None		# 將記錄類的實例對象的數據屬性放在元類中自動定義了

    def __call__(cls, *args, **kwargs):	# 此call會在類被調用（即實例化時觸發）
        if cls._instance:				# 判斷類有沒有實例化對象
            return cls._instance
        else:							# 沒有實例化對象時，控制類造空對象並初始化
            obj = cls.__new__(cls, *args, **kwargs)
            obj.__init__(*args, **kwargs)
            cls._instance = obj			# 保存對象，下一次再實例化能夠直接返回而不用再造對象
            return obj


class Student(metaclass=Mymeta):
    def __init__(self, name, age):
        self.name = name
        self.age = age


stu1 = Student('jack', 18)
stu2 = Student('jack', 18)
print(stu1 is stu2)
print(stu1.__dict__, stu2.__dict__)

# 原理：類定義時會調用元類下的__init__，類調用(實例化對象)時會觸發元類下的__call__方法
# 類定義時，給類新增一個空的數據屬性，
# 第一次實例化時，實例化以後就將這個對象賦值給類的數據屬性；第二次再實例化時，直接返回類的這個數據屬性
# 和方式3的不一樣之處1：類的這個數據屬性是放在元類中自動定義的，而不是在類中顯示的定義的。
# 和方式3的不一樣之處2：類調用時觸發元類__call__方法判斷是否有實例化對象，而不是在類的綁定方法中判斷

函數裝飾器

def singleton(cls):
    _instance_dict = {}		# 採用字典，能夠裝飾多個類，控制多個類實現單例模式
  
    def inner(*args, **kwargs):
        if cls not in _instance_dict:
            _instance_dict[cls] = cls(*args, **kwargs)
        return _instance_dict.get(cls)
    return inner


@singleton
class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    # def __new__(cls, *args, **kwargs):	# 將方法3的這部分代碼搬到了函數裝飾器中
    #     if not cls._instance:
    #         cls._instance = super().__new__(cls)
    #     return cls._instan
    
stu1 = Student('jack', 18)
stu2 = Student('jack', 18)
print(stu1 is stu2)
print(stu1.__dict__, stu2.__dict__)

類裝飾器

class SingleTon:
    _instance_dict = {}

    def __init__(self, cls_name):
        self.cls_name = cls_name

    def __call__(self, *args, **kwargs):
        if self.cls_name not in SingleTon._instance_dict:
            SingleTon._instance_dict[self.cls_name] = self.cls_name(*args, **kwargs)
        return SingleTon._instance_dict.get(self.cls_name)


@SingleTon		# 這個語法糖至關於Student = SingleTon(Student),即Student是SingleTon的實例對象
class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age

stu1 = Student('jack', 18)
stu2 = Student('jack', 18)
print(stu1 is stu2)
print(stu1.__dict__, stu2.__dict__)

# 原理：在函數裝飾器的思路上，將裝飾器封裝成類。
# 程序執行到與語法糖時，會實例化一個Student對象，這個對象是SingleTon的對象。
# 後面使用的Student本質上使用的是SingleTon的對象。
# 因此使用Student('jack', 18)來實例化對象，實際上是在調用SingleTon的對象，會觸發其__call__的執行
# 因此就在__call__中，判斷Student類有沒有實例對象了。