這是我們公司給應屆生學習的Python教程大全！希望對你有所幫助

自信與高年級學生在計算機實驗室中的導師

1. 簡介
本指南主題是 魔法方法 。
什麼是魔法方法呢？它們在面向對象的Python的處處皆是。它們是一些可以讓你對類添加“魔法”的特殊方法。 它們經常是兩個下劃線包圍來命名的（比如 __init__ ， __lt__ ）。但是現在沒有很好的文檔來解釋它們。 所有的魔法方法都會在Python的官方文檔中找到， 但是它們組織鬆散。而且很少會有示例（有的是無聊的語法描述， 語言參考） 。
所以，為了修復我感知的Python文檔的缺陷，我開始提供更為通俗的，有示例支持的Python魔法方法指南。我一開始 寫了一些博文，現在我把這些博文總起來成為一篇指南。
希望你喜歡這篇指南，一篇友好，通俗易懂的Python魔法方法指南！
2. 構造方法
我們最為熟知的基本的魔法方法就是 __init__ ，我們可以用它來指明一個對象初始化的行為。然而，當我們調用 x = SomeClass() 的時候， __init__ 並不是第一個被調用的方法。事實上，第一個被調用的是 __new__ ，這個 方法才真正地創建了實例 。當這個對象的 生命週期結束的時候， __del__ 會被調用 。讓我們近一步理解這三個方法：
__new__(cls,[...)

！

<code>from os.path import joinclass 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/<code>

3. 操作符
使用Python魔法方法的一個 巨大優勢就是可以構建一個擁有Python內置類型行為的對象 。這意味著你 可以避免使用非標準的、醜陋的方式來表達簡單的操作 。 在一些語言中，這樣做很常見:

<code>if instance.equals(other_instance): # do something/<code>

你當然可以在Python也這麼做， 但是這樣做讓代碼變得冗長而混亂 。 不同的類庫可能對同一種比較操作採用不同的方法名稱 ，這讓使用者需要做很多沒有必要的工作。 運用魔法方法的魔力，我們可以定義方法 __eq_

<code>if instance == other_instance: # do something/<code>

這是魔法力量的一部分， 這樣我們就可以創建一個像內建類型那樣的對象了 ！
3.1. 比較操作符
Python包含了一系列的魔法方法， 用於實現對象之間直接比較，而不需要採用方法調用 。同樣也 可以重載Python默認的比較方法，改變它們的行為 。下面是這些方法的列表：

<code>class Word(str): '''單詞類，按照單詞長度來定義比較行為''' def __new__(cls, word): # 注意，我們只能使用 __new__ ，因為str是不可變類型 # 所以我們必須提前初始化它（在實例創建時） if ' ' in word: print "Value contains spaces. Truncating to first space." word = word[:word.index(' ')] # Word現在包含第一個空格前的所有字母 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)/<code> 

現在我們可以 創建兩個 Word 對象（ Word(‘foo’) 和 Word(‘bar’))然後根據長度來比較它們 。注意我們沒有定義 __eq__ 和 __ne__ ，這是因為有時候它們會導致奇怪的結果（很明顯， Word(‘foo’) == Word(‘bar’) 得到的結果會是true）。 根據長度測試是否相等毫無意義，所以我們使用 str 的實現來比較相等 。
從上面可以看到，不需要實現所有的比較魔法方法，就可以使用豐富的比較操作。標準庫還在 functools 模塊中提供了一個類裝飾器，只要我們定義 __eq__ 和另外一個操作符（ __gt__, __lt__ 等），它就可以幫我們實現比較方法。這個特性只在 Python 2.7 中可用。當它可用時，它能幫助我們節省大量的時間和精力。 要使用它，只需要它 @total_ordering 放在類的定義之上就可以了
3.2. 數值操作符
就像你可以使用比較操作符來比較類的實例，你也可以定義數值操作符的行為。固定好你的安全帶，這樣的操作符真的有很多。看在組織的份上，我把它們分成了五類：一元操作符，常見算數操作符， 反射算數操作符 （後面會涉及更多），增強賦值操作符，和類型轉換操作符。
3.2.1. 一元操作符
一元操作符只有一個操作符。
__pos__(self)
實現取正操作，例如 +some_object。
__neg__(self)

