if instance.equals(other_instance):    # do something

if instance == other_instance:        #do something

用于比較的魔術(shù)方法?

Python對實現(xiàn)對象的比較，使用魔術(shù)方法進行了大的逆轉(zhuǎn)，使他們非常直觀而不是笨拙的方法調(diào)用。而且還提供了一種方法可以重寫Python對對象比較的默認(rèn)行為(通過引用)。以下是這些方法和他們的作用。

__cmp__(self, other)__cmp__ 是最基本的用于比較的魔術(shù)方法。它實際上實現(xiàn)了所有的比較符號(<,==,!=,etc.)，但是它的表現(xiàn)并不會總是如你所愿(比如，當(dāng)一個實例與另一個實例相等是通過一個規(guī)則來判斷，而一個實例大于另外一個實例是通過另外一個規(guī)則來判斷)。如果 self < other 的話 __cmp__ 應(yīng)該返回一個負(fù)數(shù)，當(dāng) self == o 的時候會返回0 ，而當(dāng) self > other 的時候會返回正數(shù)。通常最好的一種方式是去分別定義每一個比較符號而不是一次性將他們都定義。但是 __cmp__ 方法是你想要實現(xiàn)所有的比較符號而一個保持清楚明白的一個好的方法。

__eq__(self, other)定義了等號的行為, == 。

__ne__(self, other)定義了不等號的行為, != 。

__lt__(self, other)定義了小于號的行為， < 。

__gt__(self, other)定義了大于等于號的行為， >= 。

舉一個例子，創(chuàng)建一個類來表現(xiàn)一個詞語。我們也許會想要比較單詞的字典序(通過字母表)，通過默認(rèn)的字符串比較的方法就可以實現(xiàn)，但是我們也想要通過一些其他的標(biāo)準(zhǔn)來實現(xiàn)，比如單詞長度或者音節(jié)數(shù)量。在這個例子中，我們來比較長度實現(xiàn)。以下是實現(xiàn)代碼:

class Word(str):'''存儲單詞的類，定義比較單詞的幾種方法'''    def __new__(cls, word):        # 注意我們必須要用到__new__方法，因為str是不可變類型        # 所以我們必須在創(chuàng)建的時候?qū)⑺跏蓟?       if ' ' in word:            print "Value contains spaces. Truncating to first space."            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)

現(xiàn)在，我們創(chuàng)建兩個 Words 對象(通過使用 Word('foo') 和 Word('bar') 然后通過長度來比較它們。注意，我們沒有定義 __eq__ 和 __ne__ 方法。這是因為將會產(chǎn)生一些怪異的結(jié)果(比如 Word('foo') == Word('bar') 將會返回true)。這對于測試基于長度的比較不是很有意義。所以我們退回去，用 str 內(nèi)置來進行比較。

現(xiàn)在你知道你不必定義每一個比較的魔術(shù)方法從而進行豐富的比較。標(biāo)準(zhǔn)庫中很友好的在 functiontols 中提供給我們一個類的裝飾器定義了所有的豐富的比較函數(shù)。如果你只是定義 __eq__ 和另外一個(e.g. __gt__, __lt__,etc.)這個特性僅僅在Python 2.7中存在，但是你如果有機會碰到的話，那么將會節(jié)省大量的時間和經(jīng)理。你可以通過在你定義的類前放置 @total_ordering 來使用。

數(shù)值處理的魔術(shù)方法?

如同你在通過比較符來比較類的實例的時候來創(chuàng)建很多方法，你也可以定義一些數(shù)值符號的特性。系緊你的安全帶，來吧，這里有很多內(nèi)容。為了組織方便，我將會把數(shù)值處理的方法來分成五類:一元操作符，普通算數(shù)操作符，反射算數(shù)操作符(之后會詳細說明),增量賦值，和類型轉(zhuǎn)換。

some_object + other

other + some_object

x = 5x += 1 # in other words x = x + 1

class AccessCounter:    '''一個包含計數(shù)器的控制權(quán)限的類每當(dāng)值被改變時計數(shù)器會加一'''    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)    #如果你不想讓其他屬性被訪問的話，那么可以拋出 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)]

必須條件?

現(xiàn)在我們開始講如何在Python中創(chuàng)建定制的序列，這個時候該講一講協(xié)議。協(xié)議(Protocols)與其他語言中的接口很相似。它給你很多你必須定義的方法。然而在Python中的協(xié)議是很不正式的，不需要明確聲明實現(xiàn)。事實上，他們更像一種指南。

我們?yōu)槭裁船F(xiàn)在討論協(xié)議？因為如果要定制容器類型的話需要用到這些協(xié)議。首先，實現(xiàn)不變?nèi)萜鞯脑捰幸粋€協(xié)議:實現(xiàn)不可變?nèi)萜?，你只能定義 __len__ 和 __getitem__ (一會會講更多)?？勺?nèi)萜鲄f(xié)議則需要所有不可變?nèi)萜鞯乃辛硗膺€需要 __setitem__ 和 __delitem__ 。最終，如果你希望你的對象是可迭代的話，你需要定義 __iter__ 會返回一個迭代器。迭代器必須遵循迭代器協(xié)議，需要有 __iter__ (返回它本身) 和 next 。

