python類單例

1. 說說 python 的元編程

提到元這個字，你也許會想到元數據，元數據就是描述數據本身的數據，元類就是類的類，相應的元編程就是描述代碼本身的代碼，元編程就是關於創建操作源代碼(比如修改、生成或包裝原來的代碼)的函數和類。主要技術是使用裝飾器、元類、描述符類。

本文的主要目的是向大家介紹這些元編程技術，並且給出實例來演示它們是怎樣定製化源代碼的行為。

裝飾器 裝飾器就是函數的函數，它接受一個函數作為參數並返回一個新的函數，在不改變原來函數代碼的情況下為其增加新的功能，比如最常用的計時裝飾器：

from functools import wrapsdef timeit(logger=None):"""耗時統計裝飾器，單位是秒，保留 4 位小數"""def decorator(func):@wraps(func)def wrapper(*args, **kwargs):start = time.time()result = func(*args, **kwargs)end = time.time()if logger:logger.info(f"{func.__name__} cost {end - start :.4f} seconds")else:print(f"{func.__name__} cost {end - start :.4f} seconds")return resultreturn wrapperreturn decorator

(註：比如上面使用 @wraps(func) 註解是很重要的， 它能保留原始函數的元數據) 只需要在原來的函數上面加上 @timeit() 即可為其增加新的功能：

@timeit()def test_timeit():time.sleep(1)test_timeit()#test_timeit cost 1.0026 seconds

上面的代碼跟下面這樣寫的效果是一樣的：

test_timeit = timeit(test_timeit)test_timeit()

裝飾器的執行順序 當有多個裝飾器的時候，他們的調用順序是怎麼樣的？

假如有這樣的代碼，請問是先列印 Decorator1 還是 Decorator2 ?

from functools import wrapsdef decorator1(func):@wraps(func)def wrapper(*args, **kwargs):print('Decorator 1')return func(*args, **kwargs)return wrapperdef decorator2(func):@wraps(func)def wrapper(*args, **kwargs):print('Decorator 2')return func(*args, **kwargs)return wrapper@decorator1@decorator2def add(x, y):return x + yadd(1,2)# Decorator 1# Decorator 2

回答這個問題之前，我先給你打個形象的比喻，裝飾器就像函數在穿衣服，離它最近的最先穿，離得遠的最後穿，上例中 decorator1 是外套，decorator2 是內衣。

add = decorator1(decorator2(add))

在調用函數的時候，就像脫衣服，先解除最外面的 decorator1，也就是先列印 Decorator1，執行到 return func(

args, kwargs) 的時候會去解除 decorator2，然後列印 Decorator2，再次執行到 return func(

args, kwargs) 時會真正執行 add() 函數。

需要注意的是列印的位置，如果列印字元串的代碼位於調用函數之後，像下面這樣，那輸出的結果正好相反：

def decorator1(func):@wraps(func)def wrapper(*args, **kwargs):result = func(*args, **kwargs)print('Decorator 1')return resultreturn wrapperdef decorator2(func):@wraps(func)def wrapper(*args, **kwargs):result = func(*args, **kwargs)print('Decorator 2')return resultreturn wrapper

裝飾器不僅可以定義為函數，也可以定義為類，只要你確保它實現了__call__() 和 __get__() 方法。

元類 Python 中所有類（object）的元類，就是 type 類，也就是說 Python 類的創建行為由默認的 type 類控制，打個比喻，type 類是所有類的祖先。我們可以通過編程的方式來實現自定義的一些對象創建行為。

定一個類繼承 type 類 A，然後讓其他類的元類指向 A，就可以控制 A 的創建行為。典型的就是使用元類實現一個單例：

class Singleton(type):def __init__(self, *args, **kwargs):self._instance = Nonesuper().__init__(*args, **kwargs)def __call__(self, *args, **kwargs):if self._instance is None:self._instance = super().__call__(*args, **kwargs)return self._instanceelse:return self._instanceclass Spam(metaclass=Singleton):def __init__(self):print("Spam!!!")

元類 Singleton 的__init__和__new__ 方法會在定義 Spam 的期間被執行，而 __call__方法會在實例化 Spam 的時候執行。

descriptor 類（描述符類）

descriptor 就是任何一個定義了 __get__()，__set__()或 __delete__()的對象，描述器讓對象能夠自定義屬性查找、存儲和刪除的操作。這里舉官方文檔[1]一個自定義驗證器的例子。

定義驗證器類，它是一個描述符類，同時還是一個抽象類：

from abc import ABC, abstractmethodclass Validator(ABC):def __set_name__(self, owner, name):self.private_name = '_' + namedef __get__(self, obj, objtype=None):return getattr(obj, self.private_name)def __set__(self, obj, value):self.validate(value)setattr(obj, self.private_name, value)@abstractmethoddef validate(self, value):pass

自定義驗證器需要從 Validator 繼承，並且必須提供 validate() 方法以根據需要測試各種約束。

這是三個實用的數據驗證工具：

OneOf 驗證值是一組受約束的選項之一。

class OneOf(Validator):def __init__(self, *options):self.options = set(options)def validate(self, value):if value not in self.options:raise ValueError(f'Expected {value!r} to be one of {self.options!r}')

Number 驗證值是否為 int 或 float。根據可選參數，它還可以驗證值在給定的最小值或最大值之間。

