Python 內編寫類的各種技巧和方法

簡介

有關 Python 內編寫類的各種技巧和方法(構建和初始化、過載操作符、類描述、屬性訪問控制、自定義序列、反射機制、可呼叫物件、上下文管理、構建描述符物件、Pickling)。 你可以把它當作一個教程，進階，或者使用參考；我希望它能夠成為一份針對 Python 方法的使用者友好指南。

本文原始碼託管在 github 上：https://github.com/justjavac/magicmethods-zh_CN。
內容目錄

介紹
構建和初始化
使操作符在自定義類內工作
神奇方法——比較
神奇方法——數字
描述你的類
屬性訪問控制
製作自定義序列
反射
可呼叫物件
上下文管理
構建描述符物件
Pickling 你的物件
總結
附錄：如何呼叫神奇方法

1.介紹

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

何為神奇方法呢？它們是面向 Python 中的一切，是一些特殊的方法允許在自己的定義類中定義增加“神奇”的功能。它們總是使用雙下劃線（比如 __init__ 或 __lt__），但它們的文件沒有很好地把它們表現出來。所有這些神奇方法都出現在Python的官方文件中，但內容相對分散，組織結構也顯得鬆散。還有你會難以發現一個例項（雖然他們被設計很棒，在語言參考中被詳細描述，可之後就會伴隨著枯燥的語法描述等）。

所以，為了解決我認為在 Python 文件中的一大敗筆，我打算用更多純英語，例項驅動的文件來說明 Python 的神奇方法。然後我就開始花了幾周的時間來寫 blog，而現在我已經完成了它們，並將它們合訂成一份指南。

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

2.構建和初始化

相信大家都熟悉這個最基礎的神奇方法 __init__。它令你能自定義一個物件的初始化行為。而當我呼叫x=SomeClass() 時，__init__ 並不是最先被呼叫的。實際上有一個叫做 __new__ 的方法，事實上是它建立了例項，它傳遞任何引數給初始化程式來達到建立的目的。在物件生命週期結束時，呼叫 __del__。讓我們更近地觀察下這 3 個神奇方法吧：

__new__(cls,[...)

一個物件的例項化時 __new__ 是第一個被呼叫的方法。在類中傳遞其他任何引數到 __init__。__new__很少被使用，這樣做確實有其目的，特別是當一個子類繼承一個不可改變的型別(一個元組或一個字串)時。我不打算再繼續深入追求 __new__ 的細節了，因為這不會產生多大用處，因為在 Python Docs 內已經涵蓋了一份巨詳細的說明了。

__init__(self,[...)

類的初始化。它會獲得初始構建呼叫傳過來的任何東西（舉例來說就是，當我們呼叫x=SomeClass(10,'foo'),__init__ 就會把傳過來的 10 和 'foo' 作為引數。__init__在 Python 的類定義中幾乎普遍被使用）

__del__(self)

如果 __new__和 __init__ 是物件的構造器，那麼 __del__ 就是析構器。它不實現宣告為del x(這樣的程式碼不會解釋成 x.__del__())的行為。相反，它定義為當一個物件被垃圾回收時的行為。這可能對可能需要額外清理的物件相當有用，比如 sockets 或檔案物件。但要小心，如果物件仍處於存活狀態而當被解釋退出時，__del__ 沒有保證就會被執行，因此這樣的__del__ 不能作為良好的編碼規範的替代。（就像當你完成操作總是要關閉一次連線。但事實上，__del__ 幾乎永遠不會執行，就因為它處於不安全情況被呼叫了。使用時保持警惕！）

把上述這些內容合在一起，就成了一份 __init__ 和 __del__ 的實際使用用例：

from os.path import join
class FileObject:
'''對檔案物件的包裝，確保檔案在關閉時得到刪除'''

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.使操作符在自定義類內工作

使用 Python 神奇方法的優勢之一就是它提供了一種簡單的方式能讓物件的行為像內建型別。這意味著你可以避免用醜陋，反直覺和非標準方法執行基本運算。在某些語言中，通常會這樣做：

if instance.equals(other_instance):
# do something

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

if instance == other_instance:
# do something

現在你看到的是神奇方法力量的一部分。絕大多數都允許我們定義為運算子本身的意義，當用在我們自己定義的類上就像它們是內建型別。

3.1 神奇方法——比較

Python 有一整套神奇方法被設計用來通過操作符實現物件間直觀的比較，而非彆扭的方法呼叫。它們同樣提供了一套覆蓋 Python 物件比較的預設行為(通過引用)。以下是這些方法的列表以及做法：

__cmp__(self, other)

__cmp__是神奇方法中最基礎的一個。實際上它實現所有比較操作符行為(<,==,!=,等)，但它有可能不按你想要的方法工作(例如，一個例項是否等於另一個這取決於比較的準則，以及一個例項是否大於其他的這也取決於其他的準則)。如果 self < other，那 __cmp__ 應當返回一個負整數；如果 self == other，則返回 0；如果 self > other，則返回正整數。它通常是最好的定義，而不需要你一次就全定義好它們，但當你需要用類似的準則進行所有的比較時，__cmp__ 會是一個很好的方式，幫你節省重複性和提高明確度。

__eq__(self, other)

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

__ne__(self, other)

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

__lt__(self, other)

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

__gt__(self, other)

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

__le__(self, other)

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

__ge__(self, other)

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

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

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

def __new__(cls, word):
# 注意，我們使用了__new__,這是因為str是一個不可變型別，
# 所以我們必須更早地初始化它（在建立時）
if ' ' in word:
print "單詞內含有空格，截斷到第一部分"
word = word[:word.index(' ')] # 在出現第一個空格之前全是字元了現在
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)

現在，我們可以建立 2 個單詞（通過 Word('foo') 和 Word('bar'))並基於它們的長度進行比較了。注意，我們沒有定義 __eq__ 和 __ne__。這是因為這可能導致某些怪異的行為（特別是當比較 Word('foo') == Word('bar') 將會得到 True 的結果）。基於單詞長度的相等比較會令人摸不清頭腦，因此我們就沿用了str 本身的相等比較的實現。

