單例模式python

A. python 單例

這個問題問得好。老實說，我也很少這樣做。通常寫在def外class里的變數是可以直接用class名引用的。這個本身就是全局的。沒有實例化，直接引用的時候，它是唯一的。至於實例化反而會置空了。

czzczz001這個朋友的代碼也是說明了這個問題，引用這個變數a的時候要用類名去引用。而不是實例去引用。

單例模式我的開發經驗里用得少。通常都是全局變數或者是參數傳遞來代替的。象這樣的隱性的單例模式，不如用顯式的全局變數更清晰。或者是類雖然是多個實例的，不過由於引用的變數是全局的，所以也有單例相似的效果。這樣也可以。以前用C++的時候也經常這樣用。

B. Python如何實現單例模式

有些時候你的項目中難免需要一些全局唯一的對象,這些對象大多是一些工具性的東西,在Python中實現單例模式並不是什麼難事。以下總結幾種方法:
使用類裝飾器
使用裝飾器實現單例類的時候,類本身並不知道自己是單例的,所以寫代碼的人可以不care這個,只要正常寫自己的類的實現就可以,類的單例有裝飾器保證。
def singleton(cls):
instances = {}
def _wrapper(*args, **kwargs):
if cls not in instances:
instances[cls] = cls(*args, **kwargs)
return instances[cls]
return _wrapper
你會發現singleton裝飾器內部使用了一個dict。當然你也可以用其他的方式,不過以下的實現是錯誤的:
def singleton(cls):
_instance = None #外部作用域的引用對於嵌套的內部作用域是只讀的
def _wrapper(*args, **kwargs):
if _instance is None: #解釋器會拋出"UnboundLocalError: ...referenced before assignment"
_instance = cls(*args, **kwargs) #賦值行為使解釋器將"_instance"看作局部變數
return _instance
return _wrapper
使用元類(__metaclass__)和可調用對象(__call__)
Python的對象系統中一些皆對象,類也不例外,可以稱之為」類型對象」,比較繞,但仔細思考也不難:類本身也是一種對象,只不過這種對象很特殊,它表示某一種類型。是對象,那必然是實例化來的,那麼誰實例化後是這種類型對象呢?也就是元類。
Python中,class關鍵字表示定義一個類對象,此時解釋器會按一定規則尋找__metaclass__,如果找到了,就調用對應的元類實現來實例化該類對象;沒找到,就會調用type元類來實例化該類對象。
__call__是Python的魔術方法,Python的面向對象是」Duck type」的,意味著對象的行為可以通過實現協議來實現,可以看作是一種特殊的介面形式。某個類實現了__call__方法意味著該類的對象是可調用的,可以想像函數調用的樣子。再考慮一下foo=Foo()這種實例化的形式,是不是很像啊。結合元類的概念,可以看出,Foo類是單例的,則在調用Foo()的時候每次都返回了同樣的對象。而Foo作為一個類對象是單例的,意味著它的類(即生成它的元類)是實現了__call__方法的。所以可以如下實現:
class Singleton(type):
def __init__(cls, name, bases, attrs):
super(Singleton, cls).__init__(name, bases, attrs)
cls._instance = None
def __call__(cls, *args, **kwargs):
if cls._instance is None
# 以下不要使用'cls._instance = cls(*args, **kwargs)', 防止死循環,
# cls的調用行為已經被當前'__call__'協議攔截了
# 使用super(Singleton, cls).__call__來生成cls的實例
cls._instance = super(Singleton, cls).__call__(*args, **kwargs)
return cls._instance

class Foo(object): #單例類
__metaclass__ = Singleton

>>>a = Foo()
>>>b = Foo()
>>>a is b
>>>True
>>>a.x = 1
>>>b.x
>>>1
使用__new__
__init__不是Python對象的構造方法,__init__只負責初始化實例對象,在調用__init__方法之前,會首先調用__new__方法生成對象,可以認為__new__方法充當了構造方法的角色。所以可以在__new__中加以控制,使得某個類只生成唯一對象。具體實現時可以實現一個父類,重載__new__方法,單例類只需要繼承這個父類就好。
class Singleton(object):
def __new__(cls, *args, **kwargs):
if not hasattr(cls, '_instance'):
cls._instance = super(Singleton, cls).__new__(cls, *args, **kwargs)
return cls._instance

