python中的單例模式

時間 2019-11-09

標籤 python 模式欄目 Python 简体版

原文原文鏈接

單例模式

單例模式（Singleton Pattern）是一種經常使用的軟件設計模式，該模式的主要目的是確保某一個類只有一個實例存在。當你但願在整個系統中，某個類只能出現一個實例時，單例對象就能派上用場。html

好比，某個服務器程序的配置信息存放在一個文件中，客戶端經過一個 AppConfig 的類來讀取配置文件的信息。若是在程序運行期間，有不少地方都須要使用配置文件的內容，也就是說，不少地方都須要建立 AppConfig 對象的實例，這就致使系統中存在多個 AppConfig 的實例對象，而這樣會嚴重浪費內存資源，尤爲是在配置文件內容不少的狀況下。事實上，相似 AppConfig 這樣的類，咱們但願在程序運行期間只存在一個實例對象。設計模式

單例模式的要點有三個；一是某個類只能有一個實例；二是它必須自行建立這個實例；三是它必須自行向整個系統提供這個實例。服務器

在 Python 中，咱們能夠用多種方法來實現單例模式：函數

使用模塊
使用 __new__
使用裝飾器（decorator）
使用元類（metaclass）

使用模塊

其實，Python 的模塊就是自然的單例模式。spa

由於模塊在第一次導入時，會生成 .pyc 文件，當第二次導入時，就會直接加載 .pyc 文件，而不會再次執行模塊代碼。所以，咱們只需把相關的函數和數據定義在一個模塊中，就能夠得到一個單例對象了。翻譯

若是咱們真的想要一個單例類，能夠考慮這樣作：設計

#tests1.py
class MyClass(object):
    def foo(self):
        print('MyClass.foo')
my_class_obj=MyClass()

將上面的代碼保存在文件 tests1.py 中，而後這樣使用：code

from .tests1 import my_class_obj
my_class_obj.foo()

使用 `new`

爲了使類只能出現一個實例，咱們可使用 __new__ 來控制實例的建立過程，代碼以下：htm

class MyClass(object):
    _instance = None
    def __new__(cls, *args, **kwargs):
        if not cls._instance:
            cls._instance = super(MyClass, cls).__new__(cls, *args, **kwargs)
        return cls._instance

class HerClass(MyClass):
    a = 1

在上面的代碼中，咱們將類的實例和一個類變量 _instance 關聯起來，若是 cls._instance 爲 None 則建立實例，不然直接返回 cls._instance。對象

執行狀況以下：

one = HerClass()
two = HerClass()
print(one == two)   #True
print(one is two)   #True
print(id(one), id(two)) #42818864 42818864

使用裝飾器

咱們知道，裝飾器（decorator）能夠動態地修改一個類或函數的功能。這裏，咱們也可使用裝飾器來裝飾某個類，使其只能生成一個實例，代碼以下：

from functools import wraps


def singleton(cls):
    instances = {}

    @wraps(cls)
    def getinstance(*args, **kwargs):
        if cls not in instances:
            instances[cls] = cls(*args, **kwargs)
        return instances[cls]

    return getinstance


@singleton
class MyClass(object):
    a = 1

在上面，咱們定義了一個裝飾器 singleton，它返回了一個內部函數 getinstance，該函數會判斷某個類是否在字典 instances 中，若是不存在，則會將 cls 做爲 key，cls(*args, **kw) 做爲 value 存到 instances 中，不然，直接返回 instances[cls]。

使用 metaclass

元類（metaclass）能夠控制類的建立過程，它主要作三件事：

攔截類的建立
修改類的定義
返回修改後的類

使用元類實現單例模式的代碼以下：

class Singleton(type):
    _instances = {}

    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
        return cls._instances[cls]


# Python2
# class MyClass(object):
#     __metaclass__ = Singleton

# Python3
class MyClass(metaclass=Singleton):
   pass

優勢：

1、實例控制

單例模式會阻止其餘對象實例化其本身的單例對象的副本，從而確保全部對象都訪問惟一實例。

