介紹

此教程為我的數篇文章中的一個重點。主題是魔術方法。 什麼是魔術方法?他們是物件導向的Python的一切。他們是可以給你的類增加”magic”的特殊方法。他們總是被雙下劃線所包圍(e.g. __init__ 或者 __lt__)。然而他們的文件卻遠沒有提供應該有的內容。Python中所有的魔術方法均在Python官方文件中有相應描述，但是對於他們的描述比較混亂而且組織比較鬆散。很難找到有一個例子(也許他們原本打算的很好，在開始語言參考中有描述很詳細，然而隨之而來的確是枯燥的語法描述等等)。

所以，為了修補我認為Python文件應該修補的瑕疵，我決定給Python中的魔術方法提供一些用平淡的語言和例項驅使的文件。我在開始已經寫了數篇博文，現在在這篇文章中對他們進行總結。

我希望你能夠喜歡這篇文章。你可以將之當做一個教程，一個補習資料，或者一個參考。本文章的目的僅僅是為Python中的魔術方法提供一個友好的教程。

構造和初始化

每個人都知道一個最基本的魔術方法， __init__ 。通過此方法我們可以定義一個物件的初始操作。然而，當我呼叫 x = SomeClass() 的時候， __init__並不是第一個被呼叫的方法。實際上，還有一個叫做 __new__ 的方法，來構造這個例項。然後給在開始建立時候的初始化函式來傳遞引數。在物件生命週期的另一端，也有一個 __del__ 方法。我們現在來近距離的看一看這三個方法:

__new__(cls, [...) __new__ 是在一個物件例項化的時候所呼叫的第一個方法。它的第一個引數是這個類，其他的引數是用來直接傳遞給 __init__ 方法。__new__ 方法相當不常用,但是它有自己的特性，特別是當繼承一個不可變的型別比如一個tuple或者string。我不希望在 __new__ 上有太多細節，因為並不是很有用處，但是在 Python文件 中有詳細的闡述。

__init__(self, […) 此方法為類的初始化方法。當建構函式被呼叫的時候的任何引數都將會傳給它。(比如如果我們呼叫 x = SomeClass(10, 'foo'))，那麼 __init__ 將會得到兩個引數10和foo。 __init__ 在Python的類定義中被廣泛用到。

__del__(self) 如果 __new__ 和 __init__ 是物件的構造器的話，那麼 __del__ 就是析構器。它不實現語句 del x (以上程式碼將不會翻譯為 x.__del__())。它定義的是當一個物件進行垃圾回收時候的行為。當一個物件在刪除的時需要更多的清潔工作的時候此方法會很有用，比如套接字物件或者是檔案物件。注意，如果直譯器退出的時候物件還存存在，就不能保證 __del__ 能夠被執行，所以 __del__ can’t serve as a replacement for good coding practices ()~~~~~~~

放在一起的話，這裡是一個 __init__ 和 __del__ 實際使用的例子。

from os.path import join

class FileObject:
    '''給檔案物件進行包裝從而確認在刪除時檔案流關閉'''

    def __init__(self, filepath='~', filename='sample.txt'):
        #讀寫模式開啟一個檔案
        self.file = open(join(filepath, filename), 'r+')

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

讓定製的類工作起來

使用Python的魔術方法的最大優勢在於他們提供了一種簡單的方法來讓物件可以表現的像內建型別一樣。那意味著你可以避免醜陋的，違反直覺的，不標準的的操作方法。在一些語言中，有一些操作很常用比如：

if instance.equals(other_instance):
    # do something

在Python中你可以這樣。但是這會讓人迷惑且產生不必要的冗餘。相同的操作因為不同的庫會使用不同的名字，這樣會產生不必要的工作。然而有了魔術方法的力量，我們可以定義一個方法(本例中為 __eq__ )，就說明了我們的意思：

if instance == other_instance:
        #do something

這只是魔術方法的功能的一小部分。它讓你可以定義符號的含義所以我們可以在我們的類中使用。就像內建型別一樣。

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

    def __new__(cls, word):
        # 注意我們必須要用到__new__方法，因為str是不可變型別
        # 所以我們必須在建立的時候將它初始化
        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)

some_object + other

other + some_object

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

表現你的類

如果有一個字串來表示一個類將會非常有用。在Python中，有很多方法可以實現類定義內建的一些函式的返回值。 __str__(self) 定義當 str() 呼叫的時候的返回值 __repr__(self) 定義 repr() 被呼叫的時候的返回值。 str() 和 repr() 的主要區別在於 repr() 返回的是機器可讀的輸出，而 str() 返回的是人類可讀的。 __unicode__(self) 定義當 unicode() 呼叫的時候的返回值。 unicode() 和 str() 很相似，但是返回的是unicode字串。注意，如a果對你的類呼叫 str() 然而你只定義了 __unicode__() ，那麼將不會工作。你應該定義 __str__() 來確保呼叫時能返回正確的值。

__hash__(self) 定義當 hash() 呼叫的時候的返回值，它返回一個整形，用來在字典中進行快速比較 __nonzero__(self) 定義當 bool() 呼叫的時候的返回值。本方法應該返回True或者False，取決於你想讓它返回的值。

控制屬性訪問

許多從其他語言轉到Python的人會抱怨它缺乏類的真正封裝。(沒有辦法定義私有變數，然後定義公共的getter和setter)。Python其實可以通過魔術方法來完成封裝。我們來看一下:

__getattr__(self, name) 你可以定義當使用者試圖獲取一個不存在的屬性時的行為。這適用於對普通拼寫錯誤的獲取和重定向，對獲取一些不建議的屬性時候給出警告(如果你願意你也可以計算並且給出一個值)或者處理一個 AttributeError 。只有當呼叫不存在的屬性的時候會被返回。然而，這不是一個封裝的解決方案。 __setattr__(self, name, value) 與 __getattr__ 不同， __setattr__ 是一個封裝的解決方案。無論屬性是否存在，它都允許你定義對對屬性的賦值行為，以為這你可以對屬性的值進行個性定製。但是你必須對使用 __setattr__ 特別小心。之後我們會詳細闡述。 __delattr__ 與__setattr__ 相同，但是功能是刪除一個屬性而不是設定他們。注意與 __setattr__ 相同，防止無限遞迴現象發生。(在實現 __delattr__ 的時候呼叫 delself.name 即會發生) __getattribute__(self, name) __getattribute__ 與它的同伴 __setattr__ 和 __delattr__ 配合非常好。但是我不建議使用它。只有在新型別類定義中才能使用 __getattribute__ (在最新版本Python中所有的類都是新型別，在老版本中你可以通過繼承 object 來製作一個新類。這樣你可以定義一個屬性值的訪問規則。有時也會產生一些帝歸現象。(這時候你可以呼叫基類的 __getattribute__ 方法來防止此現象的發生。)它可以消除對__getattr__ 的使用，如果它被明確呼叫或者一個 AttributeError 被丟擲，那麼當實現 __getattribute__ 之後才能被呼叫。此方法是否被使用其實最終取決於你的選擇。)我不建議使用它因為它的使用機率較小(我們在取得一個值而不是設定一個值的時候有特殊的行為是非常罕見的。)而且它不能避免會出現bug。

在進行屬性訪問控制定義的時候你可能會很容易的引起一個錯誤。考慮下面的例子。

def __setattr__(self, name, value):
    self.name = value
    #每當屬性被賦值的時候， ``__setattr__()`` 會被呼叫，這樣就造成了遞迴呼叫。
    #這意味這會呼叫 ``self.__setattr__('name', value)`` ，每次方法會呼叫自己。這樣會造成程式崩潰。

def __setattr__(self, name, value):
    self.__dict__[name] = value  #給類中的屬性名分配值
    #定製特有屬性

Python的魔術方法非常強大，然而隨之而來的則是責任。瞭解正確的方法去使用非常重要。

所以我們對於定製屬性訪問許可權瞭解了多少呢。它不應該被輕易的使用。實際上，它非常強大。但是它存在的原因是:Python 不會試圖將一些不好的東西變得不可能，而是讓它們難以實現。自由是至高無上的，所以你可以做任何你想做的。以下是一個特別的屬性控制的例子(我們使用 super 因為不是所有的類都有 __dict__ 屬性):

class AccessCounter:
    '''一個包含計數器的控制許可權的類每當值被改變時計數器會加一'''

    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)]

建立定製的序列