class Foo(Singleton): #單例類
a = 1

C. Python中的單例模式的幾種實現方式的及優化

單例模式就是 ： 1、類的構造函數為private，即外部程序不能通過new關鍵字創建對象的實例 2、類中提供一個private static的 類變數引用 ； 3、單例類中提供靜態方法 定義為 public static 的方法獲取一個類的實例 ； 4、靜態方法返回 類的引用，...

D. 關於python單例模式求教大佬

因為在__new__函數里給__instance賦了新值_
__new__函數的作用就是，如果__instance還是None，就給cls.__instance新值，然後返回 __instance的值

E. python常用的幾種設計模式是什麼

單例模式：是一種常用的軟體設計模式，該模式的主要目的是確保某一個類只有一個實例存在。當你希望在整個系統中，某個類只能出現一個是實例時，單例對象就能派上用場。單例對象的要點有三個：一是某個類只能有一個實例;二是它必須自行創建整個實例，三是它必須自行向整個系統提供這個實例。
工廠模式：提供一個創建對象的介面，不像客戶端暴露創建對象的過程，使用一個公共的介面來創建對象，可以分為三種：簡單工廠、工廠方法、抽象工廠。一個類的行為或其演算法可以在運行時更改，這種類型的設計模式屬於行為型模式。
策略模式：是常見的設計模式之一，它是指對一系列的演算法定義，並將每一個演算法封裝起來，而且使它們還可以相互替換。策略模式讓演算法獨立於使用它的客戶而獨立變化。換句話來講，就是針對一個問題而定義出一個解決的模板，這個模板就是具體的策略，每個策略都是按照這個模板進行的，這種情況下我們有新的策略時就可以直接按照模板來寫，而不會影響之前已經定義好的策略。
門面模式：門面模式也被稱作外觀模式。定義如下：要求一個子系統的外部與其內部的通信必須通過一個統一的對象進行。門面模式提供一個高層次的介面，使得子系統更易於使用。門面模式注重統一的對象，也就是提供一個訪問子系統的介面。門面模式與模板模式有相似的地方，都是對一些需要重復方法的封裝。但本質上是不同的，模板模式是對類本身的方法的封裝，其被封裝的方法也可以單獨使用;門面模式，是對子系統的封裝，其被封裝的介面理論上是不會被單獨提出來使用的。

F. 怎麼理解python單例模式

在聊這之前我們首先要明確的是，單例模式在實際中的意義以及在python中具有實現的價值？

當前，相信有很多人支持單例模式，也有不少人反對，尤其是在python中，目前依舊具有很大的爭議性。我們要在評論之前首先要了解單例模式

什麼是單例模式？

顧名思義：就是單個模式

單例模式是一種常見的軟體設置模式，在它的核心結構中只包含一個被稱為單例類的特殊類，通過單例模式可以保證系統中的一個類只有一個實例而且該實例易於外界訪問，從而方便對實例個數的控制並節約系統資源。如果希望在系統中某個對象只能存在一個，單例模式是最好的解決方案。

單例模式的要點有三類

• 某個類只能有一個實例

• 它必須創建這個實例

• 它必須自行向整個系統提供這個實例

但是從具體角度實現來說的話，又可以分為三點

• 單例模式的類只能提供私有的構造函數

• 類定義中含有一個該類的靜態私有對象

• 該類提供了一個靜態的共有的函數用於創建或獲取它本身的靜態私有對象

一、實例控制

單例模式會阻止其他對象實例化其自己的單例對象的副本，從而確保所有對象都訪問唯一實例。

二、靈活性

因為類控制了實例化過程，所以類可以靈活更改實例化過程。

缺點：

一、開銷