容器后的魔法?

這些是容器使用的魔術(shù)方法。__len__(self)然會容器長度。對于可變不可變?nèi)萜鞫夹枰械膮f(xié)議的一部分。__getitem__(self, key)定義當(dāng)一個條目被訪問時，使用符號 self[key] 。這也是不可變?nèi)萜骱涂勺內(nèi)萜鞫家械膮f(xié)議的一部分。如果鍵的類型錯誤和 KeyError 或者沒有合適的值。那么應(yīng)該拋出適當(dāng)?shù)?TypeError 異常。__setitem__(self, key, value)定義當(dāng)一個條目被賦值時的行為,使用 self[key] = value 。這也是可變?nèi)萜骱筒豢勺內(nèi)萜鲄f(xié)議中都要有的一部分。__delitem__(self, key)定義當(dāng)一個條目被刪除時的行為(比如 del self[key])。這只是可變?nèi)萜鲄f(xié)議中的一部分。當(dāng)使用一個無效的鍵時應(yīng)該拋出適當(dāng)?shù)漠惓！?tt>__iter__(self)返回一個容器的迭代器。很多情況下會返回迭代器，尤其是當(dāng)內(nèi)置的 iter() 方法被調(diào)用的時候，或者當(dāng)使用 for x in container 方式循環(huán)的時候。迭代器是他們本身的對象，他們必須定義返回 self 的 __iter__ 方法。__reversed__(self)實現(xiàn)當(dāng) reversed() 被調(diào)用時的行為。應(yīng)該返回列表的反轉(zhuǎn)版本。__contains__(self, item)當(dāng)調(diào)用 in 和 not in 來測試成員是否存在時候 __contains__ 被定義。你問為什么這個不是序列協(xié)議的一部分？那是因為當(dāng) __contains__ 沒有被定義的時候，Python會迭代這個序列并且當(dāng)找到需要的值時會返回 True 。__concat__(self, other)最終，你可以通過 __concat__ 來定義當(dāng)用其他的來連接兩個序列時候的行為。當(dāng) + 操作符被調(diào)用時候會返回一個 self 和 other.__concat__ 被調(diào)用后的結(jié)果產(chǎn)生的新序列。

一個例子?

在我們的例子中，讓我們看一看你可能在其他語言中 用到的函數(shù)構(gòu)造語句的實現(xiàn)(比如 Haskell)。

class FunctionalList:'''一個封裝了一些附加魔術(shù)方法比如 head, tail, init, last, drop, 和take的列表類。'''def __init__(self, values=None):if values is None:    self.values = []else:    self.values = valuesdef __len__(self):    return len(self.values)def __getitem__(self, key):    #如果鍵的類型或者值無效，列表值將會拋出錯誤    return self.values[key]def __setitem__(self, key, value):    self.values[key] = valuedef __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(self):    #返回末尾元素    return self.values[-1]def drop(self, n):    #返回除前n個外的所有元素    return self.values[n:]def take(self, n):    #返回前n個元素    return self.values[:n]

class Entity:'''調(diào)用實體來改變實體的位置。'''def __init__(self, size, x, y):    self.x, self.y = x, y    self.size = sizedef __call__(self, x, y):    '''改變實體的位置'''    self.x, self.y = x, y

with open('foo.txt') as bar:# perform some action with bar

class Closer:'''通過with語句和一個close方法來關(guān)閉一個對象的會話管理器'''def __init__(self, obj):    self.obj = objdef __enter__(self):    return self.obj # bound to targetdef __exit__(self, exception_type, exception_val, trace):    try:        self.obj.close()    except AttributeError: # obj isn't closable        print 'Not closable.'        return True # exception handled successfully

class Meter(object):'''Descriptor for a meter.'''    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):    '''Descriptor for a foot.'''    def __get__(self, instance, owner):    return instance.meter * 3.2808    def __set__(self, instance, value):    instance.meter = float(value) / 3.2808class Distance(object):    '''Class to represent distance holding two descriptors for feet and    meters.'''    meter = Meter()    foot = Foot()

Pickling: 簡單例子?

讓我們深入研究 Pickle，比如說你現(xiàn)在需要臨時儲存一個字典，你可以把它寫入到一個文件里，并且要小心翼翼的確保格式正確，之后再用 exec() 或者處理文件輸入來恢復(fù)數(shù)據(jù)，實際上這是很不安全的，如果你使用文本存儲了一些重要的數(shù)據(jù)，任何方式的改變都可能會影響到你的程序，輕則程序崩潰，重則被惡意程序利用，所以，讓我們用 Pickle 代替這種方式：

