Python with/as和contextlib上下文管理使用說明

with/as

使用open打開過文件的對with/as都已經很是熟悉，其實with/as是對try/finally的一種替代方案。

當某個對象支持一種稱爲"環境管理協議"的協議時，就會經過環境管理器來自動執行某些善後清理工做，就像finally同樣：無論中途是否發生異常，最終都會執行某些清理操做。

用法：

with expression [as var]:
    with_block_code

當expression返回的對象是支持環境管理協議的時候，就可使用with。as var是可選的，若是不使用as var，expression返回對象將被丟棄，若是使用as var，就會將expression的返回對象賦值給變量var。

整個流程大體以下：先評估expression，若是支持環境管理協議，而後開始with/as語句塊結構，當準備退出with語句塊的時候，將執行對象中定義的善後操做。工做機制的細節見下文。

例如，open()返回的文件對象是支持環境管理協議的，因此能夠用with/as來安全地打開文件：

with open(r'd:\a\b\c\a.log') as logfile:
    for line in logfile:
        print(line)
        ...more code here...

整個過程是先open()，而後with/as，輸出每一行後將要退出with語句塊的時候，環境管理器根據文件對象中定義的操做關閉文件。

它實際上等價於：

myfile = open(r'd:\a\b\c\a.log')
try:
    for line in myfile:
        print(line)
        ...more code here...
finally:
    myfile.close()

雖然在文件不被引用以後，垃圾回收器會自動回收這個文件對象，可是垃圾回收器的回收操做是有等待時間的。換句話說，若是不使用with/as打開文件，也不顯示close()關閉文件，那麼這個文件極可能會在用完以後保持空閒一段時間，而後才被垃圾回收器回收。

with/as不只用於文件打開/關閉，鎖操做也支持環境管理協議，也就是說，在有須要的時候會自動釋放鎖資源。

嵌套多個環境管理器

在python 3.1以後，with as支持多個環境管理器，使用逗號隔開便可。

with A() as a, B() as b:
    ...statements...

它等價於嵌套的with：

with A() as a:
    with B() as b:
        ...statements...

多環境管理器管理的多個對象會在with語句塊中出現異常的時候，或者執行完with語句塊的時候所有自動被清理(例如文件關閉操做)。

例如，打開兩個文件，將它們的內容經過zip()合併在一塊兒，而且同時關閉它們：

with open('a.file') as f1, open('b.file') as f2:
    for pair in zi[(f1, f2):
        print(pair)

自定義環境管理器

不管是文件仍是鎖，都是別人已經寫好了環境管理器的對象。咱們本身也能夠寫環境管理器，讓它可使用with/as，這實際上屬於運算符重載的範疇。

要寫本身的環境管理器，先了解with/as的工做機制的細節：

1. 先評估expression，評估的返回結果是一個對象，這個對象要具備__enter__和__exit__方法，返回的對象稱爲"環境管理器"
   
2. 而後調用環境管理器的__enter__方法。__enter__方法的返回值賦值給 as 指定的變量，或者直接丟棄(沒有使用as)
   
3. 而後執行with語句塊中的內容
   
4. 若是執行with語句塊中的內容時拋出了異常，將調用__exit__(type,value,traceback)方法，其中這3個和異常相關的參數來源於sys.exc_info。若是__exit__返回值爲False，則會自動從新拋異常以便傳播異常，不然異常被認爲合理處理
   
5. 若是with語句塊中的內容沒有拋異常，則直接調用__exit__(None,None,None)，即這三個參數都傳遞爲None值

看一個簡單的示例：

class TraceBlock:
    def message(self, arg):
        print('running ' + arg)

    def __enter__(self):
        print('starting with block')
        return self

    def __exit__(self, exc_type, exc_value, exc_tb):
        if exc_type is None:
            print('exited normally\n')
        else:
            print('raise an exception! ' + str(exc_type))
            return False

上面的__enter__方法返回的對象會賦值給as關鍵字指定的變量，在這個示例中即將對象自身返回。若是有需求，能夠返回其它對象。

上面的__exit__中，若是異常的類型爲None，說明with語句塊中的語句執行過程沒有拋異常，正常結束便可。可是若是有異常，則要求返回False，實際上上面的return False能夠去掉，由於函數沒有return時默認返回None，它的布爾值表明的就時False。

測試下：

with TraceBlock() as action:
    action.message("test 1")
    print("reached")
    
print('-' * 20, "\n")

with TraceBlock() as action:
    action.message("test 2")
    raise TypeError
    print("not reached")

結果以下：

starting with block
running test 1
reached
exited normally

--------------------

starting with block
running test 2
raise an exception! <class 'TypeError'>
Traceback (most recent call last):
  File "g:/pycode/list.py", line 23, in <module>
    raise TypeError
TypeError

定義環境管理器不是件簡單的事。通常來講，若是不是很複雜的需求，直接使用try/finally來定義相關操做便可。

contextlib模塊

在自定義上下文管理器的時候，能夠經過contextlib模塊的contextmanager裝飾器來簡化，這樣不須要本身去寫__enter__和__exit__。

使用contextlib.contextmanager裝飾的時候，所裝飾的對象必須是一個生成器函數，且該生成器函數必須只yield一個值，這個值將會被綁定到with/as的as子句的變量上。

from contextlib import contextmanager

@contextmanager
def managed_resource(*args, **kwds):
    # Code to acquire resource, e.g.:
    resource = acquire_resource(*args, **kwds)
    try:
        yield resource
    finally:
        # Code to release resource, e.g.:
        release_resource(resource)

>>> with managed_resource(timeout=3600) as resource:
...     # Resource is released at the end of this block,
...     # even if code in the block raises an exception

它的執行流程是這樣的：

1. 當執行到with語句的時候，首先評估managed_resource(timeout=3600)，它是一個生成器函數，它會返回一個生成器
   
2. 而後執行resource = acquire_resource，並在yield的地方狀態被掛起這個生成器函數
   
3. 在yield掛起的時候，with語句塊中的語句開始執行
   
4. 當with語句塊退出的時候，yield被恢復，因而繼續執行生成器函數中後面的語句

若是在with語句塊中發生了異常且未處理，則會在生成器yield被恢復的時候再次拋出這個異常。所以，可使用try...except...finally語句來捕獲可能存在的錯誤，以便保證yield後面的語句(一般是資源釋放類的善後工做)能夠正常執行。