__add__(self, other)
實現加法操作。
__sub__(self, other)
實現減法操作。
__mul__(self, other)
實現乘法操作。
__floordiv__(self, other)
實現使用 // 操作符的整數除法。
__div__(self, other)
實現使用 / 操作符的除法。
__truediv__(self, other)
實現 _true_ 除法，這個函數只有使用 from __future__ import division時才有作用。
__mod__(self, other)
實現 % 取餘操作。
__divmod__(self, other)
實現 divmod 內建函數。
__pow__
實現 ** 操作符。
__lshift__(self, other)
實現左移位運算符 << 。
__rshift__(self, other)
實現右移位運算符 >> 。
__and__(self, other)
實現按位與運算符 & 。
__or__(self, other)
實現按位或運算符 | 。
__xor__(self, other)
實現按位異或運算符 ^ 。
3.2.3. 反射算數運算符
還記得剛才我說會談到反射運算符嗎？可能你會覺得它是什麼高端霸氣上檔次的概念，其實這東西挺簡單的，下面舉個例子:

<code>some_object + other/<code>

這是“常見”的加法，反射是一樣的意思， 只不過是運算符交換了一下位置 :

<code>other + some_object/<code>

所有反射運算符魔法方法和它們的常見版本做的工作相同，只不過是處理交換連個操作數之後的情況。絕大多數情況下，反 射運算和正常順序產生的結果是相同的，所以很可能你定義 __radd__ 時只是調用一下 __add__ 。注意一點，操作符 左側的對象（也就是上面的 other ）一定不要定義 （或者產生 NotImplemented 異常） 操作符的非反射版本。例如，在上面的例子中， 只有當 other 沒有定義 __add__ 時 some_object.__radd__ 才會被調用 。
__radd__(self, other)
實現反射加法操作。
__rsub__(self, other)
實現反射減法操作。
__rmul__(self, other)
實現反射乘法操作。
__rfloordiv__(self, other)
實現使用 // 操作符的整數反射除法。
__rdiv__(self, other)
實現使用 / 操作符的反射除法。
__rtruediv__(self, other)
實現 _true_ 反射除法，這個函數只有使用 from __future__ import division 時才有作用。

<code>　　x = 5　　x += 1 # 也就是 x = x + 1/<code>

這些方法都應該返回左側操作數應該被賦予的值（例如， a += b __iadd__ 也許會返回 a + b ，這個結果會被賦給 a ）,下面是方法列表：
__iadd__(self, other)
實現加法賦值操作。
__isub__(self, other)

<code>def __setattr__(self, name. value): self.name = value # 因為每次屬性幅值都要調用 __setattr__()，所以這裡的實現會導致遞歸 # 這裡的調用實際上是 self.__setattr('name', value)。因為這個方法一直 # 在調用自己，因此遞歸將持續進行，直到程序崩潰def __setattr__(self, name, value): self.__dict__[name] = value # 使用 __dict__ 進行賦值 # 定義自定義行為/<code>

再次重申，Python的魔法方法十分強大，能力越強責任越大，瞭解如何正確的使用魔法方法更加重要。
到這裡，我們對Python中自定義屬性存取控制有了什麼樣的印象？它並不適合輕度的使用。實際上，它有些過分強大，而且違反直覺。然而它之所以存在，是因為一個更大的原則： Python不指望讓杜絕壞事發生，而是想辦法讓做壞事變得困難 。 自由是至高無上的權利，你真的可以隨心所欲 。下面的例子展示了實際應用中某些特殊的屬性訪問方法（注意我們之所以使用 super 是因為不是所有的類都有 __dict__ 屬性 ）:

<code>class AccessCounter(object): ''' 一個包含了一個值並且實現了訪問計數器的類 每次值的變化都會導致計數器自增''' 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)/<code>