import pickledata = {'foo': [1, 2, 3],        'bar': ('Hello', 'world!'),        'baz': True}jar = open('data.pkl', 'wb')pickle.dump(data, jar) # write the pickled data to the file jarjar.close()

嗯，過了幾個小時之后，我們需要用到它了，只需把它 unpickle 了就行了：

import picklepkl_file = open('data.pkl', 'rb') # connect to the pickled datadata = pickle.load(pkl_file) # load it into a variableprint datapkl_file.close()

正如你期望的，數(shù)據(jù)原封不動的回來了！

同時要給你一句忠告： pickle 并不是很完美， Pickle 文件很容易被不小心或者故意損壞， Pickle 文件比純文本文件要稍微安全一點，但是還是可以被利用運行惡意程序。 Pickle 不是跨版本兼容的（譯注：最近剛好在 《Python Cookbook》上看到相關(guān)討論，書中描述的 Pickle 是跨版本兼容的，此點待驗證），所以盡量不要去分發(fā) Pickle 過的文本，因為別人并不一定能夠打開。不過在做緩存或者其他需要序列化數(shù)據(jù)的時候， Pickle 還是很有用處的。

序列化你自己的對象?

Pickle 并不是只支持內(nèi)建數(shù)據(jù)結(jié)果，任何遵循 Pickle 協(xié)議的類都可以，Pickle 協(xié)議為 Python 對象規(guī)定了4個可選方法來自定義 Pickle 行為（對于 C 擴展的 cPickle 模塊會有一些不同，但是這并不在我們的討論范圍內(nèi)）：

__getinitargs__(self)

如果你希望在逆序列化的同時調(diào)用 __init__ ，你可以定義 __getinitargs__ 方法，這個方法應(yīng)該返回一系列你想被 __init__ 調(diào)用的參數(shù)，注意這個方法只對老樣式的類起作用。

__getnewargs__(self)

對于新式的類，你可以定義任何在重建對象時候傳遞到 __new__ 方法中的參數(shù)。這個方法也應(yīng)該返回一系列的被 __new__ 調(diào)用的參數(shù)。

__getstate__(self)

你可以自定義當(dāng)對象被序列化時返回的狀態(tài)，而不是使用 __dict 方法，當(dāng)逆序列化對象的時候，返回的狀態(tài)將會被 __setstate__ 方法調(diào)用。

__setstate__(self, state)

在對象逆序列化的時候，如果 __setstate__ 定義過的話，對象的狀態(tài)將被傳給它而不是傳給 __dict__ 。這個方法是和 __getstate__ 配對的，當(dāng)這兩個方法都被定義的時候，你就可以完全控制整個序列化與逆序列化的過程了。

例子?

我們以 Slate 為例，這是一段記錄一個值以及這個值是何時被寫入的程序，但是，這個 Slate 有一點特殊的地方，當(dāng)前值不會被保存。

import timeclass Slate:    '''Class to store a string and a changelog, and forget its value when    pickled.'''    def __init__(self, value):        self.value = value        self.last_change = time.asctime()        self.history = {}    def change(self, new_value):        # Change the value. Commit last value to history        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 '%s\t %s' % (k, v)    def __getstate__(self):        # Deliberately do not return self.value or self.last_change.        # We want to have a "blank slate" when we unpickle.        return self.history    def __setstate__(self, state):        # Make self.history = state and last_change and value undefined        self.history = state        self.value, self.last_change = None, None

結(jié)論?

這份指南的希望為所有人都能帶來一些知識，即使你是 Python 大?；蛘邔τ诰ㄓ诿嫦?qū)ο箝_發(fā)。如果你是一個 Python 初學(xué)者，閱讀這篇文章之后你已經(jīng)獲得了編寫豐富，優(yōu)雅，靈活的類的知識基礎(chǔ)了。如果你是一個有一些經(jīng)驗的 Python 程序員，你可能會發(fā)現(xiàn)一些能讓你寫的代碼更簡潔的方法。如果你是一個 Python 大牛，可能會幫助你想起來一些你已經(jīng)遺忘的知識，或者一些你還沒聽說過的新功能。不管你現(xiàn)在有多少經(jīng)驗，我希望這次對于 Python 特殊方法的旅程能夠帶給你一些幫助（用雙關(guān)語真的很不錯 XD）（譯注: 這里的雙關(guān)在于標(biāo)題為 Magic Methods 這里是 神奇的旅程 ，不過由于中英語序的問題，直譯略顯頭重腳輕，所以稍微變化了下意思，丟掉了雙關(guān)的含義）。

附錄：如何調(diào)用魔術(shù)方法?

一些魔術(shù)方法直接和內(nèi)建函數(shù)相對，在這種情況下，調(diào)用他們的方法很簡單，但是，如果是另外一種不是特別明顯的調(diào)用方法，這個附錄介紹了很多并不是很明顯的魔術(shù)方法的調(diào)用形式。

希望這個表格對你對于什么時候應(yīng)該使用什么方法這個問題有所幫助。