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)` 序列化
希望這張表格可以幫你掃清你有關語法涉及到神奇方法的問題。