現在可能是一個好時機來提醒你一下，你不必過載每一個比較相關的神奇方法來獲得各種比較。標準庫已經友好地為我們在模板 functools 中提供了一個裝飾(decorator)類，定義了所有比較方法。你可以只過載 __eq__ 和一個其他的方法（比如 __gt__,__lt__，等）。這個特性只在 Python2.7(後?)適用，但當你有機會的話應該嘗試一下，它會為你省下大量的時間和麻煩。你可以通過在你自己的過載方法在加上 @total_ordering 來使用。

3.2 神奇方法——數字

就像你可以通過過載比較操作符的途徑來建立你自己的類例項，你同樣可以過載數字操作符。繫好你們的安全帶，朋友們，還有很多呢。處於本文組織的需要，我會把數字的神奇方法分割成5塊：一元操作符，常規算術操作符，反射算術操作符，增量賦值，型別轉換。
一元操作符

一元運算和函式僅有一個運算元，比如負數，絕對值等

__pos__(self)

實現一元正數的行為(如：+some_object)

__neg__(self)

實現負數的行為(如: -some_object)

__abs__(self)

實現內建 abs() 函式的行為

__invert__(self)

實現用~操作符進行的取反行為。你可以參考 Wiki:bitwise operations 來解釋這個運算子究竟會幹什麼
常規算術操作符

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

__add__(self, other)

實現加法

__sub__(self, other)

實現減法

__mul__(self, other)

實現乘法

__floordiv__(self, other)

實現地板除法，使用 // 操作符

__div__(self, other)

實現傳統除法，使用 / 操作符

__truediv__(self, other)

實現真正除法。注意，只有當你 from __future__ import division 時才會有效

__mod__(self, other)

實現求模，使用 % 操作符

__divmod__(self, other)

實現內建函式 divmod() 的行為

__pow__(self, other)

實現乘方，使用 ** 操作符

__lshift__(self, other)

實現左按位位移，使用 << 操作符

__rshift__(self, other)

實現右按位位移，使用 >> 操作符

__and__(self, other)

實現按位與，使用 & 操作符

__or__(self, other)

實現按位或，使用 | 操作符

__xor__(self, other)

實現按位異或，使用 ^ 操作符
反射算術操作符

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

some_object + other

這是“常規的”加法。而反射其實相當於一回事，除了運算元改變了改變下位置：

