深刻理解 Python 中的上下文管理器

提示：前面的內容較爲基礎，重點知識在後半段。

with 這個關鍵字，對於每一學習Python的人，都不會陌生。

操做文本對象的時候，幾乎全部的人都會讓咱們要用 with open ，這就是一個上下文管理的例子。你必定已經至關熟悉了，我就再也不廢話了。

with open('test.txt') as f:
    print f.readlines()

什麼是上下文管理器？

基本語法

with EXPR as VAR:
    BLOCK

先理清幾個概念

1. 上下文表達式：with open('test.txt') as f:
2. 上下文管理器：open('test.txt')
3. f 不是上下文管理器，應該是資源對象。

如何寫上下文管理器？

要本身實現這樣一個上下文管理，要先知道上下文管理協議。

簡單點說，就是在一個類裏，實現了__enter__和__exit__的方法，這個類的實例就是一個上下文管理器。

例如這個示例：

class Resource():
    def __enter__(self):
        print('===connect to resource===')
        return self
    def __exit__(self, exc_type, exc_val, exc_tb):
        print('===close resource connection===')
        
    def operate(self):
        print('===in operation===')
        
with Resource() as res:
    res.operate()

咱們執行一下，經過日誌的打印順序。能夠知道其執行過程。

===connect to resource===
===in operation===
===close resource connection===

從這個示例能夠很明顯的看出，在編寫代碼時，能夠將資源的鏈接或者獲取放在__enter__中，而將資源的關閉寫在__exit__ 中。

爲何要用上下文管理器？

學習時多問本身幾個爲何，養成對一些細節的思考，有助於加深對知識點的理解。

爲何要使用上下文管理器？

在我看來，這和 Python 崇尚的優雅風格有關。

1. 能夠以一種更加優雅的方式，操做（建立/獲取/釋放）資源，如文件操做、數據庫鏈接；
2. 能夠以一種更加優雅的方式，處理異常；

第一種，咱們上面已經以資源的鏈接爲例講過了。

而第二種，會被大多數人所忽略。這裏會重點講一下。

你們都知道，處理異常，一般都是使用 try...execept.. 來捕獲處理的。這樣作一個很差的地方是，在代碼的主邏輯裏，會有大量的異常處理代理，這會很大的影響咱們的可讀性。

好一點的作法呢，能夠使用 with 將異常的處理隱藏起來。

仍然是以上面的代碼爲例，咱們將1/0 這個必定會拋出異常的代碼寫在 operate 裏

class Resource():
    def __enter__(self):
        print('===connect to resource===')
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        print('===close resource connection===')
        return True

    def operate(self):
        1/0

with Resource() as res:
    res.operate()

運行一下，驚奇地發現，竟然不會報錯。

這就是上下文管理協議的一個強大之處，異常能夠在__exit__ 進行捕獲並由你本身決定如何處理，是拋出呢仍是在這裏就解決了。在__exit__ 裏返回 True（沒有return 就默認爲 return False），就至關於告訴 Python解釋器，這個異常咱們已經捕獲了，不須要再往外拋了。

在 寫__exit__ 函數時，須要注意的事，它必需要有這三個參數：

• exc_type：異常類型
• exc_val：異常值
• exc_tb：異常的錯誤棧信息

當主邏輯代碼沒有報異常時，這三個參數將都爲None。

理解並使用 contextlib

在上面的例子中，咱們只是爲了構建一個上下文管理器，卻寫了一個類。若是隻是要實現一個簡單的功能，寫一個類未免有點過於繁雜。這時候，咱們就想，若是隻寫一個函數就能夠實現上下文管理器就行了。

這個點Python早就想到了。它給咱們提供了一個裝飾器，你只要按照它的代碼協議來實現函數內容，就能夠將這個函數對象變成一個上下文管理器。

咱們按照 contextlib 的協議來本身實現一個打開文件（with open）的上下文管理器。

import contextlib

@contextlib.contextmanager
def open_func(file_name):
    # __enter__方法
    print('open file:', file_name, 'in __enter__')
    file_handler = open(file_name, 'r')
    
    # 【重點】：yield
    yield file_handler

    # __exit__方法
    print('close file:', file_name, 'in __exit__')
    file_handler.close()
    return

with open_func('/Users/MING/mytest.txt') as file_in:
    for line in file_in:
        print(line)

在被裝飾函數裏，必須是一個生成器（帶有yield），而yield以前的代碼，就至關於__enter__裏的內容。yield 以後的代碼，就至關於__exit__ 裏的內容。

上面這段代碼只能實現上下文管理器的第一個目的（管理資源），並不能實現第二個目的（處理異常）。

若是要處理異常，能夠改爲下面這個樣子。

import contextlib

@contextlib.contextmanager
def open_func(file_name):
    # __enter__方法
    print('open file:', file_name, 'in __enter__')
    file_handler = open(file_name, 'r')

    try:
        yield file_handler
    except Exception as exc:
        # deal with exception
        print('the exception was thrown')
    finally:
        print('close file:', file_name, 'in __exit__')
        file_handler.close()

        return

with open_func('/Users/MING/mytest.txt') as file_in:
    for line in file_in:
        1/0
        print(line)

好像只要講到上下文管理器，大多數人都會談到打開文件這個經典的例子。

可是在實際開發中，能夠使用到上下文管理器的例子也很多。我這邊舉個我本身的例子。

在OpenStack中，給一個虛擬機建立快照時，須要先建立一個臨時文件夾，來存放這個本地快照鏡像，等到本地快照鏡像建立完成後，再將這個鏡像上傳到Glance。而後刪除這個臨時目錄。

這段代碼的主邏輯是建立快照，而建立臨時目錄，屬於前置條件，刪除臨時目錄，是收尾工做。

雖然代碼量不多，邏輯也不復雜，可是「建立臨時目錄，使用完後再刪除臨時目錄」這個功能，在一個項目中不少地方都須要用到，若是能夠將這段邏輯處理寫成一個工具函數做爲一個上下文管理器，那代碼的複用率也大大提升。

代碼是這樣的

總結起來，使用上下文管理器有三個好處：

1. 提升代碼的複用率；
2. 提升代碼的優雅度；
3. 提升代碼的可讀性；

---