2、靈活性

由於類控制了實例化過程，因此類能夠靈活更改實例化過程。

缺點：

1、開銷

雖然數量不多，但若是每次對象請求引用時都要檢查是否存在類的實例，將仍然須要一些開銷。能夠經過使用靜態初始化解決此問題。

2、可能的開發混淆

使用單例對象（尤爲在類庫中定義的對象）時，開發人員必須記住本身不能使用 new關鍵字實例化對象。由於可能沒法訪問庫源代碼，所以應用程序開發人員可能會意外發現本身沒法直接實例化此類。

3、對象生存期

不能解決刪除單個對象的問題。在提供內存管理的語言中（例如基於.NET Framework的語言），只有單例類可以致使實例被取消分配，由於它包含對該實例的私有引用。在某些語言中（如 C++），其餘類能夠刪除對象實例，但這樣會致使單例類中出現懸浮引用。

補充：元類(metaclass)

類也是對象

只要你使用關鍵字class，Python解釋器在執行的時候就會建立一個對象。

下面的代碼段：

class MyClass(object):
    pass

將在內存中建立一個對象，名字就是MyClass。這個對象（類）自身擁有建立對象（類實例）的能力，而這就是爲何它是一個類的緣由。可是，它的本質仍然是一個對象，因而乎你能夠對它作以下的操做：

1) 你能夠將它賦值給一個變量

2) 你能夠拷貝它

3) 你能夠爲它增長屬性

4) 你能夠將它做爲函數參數進行傳遞

class MyClass(object):
    pass


print(MyClass)     # 你能夠打印一個類，由於它其實也是一個對象
# <class '__main__.MyClass'>

def echo(o):
    print(o)
echo(MyClass)       # 你能夠將類作爲參數傳給函數
# <class '__main__.MyClass'>

MyClass.new_attribute = 'foo'   #  你能夠爲類增長屬性
print(hasattr(MyClass,'new_attribute')) #True
print(MyClass.new_attribute)    #foo

MyClassMirror=MyClass　　　　# 你能夠將類賦值給一個變量
print(MyClassMirror())
# <__main__.MyClass object at 0x00000000028CDE10>

動態地建立類

由於類也是對象，你能夠在運行時動態的建立它們，就像其餘任何對象同樣。首先，你能夠在函數中建立類，使用class關鍵字便可。

def choose_class(name):
    if name == 'foo':
        class Foo(object):
            pass
        return Foo  # 返回的是類，不是類的實例
    else:
        class Bar(object):
            pass

        return Bar

MyClass = choose_class('foo')
print(MyClass)      # 函數返回的是類，不是類的實例
# <class '__main__.choose_class.<locals>.Foo'>

print(MyClass())    # 你能夠經過這個類建立類實例，也就是對象
# <__main__.choose_class.<locals>.Foo object at 0x00000000021E5CF8>

但這還不夠動態。

因爲類也是對象，因此它們必須是經過什麼東西來生成的纔對。

還記得內建函數type嗎？這個古老但強大的函數可以讓你知道一個對象的類型是什麼，就像這樣：

print(type(1))          #<class 'int'>
print(type('1'))        #<class 'str'>
print(type(MyClass))    #<class 'type'>
print(type(MyClass()))  #<class '__main__.MyClass'>

type也能動態的建立類。

type能夠像這樣工做：

type(類名, 父類的元組（針對繼承的狀況，能夠爲空），包含屬性的字典（名稱和值）)

好比下面的代碼：

class MyShinyClass(object):
    pass

能夠手動像這樣建立：

MyShinyClass=type('MyShinyClass',(),{})     # 返回一個類對象
print(MyShinyClass)     
# <class '__main__.MyShinyClass'>

print(MyShinyClass())   #  建立一個該類的實例
# <__main__.MyShinyClass object at 0x0000000002737D68>

type 接受一個字典來爲類定義屬性，所以：

class Foo(object):
    bar=True

能夠翻譯爲：

Foo = type('Foo', (), {'bar':True})