6. 自定義序列
有許多辦法可以讓你的Python類表現得像是 內建序列類型（字典，元組，列表，字符串等） 。這些魔法方式是目前為止我最喜歡的。 它們給了你難以置信的控制能力 ，可以讓你的類與一系列的全局函數完美結合。在瞭解激動人心的內容之前，首先你需要掌握一些預備知識。
6.1. 預備知識
既然講到創建自己的序列類型，就不得不說一說協議了。 協議類似某些語言中的接口，裡面包含的是一些必須實現的方法 。在Python中，協議完全是非正式的，也不需要顯式的聲明，事實上，它們更像是一種參考標準。
為什麼我們要講協議？因為在Python中實現自定義容器類型需要用到一些協議。 首先，不可變容器類型有如下協議：想實現一個不可變容器，你需要定義 __len__ 和 __getitem__ (後面會具體說明） 。可變容器的 協議除了上面提到的兩個方法之外，還需要定義 __setitem__ 和 __delitem__ 。最後，如果你想讓你的對象可以迭代，你需要定義 __iter__ ，這個方法返回一個迭代器。 迭代器必須遵守迭代器協議，需要定義 __iter__ （返回它自己）和 next 方法 。

<code>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.valuse[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]/<code>

就是這些， 一個（微不足道的）有用的例子，向你展示瞭如何實現自己的序列 。當然啦，自定義序列有更大的用處，而且絕大部分都在標準庫中實現了（Python是自帶電池的，記得嗎？），像 Counter , OrderedDict 和 NamedTuple 。
7. 反射
你可以通過定義魔法方法來控制用於 反射的內建函數 isinstance 和 issubclass 的行為 。下面是對應的魔法方法：
__instancecheck__(self, instance)
檢查一個實例是否是你定義的類的一個實例（例如 isinstance(instance, class) ）。

<code>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/<code>

10. 上下文管理器
在Python 2.5中引入了一個全新的關鍵詞，隨之而來的是 一種新的代碼複用方法—— with 聲明 。上下文管理的概念在Python中並不是全新引入的（之前它作為標準庫的一部分實現），直到PEP 343被接受，它才成為一種一級的語言結構。可能你已經見過這種寫法了:

<code>with open('foo.txt') as bar: # 使用bar進行某些操作/<code>

當對象使用 with 聲明創建時，上下文管理器允許類做一些設置和清理工作。 上下文管理器的行為 由 下面兩個魔法方法 所定義：
__enter__(self)
定義使用 with 聲明創建的語句塊最開始上下文管理器 應該做些什麼 。注意 __enter__ 的返回值會 賦給 with 聲明的目標 ，也就是 as 之後的東西。
__exit__(self, exception_type, exception_value, traceback)
定義當 with 聲明語句塊執行完畢（或終止）時上下文管理器的行為。 它可以用來處理異常，進行清理，或者做其他應該在語句塊結束之後立刻執行的工作 。如果語句塊順利執行， exception_type , exception_value 和 traceback 會是 None 。否則，你可以選擇處理這個異常或者讓用戶來處理。如果你想處理異常，確保 __exit__ 在完成工作之後返回 True 。如果你不想處理異常，那就讓它發生吧。

<code>class Closer: '''一個上下文管理器，可以在with語句中 使用close()自動關閉對象''' def __init__(self, obj): self.obj = obj def __enter__(self, obj): return self.obj # 綁定到目標 def __exit__(self, exception_type, exception_value, traceback): try: self.obj.close() except AttributeError: # obj不是可關閉的 print 'Not closable.' return True # 成功地處理了異常/<code>

這是一個 Closer 在實際使用中的例子，使用一個FTP連接來演示（一個可關閉的socket):

<code>>>> from magicmethods import Closer>>> from ftplib import FTP>>> with Closer(FTP('ftp.somesite.com')) as conn:... conn.dir()...# 為了簡單，省略了某些輸出>>> conn.dir()# 很長的 AttributeError 信息，不能使用一個已關閉的連接>>> with Closer(int(5)) as i:... i += 1...Not closable.>>> i6/<code>