雖然數量很少，但如果每次對象請求引用時都要檢查是否存在類的實例，將仍然需要一些開銷。可以通過使用靜態初始化解決此問題。

二、可能的開發混淆

使用單例對象（尤其在類庫中定義的對象）時，開發人員必須記住自己不能使用new關鍵字實例化對象。因為可能無法訪問庫源代碼，因此應用程序開發人員可能會意外發現自己無法直接實例化此類。

三、對象生存期

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

常用幾種方式

通過面向的特性，簡單的構造出單例模式

123456789101112131415
# ########### 單例類定義 ###########classFoo(object):__instance=None@staticmethoddefsingleton():ifFoo.__instance:returnFoo.__instanceelse:Foo.__instance=Foo()returnFoo.__instance# ########### 獲取實例 ###########obj=Foo.singleton()

當用於WEB界面時，單例模式的簡單運用

web 單例模式

不過我們需要注意的是：

特殊方法__new__是一個元構造程序，每當一個對象必須被factory類實例化時，就將調用它。__new__方法必須返回一個類的實例，因此它可以在對象創建之前或之後修改類。

因為__init__在子類中不會被隱式調用，所以__new__可以用來確定已經在整個類層次完成了初始化構造。__new__是對於對象狀態隱式初始化需求的回應，使得可以在比__init__更低的一個層次上定義一個初始化，這個初始化總是會被調用。

與__init__()相比__new__()方法更像一個真正的構造器。隨著類和類型的統一，用戶可以對內建類型進行派生，因此需要一種途徑來實例化不可變對象，比如派生字元串，在這種情況下解釋器則調用類的__new__（）方法，一個靜態方法，並且傳入的參數是在類實例化操作時生成的。__new__()會調用父類的__new__()來創建對象（向上代理）
·__new__必須返回一個合法的實例，這樣解釋器在調用__init__()時，就可以吧這個實例作為self傳給他。調用父類的__new__（）來創建對象，正向其他語言使用new關鍵字一樣

總結

單利模式存在的目的是保證當前內存中僅存在單個實例，避免內存浪費！！！

G. 請教Python 使用裝飾器實現單例模式的原理

簡單來講，可以不嚴謹地把Python的裝飾器看做一個包裝函數的函數。 比如，有一個函數： def func(): print 'func() run.' if '__main__' == __name__: func() 運行後將輸出: func() run. 現在需要在函數運行前後列印一條日誌

H. Python有設計模式么

單例模式：Python 的單例模式最好不要藉助類（在 Java 中藉助類是因為 Java 所有代碼都要寫在類中），而是通過一個模塊來實現。一個模塊的模塊內全局變數、模塊內全局函數，組合起來就是一個單例對象了。
模板方法模式：這個可以像其他語言一樣實現，但是如果要遵循鴨子類型原則的話，應該刪除公有的抽象父類（或介面），從而追求靈活性。
工廠方法模式、多例模式：這個也不用藉助類，直接寫一個全局函數作為工廠函數即可。因為 Python 中實例化是通過 call 類來完成的，現在改成 call 工廠函數，對客戶摳碼者是透明的。（從這點我表示理解 Python 沒有 new 操作符的好處了，使用通用的 call 定義，正交性極強）
裝飾器模式、代理模式：這個接觸過 Python 就不會不知道了，Python 內置的 decorator 語法如此著名。裝飾器模式和代理模式都可以通過這種方式完成。另外一種是對對象的裝飾或代理，這個也不需要按照契約編程的風格，讓代理對象實現被代理對象的抽象。一切動態代理，只需要通過重載屬性訪問操作符，神馬都簡單了（和 PHP 通過 __get、__set、__call 來實現動態代理很類似）。
原型模式：這個在 Python 中實現的不是那麼爽快，需要調用 來克隆原型對象。但是其實有另一種實現方式：之所以使用原型模式，是因為對象初始化需要較大開銷。我們只需要保存初始化的結果，並在產生新對象的時候賦予新對象即可。所以，通過元類控制對象被創建的過程，來實現原型模式，也是一種選擇。