有很多方法讓你的Python類行為可以像內建的序列(dict, tuple,list, string等等)。這是目前為止我最喜歡的魔術方法,因為它給你很搞的控制許可權而且讓很多函式在你的類例項上工作的很出色。但是在開始之前，需要先講一些必須條件。

class FunctionalList:
'''一個封裝了一些附加魔術方法比如 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):
    #如果鍵的型別或者值無效，列表值將會丟擲錯誤
    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個外的所有元素
    return self.values[n:]
def take(self, n):
    #返回前n個元素
    return self.values[:n]

反射

你可以通過魔術方法控制控制使用 isinstance() 和 issubclass() 內建方法的反射行為。這些魔術方法是:

__instancecheck__(self, instance)

檢查一個例項是不是你定義的類的例項

__subclasscheck__(self, subclass)

檢查一個類是不是你定義的類的子類

這些方法的用例似乎很少，這也許是真的。我不會花更多的時間在這些魔術方法上因為他們並不是很重要，但是他們的確反應了Python 中的物件導向程式設計的一些基本特性:非常容易的去做一些事情，即使並不是很必須。這些魔術方法看起來並不是很有用，但是當你需要的時候你會很高興有這種特性。

可以呼叫的物件

你也許已經知道，在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

會話管理

在Python 2.5中，為了程式碼利用定義了一個新的關鍵詞 with 語句。會話控制在Python中不罕見(之前是作為庫的一部分被實現)，直到 PEP343 被新增後。它被成為一級語言結構。你也許之前看到這樣的語句:

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

回話控制器通過包裝一個 with 語句來設定和清理行為。回話控制器的行為通過兩個魔術方法來定義: __enter__(self) 定義當使用 with 語句的時候會話管理器應該初始塊被建立的時候的行為。注意 __enter__ 的返回值被 with 語句的目標或者 as 後的名字繫結。 __exit__(self, exception_type,exception_value, traceback) 定義當一個程式碼塊被執行或者終止後會話管理器應該做什麼。它可以被用來處理異常，清除工作或者做一些程式碼塊執行完畢之後的日常工作。如果程式碼塊執行成功， exception_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 # 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

以下是一個使用 Closer 的例子，使用一個FTP連結來證明(一個可關閉的套接字):

>>> from magicmethods import Closer
>>> from ftplib import FTP
>>> with Closer(FTP('ftp.somesite.com')) as conn:
...     conn.dir()
...
>>> conn.dir()
>>> with Closer(int(5)) as i:
...     i += 1
...
Not closable.
>>> i
6

你已經看到了我們的包裝器如何靜默的處理適當和不適當的使用行為。這是會話管理器和魔術方法的強大功能。

建立物件的描述器

描述器是通過得到，設定，刪除的時候被訪問的類。當然也可以修改其他的物件。描述器並不是鼓勵的，他們註定被一個所有者類所持有。當建立物件導向的資料庫或者類，裡面含有相互依賴的屬性時，描述器將會非常有用。一種典型的使用方法是用不同的單位表示同一個數值，或者表示某個資料的附加屬性(比如座標系上某個點包含了這個點到遠點的距離資訊)。

為了構建一個描述器，一個類必須有至少 __get__ 或者 __set__ 其中一個，並且 __delete__ 被實現。讓我們看看這些魔術方法。 __get__(self,instance, owner) 定義當描述器的值被取得的時候的行為， instance 是擁有者物件的一個例項。 owner 是擁有者類本身。 __set__(self, instance,value) 定義當描述器值被改變時候的行為。 instance 是擁有者類的一個例項 value 是要設定的值。 __delete__(self, instance) 定義當描述器的值被刪除的行為。instance 是擁有者物件的例項。 以下是一個描述器的例項:單位轉換。

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()

儲存你的物件

如果你接觸過其他的 Pythoner，你可能已經聽說過 Pickle 了， Pickle 是用來序列化 Python 資料結構的模組，在你需要暫時儲存一個物件的時候（比如快取），這個模組非常的有用，不過這同時也是隱患的誕生地。

序列化資料是一個非常重要的功能，所以他不僅僅擁有相關的模組（ Pickle , cPickle ），還有自己的協議以及魔術方法，不過首先，我們先討論下關於序列化內建資料結構的方法。

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()

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()

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