而且能夠將Foo當成一個普通的類同樣使用：

class Foo(object):
    bar=True

print(Foo)      #<class '__main__.Foo'>
print(Foo.bar)  #True
f=Foo()         
print(f)        #<__main__.Foo object at 0x0000000001F7DE10>
print(f.bar)    #True

固然，你能夠向這個類繼承，因此，以下的代碼：

class FooChild(Foo):
    pass

就能夠寫成：

class Foo(object):
    bar=True

FooChild = type('FooChild', (Foo,),{})
print(FooChild)
# <class '__main__.FooChild'>

print(FooChild.bar)     # bar屬性是由Foo繼承而來
# True

最終你會但願爲你的類增長方法。只須要定義一個有着恰當簽名的函數並將其做爲屬性賦值就能夠了。

class Foo(object):
    bar=True

def echo_bar(self):
    print(self.bar)

FooChild = type('FooChild', (Foo,), {'echo_bar': echo_bar})
print(hasattr(Foo, 'echo_bar'))         #False
print(hasattr(FooChild, 'echo_bar'))    #True
my_foo = FooChild()
my_foo.echo_bar()   #True

你能夠看到，在Python中，類也是對象，你能夠動態的建立類。這就是當你使用關鍵字class時Python在幕後作的事情，而這就是經過元類來實現的。

到底什麼是元類

元類就是用來建立類的「東西」。元類就是類的類。

函數type其實是一個元類。type就是Python在背後用來建立全部類的元類。

type就是建立類對象的類。你能夠經過檢查__class__屬性來看到這一點。

Python中全部的東西，注意，我是指全部的東西——都是對象。這包括整數、字符串、函數以及類。它們所有都是對象，並且它們都是從一個類建立而來。

age = 35
print(age.__class__)    #<class 'int'>

name = 'bob'
print(name.__class__)   #<class 'str'>

def foo():
    pass
print(foo.__class__)    #<class 'function'>

class Bar(object):
    pass
b = Bar()
print(b.__class__)      #<class '__main__.Bar'>

如今，對於任何一個__class__的__class__屬性又是什麼呢？

print(age.__class__.__class__)  #<class 'type'>
print(name.__class__.__class__) #<class 'type'>
print(foo.__class__.__class__)  #<class 'type'>
print(b.__class__.__class__)    #<class 'type'>

所以，元類就是建立類這種對象的東西。

type就是Python的內建元類，固然了，你也能夠建立本身的元類。

__metaclass__屬性

你能夠在寫一個類的時候爲其添加__metaclass__屬性。

class Foo(object):
    __metaclass__ = something...

若是你這麼作了，Python就會用元類來建立類Foo。當心點，這裏面有些技巧。你首先寫下class Foo(object)，可是類對象Foo尚未在內存中建立。Python會在類的定義中尋找__metaclass__屬性，若是找到了，Python就會用它來建立類Foo，若是沒有找到，就會用內建的type來建立這個類。

當你寫以下代碼時 :

class Foo(Bar):
    pass

Python作了以下的操做：

Foo中有__metaclass__這個屬性嗎？若是是，Python會在內存中經過__metaclass__建立一個名字爲Foo的類對象（我說的是類對象，請緊跟個人思路）。若是Python沒有找到__metaclass__，它會繼續在Bar（父類）中尋找__metaclass__屬性，並嘗試作和前面一樣的操做。若是Python在任何父類中都找不到__metaclass__，它就會在模塊層次中去尋找__metaclass__，並嘗試作一樣的操做。若是仍是找不到__metaclass__,Python就會用內置的type來建立這個類對象。

如今的問題就是，你能夠在__metaclass__中放置些什麼代碼呢？

答案就是：能夠建立一個類的東西。那麼什麼能夠用來建立一個類呢？type，或者任何使用到type或者子類化type的東東均可以。

內容：自定義元類、爲何要用metaclass類而不是函數?、究竟爲何要使用元類？

參考博文：http://blog.jobbole.com/21351/