if instance.equals(other_instance):
    # do something

if instance == other_instance:
        #do something

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

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

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

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

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

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

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

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

class Word(str):
'''存儲(chǔ)單詞的類，定義比較單詞的幾種方法'''

    def __new__(cls, word):
        # 注意我們必須要用到__new__方法，因?yàn)閟tr是不可變類型
        # 所以我們必須在創(chuàng)建的時(shí)候?qū)⑺跏蓟?        if ' ' in word:
            print "Value contains spaces. Truncating to first space."
            word = word[:word.index(' ')] #單詞是第一個(gè)空格之前的所有字符
        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)建兩個(gè) Words 對象(通過使用 Word('foo') 和 Word('bar') 然后通過長度來比較它們。注意，我們沒有定義 __eq__ 和 __ne__ 方法。這是因?yàn)閷?huì)產(chǎn)生一些怪異的結(jié)果(比如 Word('foo') == Word('bar') 將會(huì)返回true)。這對于測試基于長度的比較不是很有意義。所以我們退回去，用 str 內(nèi)置來進(jìn)行比較。

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

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

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

some_object + other

other + some_object

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

class AccessCounter:
    '''一個(gè)包含計(jì)數(shù)器的控制權(quán)限的類每當(dāng)值被改變時(shí)計(jì)數(shù)器會(huì)加一'''

    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)建定制的序列，這個(gè)時(shí)候該講一講協(xié)議。協(xié)議(Protocols)與其他語言中的接口很相似。它給你很多你必須定義的方法。然而在Python中的協(xié)議是很不正式的，不需要明確聲明實(shí)現(xiàn)。事實(shí)上，他們更像一種指南。

我們?yōu)槭裁船F(xiàn)在討論協(xié)議？因?yàn)槿绻ㄖ迫萜黝愋偷脑捫枰玫竭@些協(xié)議。首先，實(shí)現(xiàn)不變?nèi)萜鞯脑捰幸粋€(gè)協(xié)議:實(shí)現(xiàn)不可變?nèi)萜鳎阒荒芏x __len__ 和 __getitem__ (一會(huì)會(huì)講更多)?？勺?nèi)萜鲄f(xié)議則需要所有不可變?nèi)萜鞯乃辛硗膺€需要 __setitem__ 和 __delitem__ 。最終，如果你希望你的對象是可迭代的話，你需要定義 __iter__ 會(huì)返回一個(gè)迭代器。迭代器必須遵循迭代器協(xié)議，需要有 __iter__ (返回它本身) 和 next 。

容器后的魔法?

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

一個(gè)例子?

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

class FunctionalList:
'''一個(gè)封裝了一些附加魔術(shù)方法比如 head, tail, init, last, drop, 和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):
    #如果鍵的類型或者值無效，列表值將會(huì)拋出錯(cuò)誤
    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(self):
    #返回末尾元素
    return self.values[-1]
def drop(self, n):
    #返回除前n個(gè)外的所有元素
    return self.values[n:]
def take(self, n):
    #返回前n個(gè)元素
    return self.values[:n]

class Entity:
'''調(diào)用實(shí)體來改變實(shí)體的位置。'''

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

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

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

class Closer:
'''通過with語句和一個(gè)close方法來關(guān)閉一個(gè)對象的會(huì)話管理器'''

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

def __enter__(self):
    return self.obj # bound to target

def __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.2808

class Distance(object):
    '''Class to represent distance holding two descriptors for feet and
    meters.'''
    meter = Meter()
    foot = Foot()

Pickling: 簡單例子?

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

import pickle

data = {'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 jar
jar.close()

嗯，過了幾個(gè)小時(shí)之后，我們需要用到它了，只需把它 unpickle 了就行了：

import pickle

pkl_file = open('data.pkl', 'rb') # connect to the pickled data
data = pickle.load(pkl_file) # load it into a variable
print data
pkl_file.close()

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

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

序列化你自己的對象?

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

__getinitargs__(self)

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

__getnewargs__(self)

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

__getstate__(self)

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

__setstate__(self, state)

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

例子?

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

import time

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

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

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

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