class Number(Validator):def __init__(self, minvalue=None, maxvalue=None):self.minvalue = minvalueself.maxvalue = maxvaluedef validate(self, value):if not isinstance(value, (int, float)):raise TypeError(f'Expected {value!r} to be an int or float')if self.minvalue is not None and value < self.minvalue:raise ValueError(f'Expected {value!r} to be at least {self.minvalue!r}')if self.maxvalue is not None and value > self.maxvalue:raise ValueError(f'Expected {value!r} to be no more than {self.maxvalue!r}')

String 驗證值是否為 str。根據可選參數，它可以驗證給定的最小或最大長度。它還可以驗證用戶定義的 predicate。

class String(Validator):def __init__(self, minsize=None, maxsize=None, predicate=None):self.minsize = minsizeself.maxsize = maxsizeself.predicate = predicatedef validate(self, value):if not isinstance(value, str):raise TypeError(f'Expected {value!r} to be an str')if self.minsize is not None and len(value) < self.minsize:raise ValueError(f'Expected {value!r} to be no smaller than {self.minsize!r}')if self.maxsize is not None and len(value) > self.maxsize:raise ValueError(f'Expected {value!r} to be no bigger than {self.maxsize!r}')if self.predicate is not None and not self.predicate(value):raise ValueError(f'Expected {self.predicate} to be true for {value!r}')

實際應用時這樣寫：

@timeit()def test_timeit():time.sleep(1)test_timeit()#test_timeit cost 1.0026 seconds0

描述器阻止無效實例的創建：

@timeit()def test_timeit():time.sleep(1)test_timeit()#test_timeit cost 1.0026 seconds1

最後的話 關於 Python 的元編程，總結如下：

如果希望某些函數擁有相同的功能，希望不改變原有的調用方式、不寫重復代碼、易維護，可以使用裝飾器來實現。

如果希望某一些類擁有某些相同的特性，或者在類定義實現對其的控制，我們可以自定義一個元類，然後讓它類的元類指向該類。

如果希望實例的屬性擁有某些共同的特點，就可以自定義一個描述符類。

以上就是本次分享的所有內容，如果你覺得文章還不錯，歡迎關注公眾號：Python編程學習圈，每日干貨分享，內容覆蓋Python電子書、教程、資料庫編程、Django，爬蟲，雲計算等等。或是前往編程學習網，了解更多編程技術知識。

原文：https://juejin.cn/post/7122297118911365134

2. python 怎麼判斷一個類是否被實例化，能給出代碼學習下嗎，謝謝！

這個類似於單例模式吧

print '----------------------方法1--------------------------'
#方法1,實現__new__方法
#並在將一個類的實例綁定到類變數_instance上,
#如果cls._instance為None說明該類還沒有實例化過,實例化該類,並返回
#如果cls._instance不為None,直接返回cls._instance
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

one = MyClass()
two = MyClass()

two.a = 3
print one.a
#3
#one和two完全相同,可以用id(), ==, is檢測
print id(one)
#29097904
print id(two)
#29097904
print one == two
#True
print one is two
#True

3. 詳解Python中的__new__、__init__、__call__三個特殊方法

__new__： 對象的創建，是一個靜態方法，第一個參數是cls。(想想也是，不可能是self，對象還沒創建，哪來的self)
__init__ ： 對象的旦胡初始化， 是一個實例方法，第一個參數是self。
__call__ ： 對象可call，注意不是類，是對象。

先有創建，才有初始化。即先__new__，而後__init__。
上面說的不好理解，看例子。

1.對於__new__

可以看到，輸出來是一個Bar對象。

__new__方法在類定義中不是必須寫的，如果沒定義，默認會調用object.__new__去創建一個對象。如果定義了，就是override,可以custom創建對象的行為。
聰明的讀者可能想到，既然__new__可以custom對象的創建，那我在這里做一下手腳，每次創建對象都返回同一個，那不就是單例模式了嗎？沒錯，就是這樣。可以觀摩《飄逸的模培攔python - 單例中返模式亂彈》
定義單例模式時，因為自定義的__new__重載了父類的__new__，所以要自己顯式調用父類的__new__，即object.__new__(cls, *args, **kwargs)，或者用super()。，不然就不是extend原來的實例了，而是替換原來的實例。

2.對於__init__

使用Python寫過面向對象的代碼的同學，可能對 __init__ 方法已經非常熟悉了，__init__ 方法通常用在初始化一個類實例的時候。例如：

這樣便是__init__最普通的用法了。但__init__其實不是實例化一個類的時候第一個被調用 的方法。當使用 Persion(name, age) 這樣的表達式來實例化一個類時，最先被調用的方法 其實是 __new__ 方法。

3.對於__call__
對象通過提供__call__(slef, [,*args [,**kwargs]])方法可以模擬函數的行為，如果一個對象x提供了該方法，就可以像函數一樣使用它，也就是說x(arg1, arg2...) 等同於調用x.__call__(self, arg1, arg2) 。模擬函數的對象可以用於創建防函數(functor) 或代理(proxy).

總結，在Python中，類的行為就是這樣，__new__、__init__、__call__等方法不是必須寫的，會默認調用，如果自己定義了，就是override,可以custom。既然override了，通常也會顯式調用進行補償以達到extend的目的。
這也是為什麼會出現"明明定義def _init__(self, *args, **kwargs)，對象怎麼不進行初始化"這種看起來詭異的行為。（注，這里_init__少寫了個下劃線，因為__init__不是必須寫的，所以這里不會報錯，而是當做一個新的方法_init__）

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

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

5. 怎麼理解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關鍵字一樣

總結

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