一文詳解Python中實現單例模式的幾種常見方式

更新時間：2023年03月22日 16:57:14 作者：Dante丶

這篇文章主要為大家介紹了Python中實現單例模式的幾種常見方式示例詳解，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪

Python 中實現單例模式的幾種常見方式

元類（Metaclass）：

class SingletonType(type):
    """
    單例元類。用于將普通類轉換為單例類。
    """
    _instances = {}  # 存儲單例實例的字典
    def __call__(cls, *args, **kwargs):
        """
        重寫 __call__ 方法。用于創(chuàng)建和返回單例實例。
        """
        if cls not in cls._instances:  # 如果類還沒有實例化過
            cls._instances[cls] = super().__call__(*args, **kwargs)  # 則創(chuàng)建新實例并存儲在字典中
        return cls._instances[cls]  # 返回字典中的實例
class MyClass(metaclass=SingletonType):
    """
    單例類。使用元類 SingletonType 將其轉換為單例類。
    """
    def __init__(self, name):
        self.name = name
    def say_hello(self):
        print(f"Hello, my name is {self.name}.")
# 創(chuàng)建 MyClass 的兩個實例，應該是同一個對象
obj1 = MyClass("Alice")
obj2 = MyClass("Bob")
# 打印兩個實例的內存地址，應該相同
print(hex(id(obj1)))  # 輸出：0x7f8d94547a90
print(hex(id(obj2)))  # 輸出：0x7f8d94547a90
# 調用兩個實例的方法，輸出應該相同
obj1.say_hello()  # 輸出：Hello, my name is Alice.
obj2.say_hello()  # 輸出：Hello, my name is Alice.

在上面的代碼中，我們定義了一個名為 SingletonType 的元類，并將其用作 MyClass 的元類。在 SingletonType 類中，我們維護了一個 _instances 字典，用于存儲每個類的唯一實例。在 __call__() 方法中，我們檢查 _instances 字典，如果類尚未擁有實例，則創(chuàng)建一個新實例并添加到 _instances 中。最后，我們返回 _instances 中的實例。

在 MyClass 類中，我們定義了一個帶參數的構造函數，并且使用 metaclass 參數來指定 SingletonType 元類。由于 MyClass 類使用 SingletonType 元類，因此它具有單例行為。在程序中，我們創(chuàng)建了 MyClass 的兩個實例 obj1 和 obj2，然后打印它們的內存地址以驗證它們是否是同一個對象。最后，我們調用這兩個實例的方法，輸出應該相同。

裝飾器（Decorator）：

def singleton(cls):
    """
    單例裝飾器。用于將普通類轉換為單例類。
    """
    instances = {}  # 存儲單例實例的字典
    def get_instance(*args, **kwargs):
        """
        獲取單例實例的方法。
        """
        if cls not in instances:  # 如果類還沒有實例化過
            instances[cls] = cls(*args, **kwargs)  # 則創(chuàng)建新實例并存儲在字典中
        return instances[cls]  # 返回字典中的實例
    return get_instance
@singleton
class MyClass:
    """
    單例類。使用裝飾器 singleton 將其轉換為單例類。
    """
    def __init__(self, name):
        self.name = name
    def say_hello(self):
        print(f"Hello, my name is {self.name}.")
# 創(chuàng)建 MyClass 的兩個實例，應該是同一個對象
obj1 = MyClass("Alice")
obj2 = MyClass("Bob")
# 打印兩個實例的內存地址，應該相同
print(hex(id(obj1)))  # 輸出：0x7f8d94547a90
print(hex(id(obj2)))  # 輸出：0x7f8d94547

在上面的代碼中，我們定義了一個名為 singleton 的裝飾器函數。在 singleton 函數內部，我們創(chuàng)建了一個 instances 字典，用于存儲每個類的唯一實例。然后，我們定義了一個名為 get_instance 的內部函數，用于獲取單例實例。在 get_instance 函數中，我們檢查 instances 字典，如果類尚未擁有實例，則創(chuàng)建一個新實例并添加到 instances 中。最后，我們返回字典中的實例。

在 MyClass 類上應用 @singleton 裝飾器，以將其轉換為單例類。由于該裝飾器是針對類進行操作的，因此它可以輕松地將任何普通類轉換為單例類。在程序中，我們創(chuàng)建了 MyClass 的兩個實例 obj1 和 obj2，然后打印它們的內存地址以驗證它們是否是同一個對象。最后，我們調用這兩個實例的方法，輸出應該相同。

模塊（Module）：

# mymodule.py
class MyClass:
    """
    單例類。
    """
    def __init__(self, name):
        self.name = name
    def say_hello(self):
        print(f"Hello, my name is {self.name}.")
my_singleton = MyClass("Alice")  # 創(chuàng)建單例實例

# main.py
from mymodule import my_singleton
# 使用單例實例
my_singleton.say_hello()  # 輸出：Hello, my name is Alice.

在上面的代碼中，我們將 MyClass 類定義在一個獨立的模塊 mymodule.py 中，并在其中創(chuàng)建了一個單例實例 my_singleton。然后，在另一個文件 main.py 中，我們從 mymodule 模塊中導入 my_singleton 實例，并使用它來調用 say_hello() 方法。

由于 Python 模塊在首次導入時會自動執(zhí)行，因此我們可以利用這一特性來創(chuàng)建單例實例。在 mymodule.py 模塊中，我們可以確保 my_singleton 只會被創(chuàng)建一次，并在程序的其他部分中共享它。

new 方法：

class MyClass:
    """
    單例類。
    """
    _instance = None  # 存儲單例實例的類變量
    def __new__(cls, *args, **kwargs):
        """
        重寫 __new__ 方法。用于創(chuàng)建和返回單例實例。
        """
        if cls._instance is None:  # 如果類還沒有實例化過
            cls._instance = super().__new__(cls)  # 則創(chuàng)建新實例并存儲在類變量中
        return cls._instance  # 返回類變量中的實例
    def __init__(self, name):
        self.name = name
    def say_hello(self):
        print(f"Hello, my name is {self.name}.")
# 創(chuàng)建 MyClass 的兩個實例，應該是同一個對象
obj1 = MyClass("Alice")
obj2 = MyClass("Bob")
# 打印兩個實例的內存地址，應該相同
print(hex(id(obj1)))  # 輸出：0x7f8d94547a90
print(hex(id(obj2)))  # 輸出：0x7f8d94547a90
# 調用兩個實例的方法，輸出應該相同
obj1.say_hello()  # 輸出：Hello, my name is Alice.
obj2.say_hello()  # 輸出：Hello, my name is Alice.

在上面的代碼中，我們將 MyClass 類的構造函數改為 __new__() 方法，并使用 _instance 類變量來存儲單例實例。在 __new__() 方法中，我們檢查 _instance 變量，如果類尚未擁有實例，則創(chuàng)建一個新實例并添加到 _instance 中。最后，我們返回 _instance 中的實例。

在程序中，我們創(chuàng)建了 MyClass 的兩個實例 obj1 和 obj2，然后打印它們的內存地址以驗證它們是否是同一個對象。最后，我們調用這兩個實例的方法，輸出應該相同。

無論使用哪種方法實現單例模式，都需要注意線程安全和可擴展性等方面的問題。因此，在實際開發(fā)中，請仔細考慮自己的需求并選擇合適的實現方式。

以上就是一文詳解Python中實現單例模式的幾種常見方式的詳細內容，更多關于Python 單例模式的資料請關注腳本之家其它相關文章！

您可能感興趣的文章: