有關(guān) Python 內(nèi)編寫類的各種技巧和方法(構(gòu)建和初始化、重載操作符、類描述、屬性訪問控制、自定義序列、反射機制、可調(diào)用對象、上下文管理、構(gòu)建描述符對象、Pickling)。你可以把它當(dāng)作一個教程，進階，或者使用參考；我希望它能夠成為一份針對 Python 方法的用戶友好指南。

內(nèi)容目錄

介紹
構(gòu)建和初始化
使操作符在自定義類內(nèi)工作
神奇方法——比較
神奇方法——數(shù)字
描述你的類
屬性訪問控制
制作自定義序列
反射
可調(diào)用對象
上下文管理
構(gòu)建描述符對象
Pickling 你的對象

總結(jié)
附錄：如何調(diào)用神奇方法

1.介紹

這份指南是幾個月內(nèi)最有價值的 Blog 投稿精華。它的主題是向大家講述 Python 中的神奇方法。

何為神奇方法呢？它們是面向 Python 中的一切，是一些特殊的方法允許在自己的定義類中定義增加“神奇”的功能。它們總是使用雙下劃線(比如 __ init__ 或 __ lt__)，但它們的文檔沒有很好地把它們表現(xiàn)出來。所有這些神奇方法都出現(xiàn)在Python的官方文檔中，但內(nèi)容相對分散，組織結(jié)構(gòu)也顯得松散。還有你會難以發(fā)現(xiàn)一個實例(雖然他們被設(shè)計很棒，在語言參考中被詳細描述，可之后就會伴隨著枯燥的語法描述等)。

所以，為了解決我認為在 Python 文檔中的一大敗筆，我打算用更多純英語，實例驅(qū)動的文檔來說明 Python 的神奇方法。然后我就開始花了幾周的時間來寫 blog，而現(xiàn)在我已經(jīng)完成了它們，并將它們合訂成一份指南。

我希望你喜歡它。把它當(dāng)作一個教程，進階，或者使用參考；我希望它能夠成為一份針對 Python 方法的用戶友好指南。

2.構(gòu)建和初始化

相信大家都熟悉這個最基礎(chǔ)的神奇方法 __ init__。它令你能自定義一個對象的初始化行為。而當(dāng)我調(diào)用x=SomeClass() 時，?init?并不是最先被調(diào)用的。實際上有一個叫做?new?的方法，事實上是它創(chuàng)建了實例，它傳遞任何參數(shù)給初始化程序來達到創(chuàng)建的目的。在對象生命周期結(jié)束時，調(diào)用?del。讓我們更近地觀察下這 3 個神奇方法吧：

• __ new__(cls,[...)

一個對象的實例化時 __ new__ 是第一個被調(diào)用的方法。在類中傳遞其他任何參數(shù)到 __ init__。new很少被使用，這樣做確實有其目的，特別是當(dāng)一個子類繼承一個不可改變的類型(一個元組或一個字符串)時。我不打算再繼續(xù)深入追求?new?的細節(jié)了，因為這不會產(chǎn)生多大用處，因為在 Python Docs 內(nèi)已經(jīng)涵蓋了一份巨詳細的說明了。

• __ init__(self,[...)

類的初始化。它會獲得初始構(gòu)建調(diào)用傳過來的任何東西(舉例來說就是，當(dāng)我們調(diào)用x=SomeClass(10,'foo'),__ init__ 就會把傳過來的 10 和 'foo' 作為參數(shù)。init在 Python 的類定義中幾乎普遍被使用)

• __ del__(self)

如果 __ new__和?init?是對象的構(gòu)造器，那么?del?就是析構(gòu)器。它不實現(xiàn)聲明為del x(這樣的代碼不會解釋成 x. del())的行為。相反，它定義為當(dāng)一個對象被垃圾回收時的行為。這可能對可能需要額外清理的對象相當(dāng)有用，比如 sockets 或文件對象。但要小心，如果對象仍處于存活狀態(tài)而當(dāng)被解釋退出時，?del?沒有保證就會被執(zhí)行，因此這樣的?del?不能作為良好的編碼規(guī)范的替代。(就像當(dāng)你完成操作總是要關(guān)閉一次連接。但事實上，?del?幾乎永遠不會執(zhí)行，就因為它處于不安全情況被調(diào)用了。使用時保持警惕！)

把上述這些內(nèi)容合在一起，就成了一份 __ init__ 和 __ del__ 的實際使用用例：

from os.path import join
class FileObject:
'''對文件對象的包裝，確保文件在關(guān)閉時得到刪除'''

def __init__(self, filepath='~', filename='sample.txt'):
# 按filepath，讀寫模式打開名為filename的文件
self.file=open(join(filepath,filename), 'r+')

def __del__(self):
self.file.close()
del self.file

3.使操作符在自定義類內(nèi)工作

使用 Python 神奇方法的優(yōu)勢之一就是它提供了一種簡單的方式能讓對象的行為像內(nèi)建類型。這意味著你可以避免用丑陋，反直覺和非標(biāo)準(zhǔn)方法執(zhí)行基本運算。在某些語言中，通常會這樣做：

if instance.equals(other_instance):
# do something

你也應(yīng)該在 Python 確實會這樣做，但同時它會增加用戶的疑惑以及不必要的冗長。不同的庫可能會對相同的運算采用不同的命名，這使得用戶比平常干了更多的事。依靠神奇方法的力量，你可以定義一個方法(比如 __ eq__),然后帶代替我們真實的意圖：

if instance == other_instance:
# do something

現(xiàn)在你看到的是神奇方法力量的一部分。絕大多數(shù)都允許我們定義為運算符本身的意義，當(dāng)用在我們自己定義的類上就像它們是內(nèi)建類型。

3.1 神奇方法——比較

Python 有一整套神奇方法被設(shè)計用來通過操作符實現(xiàn)對象間直觀的比較，而非別扭的方法調(diào)用。它們同樣提供了一套覆蓋 Python 對象比較的默認行為(通過引用)。以下是這些方法的列表以及做法：

__ cmp__(self, other)

__ cmp__是神奇方法中最基礎(chǔ)的一個。實際上它實現(xiàn)所有比較操作符行為(cmp?應(yīng)當(dāng)返回一個負整數(shù)；如果 self == other，則返回 0；如果 self > other，則返回正整數(shù)。它通常是最好的定義，而不需要你一次就全定義好它們，但當(dāng)你需要用類似的準(zhǔn)則進行所有的比較時，?cmp?會是一個很好的方式，幫你節(jié)省重復(fù)性和提高明確度。

__ eq__(self, other)

定義了相等操作符，==的行為。

__ ne__(self, other)

定義了不相等操作符，!= 的行為。

__ lt__(self, other)

定義了小于操作符，< 的行為。

__ gt__(self, other)

定義了大于操作符，> 的行為。

__ le__(self, other)

定義了小于等于操作符，<=的行為。

__ ge__(self, other)

定義了大于等于操作符，>= 的行為。

舉一個例子，設(shè)想對單詞進行類定義。我們可能希望能夠按內(nèi)部對 string 的默認比較行為，即字典序(通過字母)來比較單詞，也希望能夠基于某些其他的準(zhǔn)則，像是長度或音節(jié)數(shù)。在本例中，我們通過單詞長度排序，以下給出實現(xiàn)：

class Word(str):
'''單詞類，比較定義是基于單詞長度的'''

def __new__(cls, word):
# 注意，我們使用了__new__,這是因為str是一個不可變類型，
# 所以我們必須更早地初始化它(在創(chuàng)建時)
if ' ' in word:
print "單詞內(nèi)含有空格，截斷到第一部分"
word = word[:word.index(' ')] # 在出現(xiàn)第一個空格之前全是字符了現(xiàn)在
return str.__new__(cls, word)

def __gt__(self, other):
return len(self) > len(other)
def __lt__(self, other):
return len(self) < len(other)
def __ge__(self, other):
return len(self) >= len(other)
def __le__(self, other):
return len(self) <= len(other)

現(xiàn)在，我們可以創(chuàng)建 2 個單詞(通過 Word('foo') 和 Word('bar'))并基于它們的長度進行比較了。注意，我們沒有定義 __ eq__ 和 __ ne__。這是因為這可能導(dǎo)致某些怪異的行為(特別是當(dāng)比較 Word('foo') == Word('bar') 將會得到 True 的結(jié)果)。基于單詞長度的相等比較會令人摸不清頭腦，因此我們就沿用了str 本身的相等比較的實現(xiàn)。

現(xiàn)在可能是一個好時機來提醒你一下，你不必重載每一個比較相關(guān)的神奇方法來獲得各種比較。標(biāo)準(zhǔn)庫已經(jīng)友好地為我們在模板 functools 中提供了一個裝飾(decorator)類，定義了所有比較方法。你可以只重載 __ eq__ 和一個其他的方法(比如 __ gt__, lt，等)。這個特性只在 Python2.7(后?)適用，但當(dāng)你有機會的話應(yīng)該嘗試一下，它會為你省下大量的時間和麻煩。你可以通過在你自己的重載方法在加上 @total_ordering 來使用。

3.2 神奇方法——數(shù)字

就像你可以通過重載比較操作符的途徑來創(chuàng)建你自己的類實例，你同樣可以重載數(shù)字操作符。系好你們的安全帶，朋友們，還有很多呢。處于本文組織的需要，我會把數(shù)字的神奇方法分割成5塊：一元操作符，常規(guī)算術(shù)操作符，反射算術(shù)操作符，增量賦值，類型轉(zhuǎn)換。

一元操作符

一元運算和函數(shù)僅有一個操作數(shù)，比如負數(shù)，絕對值等

__ pos__(self)

實現(xiàn)一元正數(shù)的行為(如：+some_object)

__ neg__(self)

實現(xiàn)負數(shù)的行為(如: -some_object)

__ abs__(self)

實現(xiàn)內(nèi)建 abs() 函數(shù)的行為

__ invert__(self)

實現(xiàn)用~操作符進行的取反行為。你可以參考 Wiki:bitwise operations 來解釋這個運算符究竟會干什么
常規(guī)算術(shù)操作符

現(xiàn)在我們涵蓋了基本的二元運算符:+，-，* 等等。其中大部分都是不言自明的。

__ add__(self, other)

實現(xiàn)加法

__ sub__(self, other)

實現(xiàn)減法

__ mul__(self, other)

實現(xiàn)乘法

__ floordiv__(self, other)

實現(xiàn)地板除法，使用 // 操作符

__ div__(self, other)

實現(xiàn)傳統(tǒng)除法，使用 / 操作符

__ truediv__(self, other)

實現(xiàn)真正除法。注意，只有當(dāng)你 from __ future__ import division 時才會有效

__ mod__(self, other)

實現(xiàn)求模，使用 % 操作符

__ divmod__(self, other)

實現(xiàn)內(nèi)建函數(shù) divmod() 的行為

__ pow__(self, other)

實現(xiàn)乘方，使用 ** 操作符

__ lshift__(self, other)

實現(xiàn)左按位位移，使用 << 操作符

__ rshift__(self, other)

實現(xiàn)右按位位移，使用 >> 操作符

__ and__(self, other)

實現(xiàn)按位與，使用 & 操作符

__ or__(self, other)

實現(xiàn)按位或，使用 | 操作符

__ xor__(self, other)

實現(xiàn)按位異或，使用 ^ 操作符

反射算術(shù)操作符

你知道我會如何解釋反射算術(shù)操作符？你們中的有些人或許會覺得它很大，很可怕，是國外的概念。但它實際上很簡單，下面給一個例子：

some_object + other

這是“常規(guī)的”加法。而反射其實相當(dāng)于一回事，除了操作數(shù)改變了改變下位置：

other + some_object

因此，所有這些神奇的方法會做同樣的事等價于常規(guī)算術(shù)操作符，除了改變操作數(shù)的位置關(guān)系，比如第一個操作數(shù)和自身作為第二個。此外沒有其他的操作方式。在大多數(shù)情況下，反射算術(shù)操作的結(jié)果等價于常規(guī)算術(shù)操作，所以你盡可以在剛重載完 __ radd__就調(diào)用?add。干脆痛快：

__radd__(self, other)

實現(xiàn)反射加法

__rsub__(self, other)

實現(xiàn)反射減法

__rmul__(self, other)

實現(xiàn)反射乘法

__rfloordiv__(self, other)

實現(xiàn)反射地板除，用 // 操作符

__rdiv__(self, other)

實現(xiàn)傳統(tǒng)除法，用 / 操作符

__rturediv__(self, other)

實現(xiàn)真實除法，注意，只有當(dāng)你 from __future__ import division 時才會有效

__rmod__(self, other)

實現(xiàn)反射求模，用 % 操作符

__rdivmod__(self, other)

實現(xiàn)內(nèi)置函數(shù) divmod() 的長除行為，當(dāng)調(diào)用 divmod(other,self) 時被調(diào)用

__rpow__(self, other)

實現(xiàn)反射乘方，用 ** 操作符

__rlshift__(self, other)

實現(xiàn)反射的左按位位移，使用 << 操作符

__rrshift__(self, other)

實現(xiàn)反射的右按位位移，使用 >> 操作符

__rand__(self, other)

實現(xiàn)反射的按位與，使用 & 操作符

__ror__(self, other)

實現(xiàn)反射的按位或，使用 | 操作符

__rxor__(self, other)

實現(xiàn)反射的按位異或，使用 ^ 操作符

增量賦值

Python 也有各種各樣的神奇方法允許用戶自定義增量賦值行為。你可能已經(jīng)熟悉增量賦值，它結(jié)合了“常規(guī)的”操作符和賦值。如果你仍不明白我在說什么，下面有一個例子：

x = 5
x += 1 # 等價 x = x + 1

這些方法都不會有返回值，因為賦值在 Python 中不會有任何返回值。反而它們只是改變類的狀態(tài)。列表如下：

__iadd__(self, other)

實現(xiàn)加法和賦值

__isub__(self, other)

實現(xiàn)減法和賦值

__imul__(self, other)

實現(xiàn)乘法和賦值

__ifloordiv__(self, other)

實現(xiàn)地板除和賦值，用 //= 操作符

__idiv__(self, other)

實現(xiàn)傳統(tǒng)除法和賦值，用 /= 操作符

__iturediv__(self, other)

實現(xiàn)真實除法和賦值，注意，只有當(dāng)你 from __future__ import division 時才會有效

__imod__(self, other)

實現(xiàn)求模和賦值，用 %= 操作符

__ipow__(self, other)

實現(xiàn)乘方和賦值，用 **= 操作符

__ilshift__(self, other)

實現(xiàn)左按位位移和賦值，使用 <<= 操作符

__irshift__(self, other)

實現(xiàn)右按位位移和賦值，使用 >>= 操作符

__iand__(self, other)

實現(xiàn)按位與和賦值，使用 &= 操作符

__ior__(self, other)

實現(xiàn)按位或和賦值，使用 |= 操作符

__ixor__(self, other)

實現(xiàn)按位異或和賦值，使用 ^= 操作符

類型轉(zhuǎn)換的神奇方法

Python 也有一組神奇方法被設(shè)計用來實現(xiàn)內(nèi)置類型轉(zhuǎn)換函數(shù)的行為，如 float()

__int__(self)

實現(xiàn)到 int 的類型轉(zhuǎn)換

__long__(self)

實現(xiàn)到 long 的類型轉(zhuǎn)換

__float__(self)

實現(xiàn)到 float 的類型轉(zhuǎn)換

__complex__(self)

實現(xiàn)到復(fù)數(shù)的類型轉(zhuǎn)換

__oct__(self)

實現(xiàn)到 8 進制的類型轉(zhuǎn)換

__hex__(self)

實現(xiàn)到 16 進制的類型轉(zhuǎn)換

__index__(self)

實現(xiàn)一個當(dāng)對象被切片到 int 的類型轉(zhuǎn)換。如果你自定義了一個數(shù)值類型，考慮到它可能被切片，所以你應(yīng)該重載__index__

__trunc__(self)

當(dāng) math.trunc(self) 被調(diào)用時調(diào)用。__trunc__ 應(yīng)當(dāng)返回一個整型的截斷，(通常是 long)

__coerce__(self, other)

該方法用來實現(xiàn)混合模式的算術(shù)。如果類型轉(zhuǎn)換不可能那 __coerce__ 應(yīng)當(dāng)返回 None。否則，它應(yīng)當(dāng)返回一對包含 self 和 other(2 元組)，且調(diào)整到具有相同的類型

4.描述你的類

用一個字符串來說明一個類這通常是有用的。在 Python 中提供了一些方法讓你可以在你自己的類中自定義內(nèi)建函數(shù)返回你的類行為的描述。

__str__(self)

當(dāng)你定義的類中一個實例調(diào)用了 str()，用于給它定義行為

__repr__(self)

當(dāng)你定義的類中一個實例調(diào)用了 repr()，用于給它定義行為。str() 和 repr() 主要的區(qū)別在于它的閱讀對象。repr() 產(chǎn)生的輸出主要為計算機可讀(在很多情況下，這甚至可能是一些有效的 Python 代碼)，而 str() 則是為了讓人類可讀。

__unicode__(self)

當(dāng)你定義的類中一個實例調(diào)用了 unicode()，用于給它定義行為。unicode() 像是 str(),只不過它返回一個 unicode 字符串。警惕！如果用戶用你的類中的一個實例調(diào)用了 str(),而你僅定義了 __unicode__(),那它是不會工作的。以防萬一，你應(yīng)當(dāng)總是定義好 __str__()，哪怕用戶不會使用 unicode

__hash__(self)

當(dāng)你定義的類中一個實例調(diào)用了 hash()，用于給它定義行為。它必須返回一個整型，而且它的結(jié)果是用于來在字典中作為快速鍵比對。

__nonzero__(self)

當(dāng)你定義的類中一個實例調(diào)用了 bool()，用于給它定義行為。返回 True 或 False，取決于你是否考慮一個實例是 True 或 False 的。

我們已經(jīng)相當(dāng)漂亮地干完了神奇方法無聊的部分(無示例)，至此我們已經(jīng)討論了一些基礎(chǔ)的神奇方法，是時候讓我們向高級話題移動了。

5.屬性訪問控制

有許多從其他語言陣營轉(zhuǎn)到 Python 來的人抱怨 Python 對類缺乏真正的封裝(比如，沒有辦法自定義 private 屬性，已經(jīng)給出 public 的 getter 和 setter)。這可不是真相喲：Python 通過神奇的方法實現(xiàn)了大量的封裝，而不是通過明確的方法或字段修飾符。

請看：

__ getattr__(self, name)

你可以為用戶在試圖訪問不存在(不論是存在或尚未建立)的類屬性時定義其行為。這對捕捉和重定向常見的拼寫錯誤，給出使用屬性警告是有用的(只要你愿意，你仍舊可選計算，返回那個屬性)或拋出一個 AttributeError異常。這個方法只適用于訪問一個不存在的屬性，所以，這不算一個真正封裝的解決之道。

__ setattr__(self, name, value)

不像 __ getattr__，?setattr?是一個封裝的解決方案。它允許你為一個屬性賦值時候的行為，不論這個屬性是否存在。這意味著你可以給屬性值的任意變化自定義規(guī)則。然而，你需要在意的是你要小心使用?setattr,在稍后的列表中會作為例子給出。

__ delattr__

這等價于 __ setattr__, 但是作為刪除類屬性而不是 set 它們。它需要相同的預(yù)防措施，就像?setattr，防止無限遞歸(當(dāng)在?delattr?中調(diào)用 del self.name 會引起無限遞歸)。

__ getattribute__(self, name)

__ getattribute__ 良好地適合它的同伴們 __ setattr__ 和 __ delattr__。可我卻不建議你使用它。?getattribute?只能在新式類中使用(在 Python 的最新版本中，所有的類都是新式類，在稍舊的版本中你可以通過繼承 object 類來創(chuàng)建一個新式類。它允許你定規(guī)則，在任何時候不管一個類屬性的值那時候是否可訪問的。) 它會因為他的同伴中的出錯連坐受到某些無限遞歸問題的困擾(這時你可以通過調(diào)用基類的?getattribute?方法來防止發(fā)生)。當(dāng)?getattribute?被實現(xiàn)而又只調(diào)用了該方法如果?getattribute?被顯式調(diào)用或拋出一個 AttributeError 異常，同時也主要避免了對?getattr?的依賴。這個方法可以使用(畢竟，這是你自己的選擇)，不過我不推薦它是因為它有一個小小的用例(雖說比較少見，但我們需要特殊行為以獲取一個值而不是賦值)以及它真的很難做到實現(xiàn) 0bug。

你可以很容易地在你自定義任何類屬性訪問方法時引發(fā)一個問題。參考這個例子：

def __setattr__(self, name, value):
self.name = value
# 當(dāng)每次給一個類屬性賦值時，會調(diào)用__setattr__(),這就形成了遞歸
# 因為它真正的含義是 self.__setattr__('name', value)
# 所以這方法不停地調(diào)用它自己，變成了一個無法退出的遞歸最終引發(fā)crash

def __setattr__(self, name, value):
self.__dict__[name] = value # 給字典中的name賦值
# 在此自定義行為

再一次，Python 的神奇方法向我們展示了其難以置信的能力，同時巨大的力量也伴隨著重大的責(zé)任。重要的是讓你明白正確使用神奇方法，這樣你就不會破壞其他代碼。

那么，我們在關(guān)于定制類屬性訪問中學(xué)習(xí)了什么？不要輕易地使用，事實上它過于強大以及反直覺。這也是它為何存在的理由：Python 尋求干壞事的可能性，但會把它們弄得很難。自由是至高無上的，所以你可以做任何你想做的事情。以下是一個關(guān)于特殊屬性訪問方法的實際例子(注意，我們使用 super 因為并非所有類都有 __ dict__類屬性)：

class AccessCounter:
'''一個類包含一個值和實現(xiàn)了一個訪問計數(shù)器。
當(dāng)值每次發(fā)生變化時，計數(shù)器+1'''

def __init__(self, val):
super(AccessCounter, self).__setattr__('counter',0)
super(AccessCounter, self).__setattr__('value', val)

def __setattr__(self, name, value):
if name == 'value':
super(AccessCounter, self).__setattr__('counter', self.counter + 1)
# Make this unconditional.
# 如果你想阻止其他屬性被創(chuàng)建，拋出AttributeError(name)異常
super(AccessCounter, self).__setattr__(name, value)

def __delattr__(self, name)
if name == 'value':
super(AccessCounter, self).__setattr__('counter', self.counter + 1)
super(AccessCounter, self).__delattr__(name)

6.制作自定義序列

很有多種方式可以讓你的類表現(xiàn)得像內(nèi)建序列(字典，元組，列表，字符串等)。這些是我迄今為止最喜歡的神奇方法了，因為不合理的控制它們賦予了你一種魔術(shù)般地讓你的類實例整個全局函數(shù)數(shù)組漂亮工作的方式。在我們開始講解這個內(nèi)容之前，讓我們先快速理清需求。
需求

現(xiàn)在我們正在談?wù)撊绾蝿?chuàng)建你自己的序列。也是什么談一談 protocol 了。protocol 在某些地方跟接口很相似。接口在其他語言中，是一組給定的方法，而你必須定義它們。然而，在 Python 中 protocol 是完全非正式的，而且不要求顯式聲明去實現(xiàn)。更進一步說，它們更像是準(zhǔn)則。

為何我們現(xiàn)在要談?wù)?protocol？因為在 Python 中要實現(xiàn)自定義容器類型會涉及使用到這其中某些 protocol。

首先，有一個 protocol 是為定義不可變?nèi)萜鞯?#xff1a;為了制作一個不可變?nèi)萜?#xff0c;你只需要定義 __ len__ 和__ getitem__(稍后詳述)。可變?nèi)萜?protocol 要求所有不可變?nèi)萜髟黾?setitem?和?delitem。然后，如果你希望你的對象是可迭代的，那你還得定義一個會返回迭代器 iterator 的?iter?方法。并且這個迭代器必須遵守一個迭代 protocol，也就是要求迭代器有回調(diào)方法?iter?(返回自身)和 next。
隱藏在容器背后的魔法

已經(jīng)迫不及待了？以下便是容器使用的神奇魔法：

__ len__(self)

返回容器的長度。部分 protocol 同時支持可變和不可變?nèi)萜?br />
__ getitem__(self, key)

定義當(dāng)某一個 item 被訪問時的行為，使用 self[key] 表示法。這個同樣也是部分可變和不可變?nèi)萜?protocol。這也可拋出適當(dāng)?shù)漠惓? TypeError 當(dāng) key 的類型錯誤，或沒有值對應(yīng) Key 時。

__ setitem__(self, key, value)

定義當(dāng)某一個 item 被賦值時候的行為，使用 self[key]=value 表示法。這也是部分可變和不可變?nèi)萜?protocol。再一次重申，你應(yīng)當(dāng)在適當(dāng)之處拋出 KeyError 和 TypeError 異常。

