python單例模式

• 優勢:
  • 實例控制
    單例模式會阻止其餘對象實例化,其本身的單例對象的副本,從而確保全部對象都訪問惟一實例
  • 靈活性
    由於類控制了實例化過程,因此類能夠靈活更改實例化過程
    
• 缺點
  • 開銷
    雖然數量不多,但若是每次對象請求引用時都要檢查是否存在類的實例,將仍然須要一些開銷.能夠經過使用靜態初始化解決問題.
  • 可能的開發混淆
    使用單例對象(尤爲在類庫中定義的對象)時,開發人員必須記住本身不能使用new關鍵字實例化對象.由於可能沒法訪問庫源代碼.所以應用程序開發人員可能會意外發現本身沒法直接實例化此類.
  • 對象生存期
    不能解決刪除單個對象的問題.在提供內存管理的語言中,只有單例類可以致使實例被取消分配,由於它包含對該實例的私有引用.在某些語言中,其餘類能夠刪除對象實例,但這樣會致使單例類中出現懸浮引用.

方法1

class singleton:
    def __init__(self, aClass):
        self.aClass = aClass
        self.instance = None

    def __call__(self, *args):
        if self.instance == None:
            self.instance = self.aClass(*args)
        return self.instance

@singleton  # Person = singleton(Person)
class Person:
    def __init__(self, name, hours, rate):
        self.name = name
        self.hours = hours
        self.rate = rate

    def pay(self):
        return self.hours * self.rate

方法2

def getInstance(aClass, *args):
    if aClass not in instances:
        instances[aClass] = aClass(*args)
    return instances[aClass]  # 每個類只能存在一個實例


def singleton(aClass):
    def onCall(*args):
        return getInstance(aClass, *args)
    return onCall

@singleton  # Person = singleton(Person)
class Person:
    def __init__(self, name, hours, rate):
        self.name = name
        self.hours = hours
        self.rate = rate

    def pay(self):
        return self.hours * self.rate

方法3

class Singleton(object):  
    def __new__(cls, *args, **kw):  
        if not hasattr(cls, '_instance'):  
            orig = super(Singleton, cls)  
            cls._instance = orig.__new__(cls, *args, **kw)  
        return cls._instance  

class MyClass(Singleton):  
    a = 1

方法4

class Borg(object):  
    _state = {}  
    def __new__(cls, *args, **kw):  
        ob = super(Borg, cls).__new__(cls, *args, **kw)  
        ob.__dict__ = cls._state  
        return ob  

class MyClass2(Borg):  
    a = 1

方法5

class Singleton2(type):  
    def __init__(cls, name, bases, dict):  
        super(Singleton2, cls).__init__(name, bases, dict)  
        cls._instance = None  
    def __call__(cls, *args, **kw):  
        if cls._instance is None:  
            cls._instance = super(Singleton2, cls).__call__(*args, **kw)  
        return cls._instance  

class MyClass3(object):  
    __metaclass__ = Singleton2

方法6

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

@singleton  
class MyClass4(object):  
    a = 1  
    def __init__(self, x=0):  
        self.x = x