other + some_object

因此，所有這些神奇的方法會做同樣的事等價於常規算術操作符，除了改變運算元的位置關係，比如第一個運算元和自身作為第二個。此外沒有其他的操作方式。在大多數情況下，反射算術操作的結果等價於常規算術操作，所以你儘可以在剛過載完 __radd__就呼叫 __add__。乾脆痛快：

__radd__(self, other)

實現反射加法

__rsub__(self, other)

實現反射減法

__rmul__(self, other)

實現反射乘法

__rfloordiv__(self, other)

實現反射地板除，用 // 操作符

__rdiv__(self, other)

實現傳統除法，用 / 操作符

__rturediv__(self, other)

實現真實除法，注意，只有當你 from __future__ import division 時才會有效

__rmod__(self, other)

實現反射求模，用 % 操作符

__rdivmod__(self, other)

實現內建函式 divmod() 的長除行為，當呼叫 divmod(other,self) 時被呼叫

__rpow__(self, other)

實現反射乘方，用 ** 操作符

__rlshift__(self, other)

實現反射的左按位位移，使用 << 操作符

__rrshift__(self, other)

實現反射的右按位位移，使用 >> 操作符

__rand__(self, other)

實現反射的按位與，使用 & 操作符

__ror__(self, other)

實現反射的按位或，使用 | 操作符

__rxor__(self, other)

實現反射的按位異或，使用 ^ 操作符
增量賦值

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

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

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

__iadd__(self, other)

實現加法和賦值

__isub__(self, other)

實現減法和賦值

__imul__(self, other)

實現乘法和賦值

__ifloordiv__(self, other)

實現地板除和賦值，用 //= 操作符

__idiv__(self, other)

實現傳統除法和賦值，用 /= 操作符

__iturediv__(self, other)

實現真實除法和賦值，注意，只有當你 from __future__ import division 時才會有效

__imod__(self, other)

實現求模和賦值，用 %= 操作符

__ipow__(self, other)

實現乘方和賦值，用 **= 操作符

__ilshift__(self, other)

實現左按位位移和賦值，使用 <<= 操作符

__irshift__(self, other)

實現右按位位移和賦值，使用 >>= 操作符

__iand__(self, other)

實現按位與和賦值，使用 &= 操作符

__ior__(self, other)

實現按位或和賦值，使用 |= 操作符

__ixor__(self, other)

實現按位異或和賦值，使用 ^= 操作符
型別轉換的神奇方法

Python 也有一組神奇方法被設計用來實現內建型別轉換函式的行為，如 float()

__int__(self)

實現到 int 的型別轉換

__long__(self)

實現到 long 的型別轉換

__float__(self)

實現到 float 的型別轉換

__complex__(self)

實現到複數的型別轉換

__oct__(self)

實現到 8 進位制的型別轉換

__hex__(self)

實現到 16 進位制的型別轉換

__index__(self)

實現一個當物件被切片到 int 的型別轉換。如果你自定義了一個數值型別，考慮到它可能被切片，所以你應該過載__index__

__trunc__(self)

當 math.trunc(self) 被呼叫時呼叫。__trunc__ 應當返回一個整型的截斷，(通常是 long)

__coerce__(self, other)

該方法用來實現混合模式的算術。如果型別轉換不可能那 __coerce__ 應當返回 None。 否則，它應當返回一對包含 self 和 other（2 元組），且調整到具有相同的型別

4.描述你的類

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

__str__(self)

當你定義的類中一個例項呼叫了 str()，用於給它定義行為

__repr__(self)

當你定義的類中一個例項呼叫了 repr()，用於給它定義行為。 str() 和 repr() 主要的區別在於它的閱讀物件。 repr() 產生的輸出主要為計算機可讀(在很多情況下，這甚至可能是一些有效的 Python 程式碼)，而 str() 則是為了讓人類可讀。

__unicode__(self)

當你定義的類中一個例項呼叫了 unicode()，用於給它定義行為。 unicode() 像是 str(),只不過它返回一個 unicode 字串。 警惕！如果使用者用你的類中的一個例項呼叫了 str(),而你僅定義了 __unicode__(),那它是不會工作的。 以防萬一，你應當總是定義好 __str__()，哪怕使用者不會使用 unicode