看到我們的包裝器是如何同時優雅地處理正確和不正確的調用了嗎？這就是上下文管理器和魔法方法的力量。Python標準庫包含一個 contextlib 模塊，裡面有一個上下文管理器 contextlib.closing() 基本上和我們的包裝器完成的是同樣的事情（但是沒有包含任何當對象沒有close()方法時的處理）。
11. 創建描述符對象
描述符是一個類，當使用取值，賦值和刪除 時它可以改變其他對象。 描述符不是用來單獨使用的，它們需要被一個擁有者類所包含 。描述符可以用來創建面向對象數據庫，以及創建某些屬性之間互相依賴的類。 描述符在表現具有不同單位的屬性，或者需要計算的屬性時顯得特別有用 （例如表現一個座標系中的點的類，其中的距離原點的距離這種屬性）。

<code>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, owner): 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.2808class Distance(object): '''用於描述距離的類，包含英尺和米兩個描述符。''' meter = Meter() foot = Foot()/<code>

12. 拷貝
有些時候，特別是處理可變對象時，你可能想拷貝一個對象， 改變這個對象而不影響原有的對象 。這時就需要用到Python的 copy 模塊了。然而（幸運的是），Python模塊並不具有感知能力， 因此我們不用擔心某天基於Linux的機器人崛起。但是我們的確需要告訴Python如何有效率地拷貝對象。
__copy__(self)
定義對類的實例使用 copy.copy() 時的行為。 copy.copy() 返回一個對象的淺拷貝 ，這意味著拷貝出的實例是全新的， 然而裡面的數據全都是引用的 。也就是說，對象本身是拷貝的，但是它的數據還是引用的（ 所以淺拷貝中的數據更改會影響原對象 ）。

<code>import pickledata = {'foo': [1,2,3], 'bar': ('Hello', 'world!'), 'baz': True}jar = open('data.pkl', 'wb')pickle.dump(data, jar) # 將pickle後的數據寫入jar文件jar.close()/<code>

過了幾個小時，我們想把它取出來，我們只需要反pickle它:

<code>import picklepkl_file = open('data.pkl', 'rb') # 與pickle後的數據連接data = pickle.load(pkl_file) # 把它加載進一個變量print datapkl_file.close()/<code>

將會發生什麼？正如你期待的，它就是我們之前的 data 。
現在，還需要謹慎地說一句： pickle並不完美。Pickle文件很容易因為事故或被故意的破壞掉。 Pickling或許比純文本文件安全一些，但是依然有可能被用來運行惡意代碼 。而且它還不支持跨Python版本，所以 不要指望分發pickle對象之後所有人都能正確地讀取 。然而不管怎麼樣，它依然是一個強有力的工具，可以用於緩存和其他類型的持久化工作。
13.2. Pickle你的對象
Pickle不僅僅可以用於內建類型，任何遵守pickle協議的類都可以被pickle。Pickle協議有四個可選方法，可以讓類自定義它們的行為（這和C語言擴展略有不同，那不在我們的討論範圍之內）。
__getinitargs__(self)
如果 你想讓你的類在反pickle時調用 __init__ ，你可以定義 __getinitargs__(self)，它會返回一個參數元組，這個元組會傳遞給 __init__ 。注意，這個方法只能用於舊式類。

<code>import timeclass Slate: '''存儲一個字符串和一個變更日誌的類 每次被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_change(self): print 'Changelog for Slate object:' for k,v in self.history.items(): print '%s\\\\\\\\t %s' % (k,v) def __getstate__(self): # 故意不返回self.value或self.last_change # 我們想在反pickle時得到一個空白的slate return self.history def __setstate__(self): # 使self.history = slate，last_change # 和value為未定義 self.history = state self.value, self.last_change = None, None/<code>

福利：轉發評論+私信“學習”即可領取Python視頻教程

閱讀更多 王組長的隊員 的文章

關鍵字: 跳槽那些事兒 教程 應屆生