__delitem__(self, key)

定義當(dāng)某一個 item 被刪除(例如 del self[key])時的行為。這僅是部分可變?nèi)萜鞯?protocol。在一個無效key 被使用后，你必須拋出一個合適的異常。

__ iter__(self)

應(yīng)該給容器返回一個迭代器。迭代器會返回若干內(nèi)容,大多使用內(nèi)建函數(shù) iter() 表示。當(dāng)一個容器使用形如 for x in container: 的循環(huán)。迭代器本身就是其對象，同時也要定義好一個 __iter__ 方法來返回自身。

__ reversed__(self)

當(dāng)定義調(diào)用內(nèi)建函數(shù) reversed() 時的行為。應(yīng)該返回一個反向版本的列表。

__ contains__(self, item)

__ contains__ 為成員關(guān)系，用 in 和 not in 測試時定義行為。那你會問這個為何不是一個序列的 protocol 的一部分？這是因為當(dāng) __contains__ 未定義，Python 就會遍歷序列，如果遇到正在尋找的 item 就會返回True。

__ concat__(self, other)

最后，你可通過 __concat__ 定義你的序列和另外一個序列的連接。應(yīng)該從 self 和 other 返回一個新構(gòu)建的序列。當(dāng)調(diào)用 2 個序列時 __concat__ 涉及操作符 +

一個例子

在我們的例子中，讓我們看一下一個 list 實現(xiàn)的某些基礎(chǔ)功能性的構(gòu)建。可能會讓你想起你使用的其他語言(比如 Haskell)。

class FunctionalList:
'''類覆蓋了一個list的某些額外的功能性魔法，像head，
tail，init，last，drop，and take'''
def __init__(self, values=None):
if values is None:
self.values = []
else:
self.values = values

def __len__(self):
return len(self.values)

def __getitem__(self, key):
# 如果key是非法的類型和值，那么list valuse會拋出異常
return self.values[key]

def __setitem__(self, key, value):
self.values[key] = value

def __delitem__(self, key):
del self.values[key]

def __iter__(self):
return iter(self.values)

def __reversed__(self):
return reversed(self.values)

def append(self, value):
self.values.append(value)
def head(self):
# 獲得第一個元素
return self.values[0]
def tail(self):
# 獲得在第一個元素后的其他所有元素
return self.values[1:]
def init(self):
# 獲得除最后一個元素的序列
return self.values[:-1]
def last(last):
# 獲得最后一個元素
return self.values[-1]
def drop(self, n):
# 獲得除前n個元素的序列
return self.values[n:]
def take(self, n):
# 獲得前n個元素
return self.values[:n]

通過這個(輕量的)有用的例子你知道了如何實現(xiàn)你自己的序列。當(dāng)然，還有很多更有用的應(yīng)用，但是它們其中的很多已經(jīng)被標(biāo)準(zhǔn)庫實現(xiàn)了，像 Counter, OrderedDict, NamedTuple

7.反射

你也可以通過定義神奇方法來控制如何反射使用內(nèi)建函數(shù) isinstance() 和 issubclass() 的行為。這些神奇方法是：

__instancecheck__(self, instance)

檢查一個實例是否是你定義類中的一個實例(比如，isinstance(instance, class))

__subclasscheck__(self, subclass)

檢查一個類是否是你定義類的子類(比如，issubclass(subclass, class))

這對于神奇方法的用例情況來說可能較小，可它的確是真的。我并不想花費太多的時間在反射方法上面，因為他們不是那么地重要。不過它們反映了在 Python 中關(guān)于面對對象編程一些重要的東西，而且在 Python 中的普遍：總是在找一種簡單的方式來做某些事情，即使它能被用到的不多。這些神奇方法似乎看上去不那么有用，但當(dāng)你需要使用它們的時候你會感激它們的存在(和你閱讀的這本指南!)。

8.可調(diào)用對象

正如你可能已經(jīng)知道，在 Python 中函數(shù)是第一類對象。這就意味著它們可以被傳遞到函數(shù)和方法，就像是任何類型的對象。這真是一種難以置信強大的特性。

這是 Python 中一個特別的神奇方法，它允許你的類實例像函數(shù)。所以你可以“調(diào)用”它們，把他們當(dāng)做參數(shù)傳遞給函數(shù)等等。這是另一個強大又便利的特性讓 Python 的編程變得更可愛了。

__ call__(self, [args...])

允許類實例像函數(shù)一樣被調(diào)用。本質(zhì)上，這意味著 x() 等價于 x.__ call__()。注意，?call?需要的參數(shù)數(shù)目是可變的，也就是說可以對任何函數(shù)按你的喜好定義參數(shù)的數(shù)目定義?call

__ call__ 可能對于那些經(jīng)常改變狀態(tài)的實例來說是極其有用的。“調(diào)用”實例是一種順應(yīng)直覺且優(yōu)雅的方式來改變對象的狀態(tài)。下面一個例子是一個類表示一個實體在一個平面上的位置：

class Entity:
'''描述實體的類，被調(diào)用的時候更新實體的位置'''

def __init__(self, size, x, y):
self.x, self.y = x, y
self.size = size

def __call__(self, x, y):
'''改變實體的位置'''
self.x, self.y = x, y

#省略...

9.上下文管理

在 Python2.5 里引入了一個新關(guān)鍵字(with)使得一個新方法得到了代碼復(fù)用。上下文管理這個概念在 Python 中早已不是新鮮事了(之前它作為庫的一部分被實現(xiàn)過)，但直到 PEP343 才作為第一個類語言結(jié)構(gòu)取得了重要地位而被接受。你有可能早就已經(jīng)見識過 with 聲明：

with open('foo.txt') as bar:
# 對bar執(zhí)行某些動作

上下文管理允許對對象進行設(shè)置和清理動作，用 with 聲明進行已經(jīng)封裝的操作。上下文操作的行為取決于 2 個神奇方法：

__ enter__(self)

定義塊用 with 聲明創(chuàng)建出來時上下文管理應(yīng)該在塊開始做什么。注意，enter?的返回值必須綁定 with 聲明的目標(biāo)，或是 as 后面的名稱。

__ exit__(self, exception_type, exception_value, traceback)

定義在塊執(zhí)行(或終止)之后上下文管理應(yīng)該做什么。它可以用來處理異常，進行清理，或行動處于塊之后某些總是被立即處理的事。如果塊執(zhí)行成功的話，excepteion_type，exception_value，和 traceback 將會置None。否則，你可以選擇去處理異常，或者讓用戶自己去處理。如果你想處理，確保在全部都完成之后__ exit__ 會返回 True。如果你不想讓上下文管理處理異常，那就讓它發(fā)生好了。

__ enter__ 和 __ exit__ 對那些已有良好定義和對設(shè)置，清理行為有共同行為的特殊類是有用。你也可以使用這些方法去創(chuàng)建封裝其他對象通用的上下文管理。看下面的例子：

class Closer:
'''用with聲明一個上下文管理用一個close方法自動關(guān)閉一個對象'''

def __init__(self, obj):
self.obj = obj

def __enter__(self):
return self.obj # 綁定目標(biāo)

def __exit__(self, exception_type, exception_val, trace):
try:
self.obj.close()
except AttributeError: #obj不具備close
print 'Not closable.'
return True # 成功處理異常

以下是一個對于 Closer 實際應(yīng)用的一個例子，使用一個 FTP 連接進行的演示(一個可關(guān)閉的套接字)：

>>> from magicmethods import Closer
>>> from ftplib import :;;
>>> with Closer(FTP('ftp.somsite.com')) as conn:
... conn.dir()
...
# 省略的輸出
>>> conn.dir()
# 一個很長的AttributeError消息， 不能關(guān)閉使用的一個連接
>>> with Closer(int(5)) as i:
... i += 1
...
Not closeable.
>>> i
6

瞧見我們?nèi)绾纹恋胤庋b處理正確或不正確的用例了嗎？那就是上下文管理和神奇方法的威力。

10.構(gòu)建描述符對象

描述符可以改變其他對象，也可以是訪問類中任一的 getting,setting,deleting。描述符不意味著孤立；相反，它們意味著會被它們的所有者類控制。當(dāng)建立面向?qū)ο髷?shù)據(jù)庫或那些擁有相互依賴的屬性的類時，描述符是有用的。當(dāng)描述符在幾個不同單元或描述計算屬性時顯得更為有用。

作為一個描述符，一個類必須至少實現(xiàn) __ get__,?set,和?delete中的一個。讓我們快點看一下這些神奇方法吧：

__ get__(self, instance, owner)

當(dāng)描述符的值被取回時定義其行為。instance 是 owner 對象的一個實例，owner 是所有類。

__ set__(self, instance, value)

當(dāng)描述符的值被改變時定義其行為。instance 是 owner 對象的一個實例，value 是設(shè)置的描述符的值

__ delete__(self, instance)

當(dāng)描述符的值被刪除時定義其行為。instance 是 owner 對象的一個實例。

現(xiàn)在，有一個有用的描述符應(yīng)用例子：單位轉(zhuǎn)換策略

class Meter(object):
'''米描述符'''

def __init__(self, value=0.0):
self.value = float(value)
def __get__(self, instance, owner):
return self.value
def __set__(self, instance, value):
self.value = float(value)

class Foot(object):
'''英尺描述符'''

def __get__(self, instance, owner):
return instance.meter * 3.2808
def __set__(self, instance, value):
instance.meter = float(value) / 3.2808

class Distance(object):
'''表示距離的類，控制2個描述符：feet和meters'''
meter = Meter()
foot = Foot()

11.Pickling 你的對象

假如你花時間和其他 Pythonistas 打交道，那么你至少有可能聽到過 Pickling 這個詞。Pickling 是一種對 Python 數(shù)據(jù)結(jié)構(gòu)的序列化過程。如果你需要存儲一個對象，之后再取回它(通常是為了緩存)那么它就顯得格外地有用了。同時，它也是產(chǎn)生憂慮和困惑的主要來源。

Pickling 是那么地重要以至于它不僅有自己專屬的模塊(pickle)，還有自己的 protocol 和神奇方法與其相伴。但首先用簡要的文字來解釋下如何 pickle 已經(jīng)存在的類型(如果你已經(jīng)懂了可以隨意跳過這部分內(nèi)容)
Pickling:鹽水中的快速浸泡

讓我們跳入 pickling。話說你有一個詞典你想要保存它并在稍后取回。你可以把它的內(nèi)容寫到一個文件中去，需要非常小心地確保你寫了正確的語法，然后用 exec() 或處理文件的輸入取回寫入的內(nèi)容。但這是不穩(wěn)定的:如果你你在純文本中保存重要的數(shù)據(jù)，它有可能被幾種方法改變，導(dǎo)致你的程序 crash 或在你的計算機上運行了惡意代碼而出錯。于是，我們準(zhǔn)備 pickle 它：

import pickle

data = {'foo': [1,2,3],
'bar': ('Hello','world!'),
'baz': True}
jar = open('data.pk1', 'wb')
pickle.dump(data, jar) # 把pickled數(shù)據(jù)寫入jar文件
jar.close()

好了現(xiàn)在，已經(jīng)過去了幾個小時。我們希望拿回數(shù)據(jù)，而我們需要做的事僅僅是 unpickle 它：

import pickle

pk1_file = open('data.pk1','rb') #連接pickled數(shù)據(jù)
data = pickle.load(pk1_file) #把數(shù)據(jù)load到一個變量中去
print data
pk1_file.close()

發(fā)生了什么事？正如你的預(yù)期，我們獲得了 data。

現(xiàn)在，我要給你一些忠告：pickling 并非完美。Pickle 文件很容易因意外或出于故意行為而被損毀。Pickling 可能比起使用純文本文件安全些，但它仍舊有可能會被用來跑惡意代碼。還有因為 Python 版本的不兼容問題，所以不要期望發(fā)布 Pickled 對象，也不要期望人們能夠打開它們。但是，它依然是一個強大的緩存工具和其他常見序列化任務(wù)。

Pickling你自定義的對象

Pickling 不僅可用在內(nèi)建類型上，還可以用于遵守 pickle 協(xié)議的任何類。pickle 協(xié)議有 4 個可選方法用于定制 Python 對象如何運行(這跟 C 擴展有點不同，但那不在我們討論的范圍內(nèi))：

__ getinitargs__(self)

如果你想當(dāng)你的類 unpickled 時調(diào)用 __ init__，那你可以定義__ getinitargs__，該方法應(yīng)該返回一個元組的參數(shù)，然后你可以把他傳遞給 __ init__。注意，該方法僅適用于舊式類。

__ getnewargs__(self)

對于新式類，你可以影響有哪些參數(shù)會被傳遞到 __new__ 進行 unpickling。該方法同樣應(yīng)該返回一個元組參數(shù)，然后能傳遞給 __new__

__getstate__(self)