__hash__(self)

當你定義的類中一個例項呼叫了 hash()，用於給它定義行為。 它必須返回一個整型，而且它的結果是用於來在字典中作為快速鍵比對。

__nonzero__(self)

當你定義的類中一個例項呼叫了 bool()，用於給它定義行為。 返回 True 或 False，取決於你是否考慮一個例項是 True 或 False 的。

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

5.屬性訪問控制

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

請看：

__getattr__(self, name)

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

__setattr__(self, name, value)

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

__delattr__

這等價於 __setattr__, 但是作為刪除類屬性而不是 set 它們。 它需要相同的預防措施，就像 __setattr__，防止無限遞迴（當在 __delattr__ 中呼叫 del self.name 會引起無限遞迴）。

__getattribute__(self, name)

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

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

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

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

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

那麼，我們在關於定製類屬性訪問中學習了什麼？ 不要輕易地使用，事實上它過於強大以及反直覺。 這也是它為何存在的理由：Python 尋求幹壞事的可能性，但會把它們弄得很難。 自由是至高無上的，所以你可以做任何你想做的事情。 以下是一個關於特殊屬性訪問方法的實際例子（注意，我們使用 super 因為並非所有類都有 __dict__類屬性）：

class AccessCounter:
'''一個類包含一個值和實現了一個訪問計數器。
當值每次發生變化時，計數器+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.
# 如果你想阻止其他屬性被建立，丟擲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.製作自定義序列

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

現在我們正在談論如何建立你自己的序列。 也是什麼談一談 protocol 了。 protocol 在某些地方跟介面很相似。 介面在其他語言中，是一組給定的方法，而你必須定義它們。 然而，在 Python 中 protocol 是完全非正式的，而且不要求顯式宣告去實現。 更進一步說，它們更像是準則。

為何我們現在要談論 protocol？ 因為在 Python 中要實現自定義容器型別會涉及使用到這其中某些 protocol。

首先，有一個 protocol 是為定義不可變容器的：為了製作一個不可變容器，你只需要定義 __len__ 和__getitem__（稍後詳述）。 可變容器 protocol 要求所有不可變容器增加 __setitem__ 和 __delitem__。 然後，如果你希望你的物件是可迭代的，那你還得定義一個會返回迭代器 iterator 的 __iter__ 方法。 並且這個迭代器必須遵守一個迭代 protocol，也就是要求迭代器有回撥方法 __iter__ （返回自身）和 next。
隱藏在容器背後的魔法

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

__len__(self)

返回容器的長度。部分 protocol 同時支援可變和不可變容器

__getitem__(self, key)

定義當某一個 item 被訪問時的行為，使用 self[key] 表示法。 這個同樣也是部分可變和不可變容器 protocol。 這也可丟擲適當的異常: TypeError 當 key 的型別錯誤，或沒有值對應 Key 時。

__setitem__(self, key, value)

定義當某一個 item 被賦值時候的行為，使用 self[key]=value 表示法。 這也是部分可變和不可變容器 protocol。 再一次重申，你應當在適當之處丟擲 KeyError 和 TypeError 異常。

__delitem__(self, key)

定義當某一個 item 被刪除（例如 del self[key]）時的行為。 這僅是部分可變容器的 protocol。在一個無效key 被使用後，你必須丟擲一個合適的異常。

__iter__(self)

應該給容器返回一個迭代器。 迭代器會返回若干內容,大多使用內建函式 iter() 表示。 當一個容器使用形如 for x in container: 的迴圈。 迭代器本身就是其物件，同時也要定義好一個 __iter__ 方法來返回自身。

__reversed__(self)

當定義呼叫內建函式 reversed() 時的行為。應該返回一個反向版本的列表。

__contains__(self, item)

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

__concat__(self, other)

最後，你可通過 __concat__ 定義你的序列和另外一個序列的連線。 應該從 self 和 other 返回一個新構建的序列。 當呼叫 2 個序列時 __concat__ 涉及操作符 +
一個例子

在我們的例子中，讓我們看一下一個 list 實現的某些基礎功能性的構建。 可能會讓你想起你使用的其他語言（比如 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]

通過這個(輕量的)有用的例子你知道了如何實現你自己的序列。 當然，還有很多更有用的應用，但是它們其中的很多已經被標準庫實現了，像 Counter, OrderedDict, NamedTuple

7.反射

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

__instancecheck__(self, instance)

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

__subclasscheck__(self, subclass)

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

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

8.可呼叫物件

正如你可能已經知道，在 Python 中函式是第一類物件。 這就意味著它們可以被傳遞到函式和方法，就像是任何型別的物件。 這真是一種難以置信強大的特性。

這是 Python 中一個特別的神奇方法，它允許你的類例項像函式。 所以你可以“呼叫”它們，把他們當做引數傳遞給函式等等。 這是另一個強大又便利的特性讓 Python 的程式設計變得更可愛了。

__call__(self, [args...])

允許類例項像函式一樣被呼叫。 本質上，這意味著 x() 等價於 x.__call__()。 注意，__call__ 需要的引數數目是可變的，也就是說可以對任何函式按你的喜好定義引數的數目定義 __call__

__call__ 可能對於那些經常改變狀態的例項來說是極其有用的。 “呼叫”例項是一種順應直覺且優雅的方式來改變物件的狀態。 下面一個例子是一個類表示一個實體在一個平面上的位置：

class Entity:
'''描述實體的類，被呼叫的時候更新實體的位置'''

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 裡引入了一個新關鍵字（with）使得一個新方法得到了程式碼複用。 上下文管理這個概念在 Python 中早已不是新鮮事了（之前它作為庫的一部分被實現過），但直到 PEP343 才作為第一個類語言結構取得了重要地位而被接受。 你有可能早就已經見識過 with 宣告：

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

上下文管理允許對物件進行設定和清理動作，用 with 宣告進行已經封裝的操作。 上下文操作的行為取決於 2 個神奇方法：

__enter__(self)

定義塊用 with 宣告創建出來時上下文管理應該在塊開始做什麼。 注意，__enter__ 的返回值必須繫結 with 宣告的目標，或是 as 後面的名稱。

__exit__(self, exception_type, exception_value, traceback)

定義在塊執行（或終止）之後上下文管理應該做什麼。 它可以用來處理異常，進行清理，或行動處於塊之後某些總是被立即處理的事。 如果塊執行成功的話，excepteion_type，exception_value，和 traceback 將會置None。 否則，你可以選擇去處理異常，或者讓使用者自己去處理。 如果你想處理，確保在全部都完成之後__exit__ 會返回 True。 如果你不想讓上下文管理處理異常，那就讓它發生好了。

__enter__ 和 __exit__ 對那些已有良好定義和對設定，清理行為有共同行為的特殊類是有用。 你也可以使用這些方法去建立封裝其他物件通用的上下文管理。 看下面的例子：

class Closer:
'''用with宣告一個上下文管理用一個close方法自動關閉一個物件'''

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

def __enter__(self):
return self.obj # 繫結目標

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

以下是一個對於 Closer 實際應用的一個例子，使用一個 FTP 連線進行的演示（一個可關閉的套接字）：

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

瞧見我們如何漂亮地封裝處理正確或不正確的用例了嗎？那就是上下文管理和神奇方法的威力。

10.構建描述符物件

描述符可以改變其他物件，也可以是訪問類中任一的 getting,setting,deleting。 描述符不意味著孤立；相反，它們意味著會被它們的所有者類控制。 當建立面向物件資料庫或那些擁有相互依賴的屬性的類時，描述符是有用的。 當描述符在幾個不同單元或描述計算屬性時顯得更為有用。

作為一個描述符，一個類必須至少實現 __get__,__set__,和 __delete__中的一個。 讓我們快點看一下這些神奇方法吧：

__get__(self, instance, owner)

當描述符的值被取回時定義其行為。instance 是 owner 物件的一個例項，owner 是所有類。

__set__(self, instance, value)

當描述符的值被改變時定義其行為。instance 是 owner 物件的一個例項，value 是設定的描述符的值

__delete__(self, instance)

當描述符的值被刪除時定義其行為。instance 是 owner 物件的一個例項。

現在，有一個有用的描述符應用例子：單位轉換策略

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 資料結構的序列化過程。 如果你需要儲存一個物件，之後再取回它（通常是為了快取）那麼它就顯得格外地有用了。 同時，它也是產生憂慮和困惑的主要來源。

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

讓我們跳入 pickling。 話說你有一個詞典你想要儲存它並在稍後取回。 你可以把它的內容寫到一個檔案中去，需要非常小心地確保你寫了正確的語法，然後用 exec() 或處理檔案的輸入取回寫入的內容。 但這是不穩定的:如果你你在純文字中儲存重要的資料，它有可能被幾種方法改變，導致你的程式 crash 或在你的計算機上運行了惡意程式碼而出錯。 於是，我們準備 pickle 它：

import pickle

data = {'foo': [1,2,3],
'bar': ('Hello','world!'),
'baz': True}
jar = open('data.pk1', 'wb')
pickle.dump(data, jar) # 把pickled資料寫入jar檔案
jar.close()

好了現在，已經過去了幾個小時。 我們希望拿回資料，而我們需要做的事僅僅是 unpickle 它：

import pickle

pk1_file = open('data.pk1','rb') #連線pickled資料
data = pickle.load(pk1_file) #把資料load到一個變數中去
print data
pk1_file.close()

發生了什麼事？正如你的預期，我們獲得了 data。

現在，我要給你一些忠告：pickling 並非完美。 Pickle 檔案很容易因意外或出於故意行為而被損毀。 Pickling 可能比起使用純文字檔案安全些，但它仍舊有可能會被用來跑惡意程式碼。 還有因為 Python 版本的不相容問題，所以不要期望釋出 Pickled 物件，也不要期望人們能夠開啟它們。 但是，它依然是一個強大的快取工具和其他常見序列化任務。
Pickling你自定義的物件

Pickling 不僅可用在內建型別上，還可以用於遵守 pickle 協議的任何類。 pickle 協議有 4 個可選方法用於定製 Python 物件如何執行（這跟 C 擴充套件有點不同，但那不在我們討論的範圍內）：

__getinitargs__(self)

如果你想當你的類 unpickled 時呼叫 __init__，那你可以定義__getinitargs__，該方法應該返回一個元組的引數，然後你可以把他傳遞給 __init__。注意，該方法僅適用於舊式類。

__getnewargs__(self)

對於新式類，你可以影響有哪些引數會被傳遞到 __new__ 進行 unpickling。 該方法同樣應該返回一個元組引數，然後能傳遞給 __new__

__getstate__(self)

代替物件的 __dict__ 屬性被儲存。 當物件 pickled，你可返回一個自定義的狀態被儲存。 當物件 unpickled 時，這個狀態將會被 __setstate__ 使用。

__setstate__(self, state)

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

一個例子：

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

import time

class Slate:
'''儲存一個字串和一個變更log，當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.
# 當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.總結

