Python上下文管理器怎么使用

這篇文章主要介紹了Python上下文管理器怎么使用的相關知識，內容詳細易懂，操作簡單快捷，具有一定借鑒價值，相信大家閱讀完這篇Python上下文管理器怎么使用文章都會有所收獲，下面我們一起來看看吧。

什么是上下文管理器？

即使你沒有聽說過 Python 的上下文管理器，根據介紹，你也已經知道，它是try/finally塊的替代品。它是使用打開文件時常用的語句with來實現的。與try/finally相同，引入此模式是為了保證在塊末尾執行某些操作，即使發生異常或程序終止。

從表面上看，上下文管理協議只是圍繞with代碼塊的語句。實際上，它包含 2 個特殊的 ( dunder ) 方法 -__enter__和__exit__組成，分別有助于啟動和停止。

當代碼中遇到with語句時，將觸發__enter__方法并將其返回值放入as限定符后面的變量中。with塊體執行完畢后，調用__exit__方法進行停止——完成finally塊的作用。

# Using try/finally
import time

start = time.perf_counter()  # Setup
try:  # Actual body
    time.sleep(3)
finally:  # Teardown
    end = time.perf_counter()
    elapsed = end - start

print(elapsed)

# Using Context Manager
with Timer() as t:
    time.sleep(3)

print(t.elapsed)

上面的代碼顯示了使用try/finally的版本和使用with語句來實現簡單的計時器的更優雅的版本。如上所述，實現這樣的上下文管理器需要__enter__和__exit__，但是我們將如何創建它們呢？我們看一下這個Timer類的代碼：

# Implementation of above context manager
class Timer:
    def __init__(self):
        self._start = None
        self.elapsed = 0.0

    def start(self):
        if self._start is not None:
            raise RuntimeError('Timer already started...')
        self._start = time.perf_counter()

    def stop(self):
        if self._start is None:
            raise RuntimeError('Timer not yet started...')
        end = time.perf_counter()
        self.elapsed += end - self._start
        self._start = None

    def __enter__(self):  # Setup
        self.start()
        return self

    def __exit__(self, *args):  # Teardown
        self.stop()

此代碼片段顯示了實現__enter__和__exit__方法的Timer類。__enter__方法僅啟動計時器并返回self，self將在with ....中作為some_var賦值， with語句體完成后，將使用 3 個參數調用__exit__方法 - 異常類型、異常值和回溯。如果with語句正文中一切順利，則這些都等于None。如果引發異常，這些將填充異常數據，我們可以在__exit__方法中處理這些數據。在這種情況下，我們省略了異常處理，只是停止計時器并計算經過的時間，并將其存儲在上下文管理器的屬性中。

我們已經在這里看到了with語句的實現和示例用法，但是為了更直觀地了解實際發生的情況，讓我們看看如何在沒有 Python 語法糖的情況下調用這些特殊方法：

manager = Timer()
manager.__enter__()  # Setup
time.sleep(3)  # Body
manager.__exit__(None, None, None)  # Teardown
print(manager.elapsed)

現在我們已經確定了什么是上下文管理器，它是如何工作的以及如何實現它，讓我們看看使用它的好處——只是為了有更多的動力從try/finally切換到with語句。

第一個好處是整個啟動和停止都在上下文管理器對象的控制下進行。這可以防止錯誤并減少樣板代碼，從而使 API 更安全、更易于使用。使用它的另一個原因是with塊突出了關鍵部分并鼓勵你減少該部分中的代碼量，這通常也是一個好習慣。最后——最后但并非最不重要的一點——它是一個很好的重構工具，它可以將常見的啟動和停止代碼分解出來，并將其移動到一個位置——即__enter__和__exit__方法。

話雖如此，我希望我能說服你開始使用上下文管理器，而不是try/finally，即使你以前沒有使用過它們。那么，現在讓我們看看一些很酷且有用的上下文管理器，你應該開始將它們包含在你的代碼中！

@contextmanager

在上一節中，我們探討了如何使用__enter__和__exit__方法實現上下文管理器。這很簡單，但我們可以使用contextlib，更具體地說，使用@contextmanager，使其更簡單。

@contextmanager是一個裝飾器，可用于編寫自包含的上下文管理函數。因此，我們不需要創建整個類并實現__enter__和__exit__方法，我們只需要創建一個生成器：

from contextlib import contextmanager
from time import time, sleep

@contextmanager
def timed(label):
    start = time()  # Setup - __enter__
    print(f"{label}: Start at {start}")
    try:  
        yield  # yield to body of `with` statement
    finally:  # Teardown - __exit__
        end = time()
        print(f"{label}: End at {end} ({end - start} elapsed)")

with timed("Counter"):
    sleep(3)