代替對象的 __dict__ 屬性被保存。當(dāng)對象 pickled，你可返回一個自定義的狀態(tài)被保存。當(dāng)對象 unpickled 時，這個狀態(tài)將會被 __setstate__ 使用。

__setstate__(self, state)

對象 unpickled 時，如果 __setstate__ 定義對象狀態(tài)會傳遞來代替直接用對象的 __dict__ 屬性。這正好跟__getstate__ 手牽手：當(dāng)二者都被定義了，你可以描述對象的 pickled 狀態(tài)，任何你想要的。

一個例子：

我們的例子是 Slate 類，它會記憶它曾經(jīng)的值和已經(jīng)寫入的值。然而，當(dāng)這特殊的 slate 每一次 pickle 都會被清空:當(dāng)前值不會被保存。

import time

class Slate:
'''存儲一個字符串和一個變更log，當(dāng)Pickle時會忘記它的值'''

def __init__(self, value):
self.value = value
self.last_change = time.asctime()
self.history = {}

def change(self, new_value):
# 改變值，提交最后的值到歷史記錄
self.history[self.last_change] = self.value
self.value = new_value
self.last_change = time.asctime()

def print_changes(self):
print 'Changelog for Slate object:'
for k, v in self.history.items():
print '%st %s' % (k, v)

def __getstate__(self):
# 故意不返回self.value 或 self.last_change.
# 當(dāng)unpickle，我們希望有一塊空白的"slate"
return self.history

def __setstate__(self, state):
# 讓 self.history = state 和 last_change 和 value被定義
self.history = state
self.value, self.last_change = None, None

12.總結(jié)

這份指南的目標(biāo)就是任何人讀一讀它，不管讀者們是否具備 Python 或面對對象的編程經(jīng)驗。如果你正準(zhǔn)備學(xué)習(xí) Python，那你已經(jīng)獲得了編寫功能豐富，優(yōu)雅，易用的類的寶貴知識。如果你是一名中級 Python 程序員，你有可能已經(jīng)拾起了一些新概念和策略和一些好的方法來減少你和你的用戶編寫的代碼量。如果你是一名 Pythonista 專家，你可能已經(jīng)回顧了某些你可能已經(jīng)被你遺忘的知識點，或著你又學(xué)習(xí)到了一些新技巧。不管你的的經(jīng)驗等級，我希望這次 Python 神奇方法的旅程達到了真正神奇的效果。(我無法控制自己在最后不用個雙關(guān)語)

附錄：如果調(diào)用神奇方法

Python 中的一些神奇方法直接映射到內(nèi)建函數(shù)；在這種情況下，調(diào)用它們的方法是相當(dāng)明顯的。然而，在其他情況下，那些調(diào)用方法就不這么明顯了。本附錄致力于揭開能夠引導(dǎo)神奇方法被調(diào)用的非明顯語法。
神奇方法 調(diào)用方法 說明

`__new__(cls [,...])` `instance = MyClass(arg1, arg2)` `__new__` 在創(chuàng)建實例的時候被調(diào)用
`__init__(self [,...])` `instance = MyClass(arg1, arg2)` `__init__` 在創(chuàng)建實例的時候被調(diào)用
`__cmp__(self, other)` `self == other`, `self > other`, 等 在比較的時候調(diào)用
`__pos__(self)` `+self` 一元加運算符
`__neg__(self)` `-self` 一元減運算符
`__invert__(self)` `~self` 取反運算符
`__index__(self)` `x[self]` 對象被作為索引使用的時候
`__nonzero__(self)` `bool(self)` 對象的布爾值
`__getattr__(self, name)` `self.name # name不存在` 訪問一個不存在的屬性時
`__setattr__(self, name, val)` `self.name = val` 對一個屬性賦值時
`__delattr__(self, name)` `del self.name` 刪除一個屬性時
`__getattribute(self, name)` `self.name` 訪問任何屬性時
`__getitem__(self, key)` `self[key]` 使用索引訪問元素時
`__setitem__(self, key, val)` `self[key] = val` 對某個索引值賦值時
`__delitem__(self, key)` `del self[key]` 刪除某個索引值時
`__iter__(self)` `for x in self` 迭代時
`__contains__(self, value)` `value in self`, `value not in self` 使用 `in` 操作測試關(guān)系時
`__concat__(self, value)` `self + other` 連接兩個對象時
`__call__(self [,...])` `self(args)` “調(diào)用”對象時
`__enter__(self)` `with self as x:` `with` 語句上下文管理
`__exit__(self, exc, val, trace)` `with self as x:` `with` 語句上下文管理
`__getstate__(self)` `pickle.dump(pkl_file, self)` 序列化
`__setstate__(self)` `data = pickle.load(pkl_file)` 序列化

希望這張表格可以幫你掃清你有關(guān)語法涉及到神奇方法的問題。

對Python感興趣或者是正在學(xué)習(xí)的小伙伴，可以加入我們的Python學(xué)習(xí)扣qun：784758214，看看前輩們是如何學(xué)習(xí)的！從基礎(chǔ)的python腳本到web開發(fā)、爬蟲、django、數(shù)據(jù)挖掘等【PDF，實戰(zhàn)源碼】，零基礎(chǔ)到項目實戰(zhàn)的資料都有整理。送給每一位python的小伙伴！每天都有大牛定時講解Python技術(shù)，分享一些學(xué)習(xí)的方法和需要注意的小細節(jié)

總結(jié)

以上是生活随笔為你收集整理的python编写ATM类_Python中编写类的各种技巧和方法的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。