這份指南的目標就是任何人讀一讀它，不管讀者們是否具備 Python 或面對物件的程式設計經驗。 如果你正準備學習 Python，那你已經獲得了編寫功能豐富，優雅，易用的類的寶貴知識。 如果你是一名中級 Python 程式設計師，你有可能已經拾起了一些新概念和策略和一些好的方法來減少你和你的使用者編寫的程式碼量。 如果你是一名 Pythonista 專家，你可能已經回顧了某些你可能已經被你遺忘的知識點，或著你又學習到了一些新技巧。 不管你的的經驗等級，我希望這次 Python 神奇方法的旅程達到了真正神奇的效果。（我無法控制自己在最後不用個雙關語）

附錄：如果呼叫神奇方法

Python 中的一些神奇方法直接對映到內建函式；在這種情況下，呼叫它們的方法是相當明顯的。 然而，在其他情況下，那些呼叫方法就不這麼明顯了。 本附錄致力於揭開能夠引導神奇方法被呼叫的非明顯語法。
神奇方法 呼叫方法 說明
`__new__(cls [,...])` `instance = MyClass(arg1, arg2)` `__new__` 在建立例項的時候被呼叫
`__init__(self [,...])` `instance = MyClass(arg1, arg2)` `__init__` 在建立例項的時候被呼叫
`__cmp__(self, other)` `self == other`, `self > other`, 等 在比較的時候呼叫
`__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` 操作測試關係時
`__concat__(self, value)` `self + other` 連線兩個物件時
`__call__(self [,...])` `self(args)` “呼叫”物件時
`__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)` 序列化

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