# Counter: Start at 1599153092.4826472
# Counter: End at 1599153095.4854734 (3.00282621383667 elapsed)

此代碼段實現了與上一節中的Timer類非常相似的上下文管理器。然而，這一次，我們需要的代碼要少得多。這段代碼分為兩個部分，一部分是在yield之前，另一部分是yield之后。yield之前的代碼承擔了__enter__方法的工作，而yield本身是__enter__方法的return語句。yield之后的都是__exit__方法的一部分。

正如你在上面看到的，像這樣使用單個函數創建上下文管理器需要使用使用try/finally語句，因為如果在語句withy體中發生異常，它將在yield行被引發，我們需要在對應于__exit__方法的finally塊中處理它。

正如我已經提到的，這可以用于自包含的上下文管理器。但是，它不適合需要成為對象一部分的上下文管理器，例如連接或鎖。

盡管使用單個函數構建上下文管理器會迫使你使用try/finally，并且只能用于更簡單的用例，但在我看來，它仍然是構建更精簡的上下文管理器的優雅而實用的選擇。

現實生活中的例子

現在讓我們從理論轉向實用且有用的上下文管理器，你可以自己構建它。

記錄上下文管理器

當需要嘗試查找代碼中的一些bug時，你可能會首先查看日志以找到問題的根本原因。但是，這些日志可能默認設置為錯誤或警告級別，這可能不足以用于調試。更改整個程序的日志級別應該很容易，但更改特定代碼部分的日志級別可能會更復雜 - 不過，這可以通過以下上下文管理器輕松解決：

import logging
from contextlib import contextmanager

@contextmanager
def log(level):
    logger = logging.getLogger()
    current_level = logger.getEffectiveLevel()
    logger.setLevel(level)
    try:
        yield
    finally:
        logger.setLevel(current_level)

def some_function():
    logging.debug("Some debug level information...")
    logging.error('Serious error...')
    logging.warning('Some warning message...')

with log(logging.DEBUG):
    some_function()

# DEBUG:root:Some debug level information...
# ERROR:root:Serious error...
# WARNING:root:Some warning message...

超時上下文管理器

在本文的開頭，我們正在使用計時代碼塊。我們在這里嘗試的是將超時設置為with語句包圍的塊：

import signal
from time import sleep

class timeout:
    def __init__(self, seconds, *, timeout_message=""):
        self.seconds = int(seconds)
        self.timeout_message = timeout_message

    def _timeout_handler(self, signum, frame):
        raise TimeoutError(self.timeout_message)

    def __enter__(self):
        signal.signal(signal.SIGALRM, self._timeout_handler)  # Set handler for SIGALRM
        signal.alarm(self.seconds)  # start countdown for SIGALRM to be raised

    def __exit__(self, exc_type, exc_val, exc_tb):
        signal.alarm(0)  # Cancel SIGALRM if it's scheduled
        return exc_type is TimeoutError  # Suppress TimeoutError


with timeout(3):
    # Some long running task...
    sleep(10)

上面的代碼為這個上下文管理器聲明了一個名為timeout的類，因為這個任務不能在單個函數中完成。為了能夠實現這種超時，我們還需要使用信號-更具體地說是SIGALRM。我們首先使用signal.signal(...)將處理程序設置為SIGALRM，這意味著當內核引發SIGALRM時，將調用處理程序函數。對于這個處理程序函數（_timeout_handler），它所做的只是引發TimeoutError，如果沒有及時完成，它將停止with語句體中的執行。處理程序就位后，我們還需要以指定的秒數開始倒計時，這由signal.alarm(self.seconds)完成。

對于__exit__方法，如果上下文管理器的主體設法在時間到期之前完成，SIGALRM則將被取消，而signal.alarm(0)和程序可以繼續。另一方面 - 如果由于超時而引發信號，那么_timeout_handler將引發TimeoutError，這將__exit__被捕獲和抑制，with語句主體將被中斷，其余代碼可以繼續執行。

使用已有的

除了上面的上下文管理器，標準庫或其他常用庫（如request或sqlite3）中已經有很多有用的上下文管理程序。那么，讓我們看看我們可以在那里找到什么。

臨時更改小數精度

如果你正在執行大量數學運算并需要特定的精度，那么你可能會遇到需要臨時更改十進制數精度的情況：

from decimal import getcontext, Decimal, setcontext, localcontext, Context

# Bad
old_context = getcontext().copy()
getcontext().prec = 40
print(Decimal(22) / Decimal(7))
setcontext(old_context)

# Good
with localcontext(Context(prec=50)):
    print(Decimal(22) / Decimal(7))  # 3.1428571428571428571428571428571428571428571428571

print(Decimal(22) / Decimal(7))      # 3.142857142857142857142857143

上面的代碼演示了不帶和帶上下文管理器的選項。第二個選項顯然更短，更具可讀性。它還考慮了臨時上下文，使其不易出錯。

contextlib

在使用@contextmanager時，我們已經窺探了contextlib，但我們可以使用更多的東西——作為第一個示例，讓我們看看redirect_stdout和redirect redirect_stderr：

import sys
from contextlib import redirect_stdout

# Bad
with open("help.txt", "w") as file:
    stdout = sys.stdout
    sys.stdout = file
    try:
        help(int)
    finally:
        sys.stdout = stdout

# Good
with open("help.txt", "w") as file:
    with redirect_stdout(file):
        help(int)

如果你有一個工具或函數，默認情況下將所有數據輸出到stdout或stderr，但你希望它將數據輸出到其他地方——例如文件。那么這兩個上下文管理器可能非常有用。與前面的示例一樣，這大大提高了代碼的可讀性，并消除了不必要的視覺干擾。

contextlib的另一個方便的方法是suppress上下文管理器，它將抑制任何不需要的異常和錯誤：

import os
from contextlib import suppress

try:
    os.remove('file.txt')
except FileNotFoundError:
    pass


with suppress(FileNotFoundError):
    os.remove('file.txt')

當然，正確處理異常是更好的，但有時你只需要消除令人討厭的DeprecationWarning警告，這個上下文管理器至少會使它可讀。

我將提到的contextlib中的最后一個實際上是我最喜歡的，它叫做closing：

# Bad
try:
    page = urlopen(url)
    ...
finally:
    page.close()

# Good
from contextlib import closing

with closing(urlopen(url)) as page:
    ...

此上下文管理器將關閉作為參數傳遞給它的任何資源（在上面的示例中），即page對象。至于在后臺實際發生的情況，上下文管理器實際上只是強制調用頁面對象的.close()方法，與使用try/finally選項的方式相同。

用于更好測試的上下文管理器

若你們想讓人們使用、閱讀或維護你們所寫的測試，你們必須讓他們可讀，易于理解和模仿。mock.patch上下文管理器可以幫助你：

# Bad
import requests
from unittest import mock
from unittest.mock import Mock

r = Mock()
p = mock.patch('requests.get', return_value=r)
mock_func = p.start()
requests.get(...)
# ... do some asserts
p.stop()

# Good
r = Mock()
with mock.patch('requests.get', return_value=r):
    requests.get(...)
    # ... do some asserts

使用mock.patch上下文管理器可以讓你擺脫不必要的.start()和.stop()調用，并幫助你定義此特定模擬的明確范圍。這個測試的好處是它可以與unittest以及pytest一起使用，即使它是標準庫的一部分（因此也是unittest）。

說到pytest，讓我們也展示一下這個庫中至少一個非常有用的上下文管理器：

import pytest, os

with pytest.raises(FileNotFoundError, message="Expecting FileNotFoundError"):
    os.remove('file.txt')

這個例子展示了pytest.raises的非常簡單的用法，它斷言代碼塊引發提供的異常。如果沒有，則測試失敗。這對于測試預期會引發異常或失敗的代碼路徑非常方便。

跨請求持久化會話

從pytest轉到另一個偉大的庫——requests。通常，你可能需要在HTTP請求之間保留cookie，需要保持TCP連接活動，或者只想對同一主機執行多個請求。requests提供了一個很好的上下文管理器來幫助應對這些挑戰，即管理會話：

import requests

with requests.Session() as session:
    session.request(method=method, url=url, **kwargs)

除了解決上述問題之外，這個上下文管理器還可以幫助提高性能，因為它將重用底層連接，因此避免為每個請求/響應對打開新連接。

管理 SQLite 事務

最后但同樣重要的是，還有用于管理SQLite事務的上下文管理器。除了使代碼更干凈之外，此上下文管理器還提供了在異常情況下回滾更改的能力，以及在with語句體成功完成時自動提交的能力：

import sqlite3
from contextlib import closing

# Bad
connection = sqlite3.connect(":memory:")
try:
    connection.execute("INSERT INTO employee(firstname, lastname) values (?, ?)", ("John", "Smith",))
except sqlite3.IntegrityError:
    ...

connection.close()

# Good
with closing(sqlite3.connect(":memory:")) as connection:
    with connection:
        connection.execute("INSERT INTO employee(firstname, lastname) values (?, ?)", ("John", "Smith",))

在本例中，你還可以看到closing上下文管理器的良好使用，它有助于處理不再使用的連接對象，這進一步簡化了代碼，并確保我們不會讓任何連接掛起。

關于“Python上下文管理器怎么使用”這篇文章的內容就介紹到這里，感謝各位的閱讀！相信大家對“Python上下文管理器怎么使用”知識都有一定的了解，大家如果還想學習更多知識，歡迎關注億速云行業資訊頻道。