So erweitern Sie Python-Timer mit Kontextmanagern

Wir haben oben die erste Python-Timer-Klasse erstellt und dann unsere Timer-Klasse schrittweise erweitert, und ihr Code ist auch relativ umfangreich und leistungsstark. Wir können damit nicht zufrieden sein und müssen noch eine Codevorlage erstellen, um den Timer zu verwenden:

• Erstens instanziieren Sie die Klasse
• Zweitens rufen Sie .start() vor dem Codeblock auf, den Sie zeitlich festlegen möchten
• Abschließend Rufen Sie .stop nach dem Codeblock auf ()

Ein Python-Timer-Kontextmanager

Python verfügt über ein einzigartiges Konstrukt zum Aufrufen von Funktionen vor und nach einem Codeblock: einen Kontextmanager.

Erfahren Sie mehr über Kontextmanager in Python

Kontextmanager sind seit langem ein wichtiger Bestandteil von Python. 2005 durch PEP 343 eingeführt und erstmals in Python 2.5 implementiert. Kontextmanager in Ihrem Code können mit dem Schlüsselwort with identifiziert werden:

with EXPRESSION as VARIABLE:
BLOCK

EXPRESSION sind Python-Ausdrücke, die Kontextmanager zurückgeben. Zunächst wird der Kontextmanager an den Variablennamen VARIABLE gebunden. BLOCK kann ein beliebiger regulärer Python-Codeblock sein. Der Kontextmanager stellt sicher, dass das Programm Code aufruft, bevor BLOCK ausgeführt wird, und anderen Code, nachdem BLOCK ausgeführt wird. Auf diese Weise wird die Ausnahme auch dann ausgeführt, wenn BLOCK eine Ausnahme auslöst.

Kontextmanager werden am häufigsten für die Verwaltung verschiedener Ressourcen wie Dateien, Sperren und Datenbankverbindungen verwendet. Kontextmanager werden verwendet, um Ressourcen nach ihrer Verwendung freizugeben und zu bereinigen. Das folgende Beispiel demonstriert die Grundstruktur von timer.py, indem nur die Zeilen gedruckt werden, die Doppelpunkte enthalten. Darüber hinaus wird die übliche Redewendung zum Öffnen von Dateien in Python angezeigt:

with open("timer.py") as fp:
print("".join(ln for ln in fp if ":" in ln))

class TimerError(Exception):
class Timer:
timers: ClassVar[Dict[str, float]] = {}
name: Optional[str] = None
text: str = "Elapsed time: {:0.4f} seconds"
logger: Optional[Callable[[str], None]] = print
_start_time: Optional[float] = field(default=None, init=False, repr=False)
def __post_init__(self) -> None:
if self.name is not None:
def start(self) -> None:
if self._start_time is not None:
def stop(self) -> float:
if self._start_time is None:
if self.logger:
if self.name:

Beachten Sie, dass bei Verwendung von open() als Kontextmanager der Dateizeiger fp nicht explizit geschlossen wird. Sie können bestätigen, dass fp automatisch geschlossen wird:

fp.closed

True

Here In Im Beispiel ist open("timer.py") ein Ausdruck, der den Kontextmanager zurückgibt. Dieser Kontextmanager ist an den Namen fp gebunden. Der Kontextmanager ist während der Ausführung von print() gültig. Dieser einzeilige Codeblock wird im Kontext von fp ausgeführt.

fp ist ein Kontextmanager. Was bedeutet das? Technisch gesehen implementiert fp das Kontextmanagerprotokoll. Der Python-Sprache liegen viele verschiedene Protokolle zugrunde. Stellen Sie sich ein Protokoll als einen Vertrag vor, der festlegt, welche spezifischen Methoden unser Code implementieren muss.

Das Kontextmanagerprotokoll besteht aus zwei Methoden:

1. .__enter__() wird aufgerufen, wenn der mit dem Kontextmanager verknüpfte Kontext eingegeben wird.
2. Wird .__exit__() aufgerufen, wenn der mit dem Kontextmanager verknüpfte Kontext verlassen wird.

Mit anderen Worten: Um Ihren eigenen Kontextmanager zu erstellen, müssen Sie eine Klasse schreiben, die .__enter__() und .__exit__() implementiert. Probieren Sie das Kontextmanager-Beispiel „Hello, World!“ aus:

# studio.py
class Studio:
def __init__(self, name):
self.name = name

def __enter__(self):
print(f"你好 {self.name}")
return self

def __exit__(self, exc_type, exc_value, exc_tb):
print(f"一会儿见, {self.name}")

Studio ist ein Kontextmanager, der das Kontextmanagerprotokoll implementiert und wie folgt verwendet wird:

from studio import Studio
with Studio("云朵君"):
print("正在忙 ...")

你好 云朵君
正在忙 ...
一会儿见, 云朵君

Beachten Sie zunächst, wie .__enter__() aufgerufen wird, bevor Sie etwas tun, und .__exit__ () wird aufgerufen, nachdem etwas getan wurde. In diesem Beispiel wird nicht auf den Kontextmanager verwiesen, sodass es nicht erforderlich ist, as zur Benennung des Kontextmanagers zu verwenden.

Beachten Sie als Nächstes, dass der Rückgabewert von self.__enter__() bestimmten Einschränkungen unterliegt. Wenn Sie einen Kontextmanager erstellen, möchten Sie normalerweise self von .__enter__() zurückgeben. Der Rückgabewert kann wie folgt verwendet werden:

from greeter import Greeter
with Greeter("云朵君") as grt:
print(f"{grt.name} 正在忙 ...")

你好 云朵君
云朵君 正在忙 ...
一会儿见, 云朵君

Beim Schreiben der Funktion __exit__ müssen Sie darauf achten. Sie muss diese drei Parameter haben:

• exc_type: Ausnahmetyp
• exc_val: Ausnahmewert
• exc_tb: Ausnahme Die Fehlerstapelinformationen

Diese drei Parameter werden für die Fehlerbehandlung im Kontextmanager verwendet und mit dem Rückgabewert von sys.exc_info() zurückgegeben. Wenn der Hauptlogikcode keine Ausnahme meldet, sind diese drei Parameter alle None.

Wenn beim Ausführen des Blocks eine Ausnahme auftritt, ruft der Code .__exit__() mit dem Ausnahmetyp, der Ausnahmeinstanz und dem Traceback-Objekt (d. h. exc_type, exc_value und exc_tb) auf. Normalerweise werden diese im Kontextmanager ignoriert und .__exit__() wird aufgerufen, bevor die Ausnahme ausgelöst wird:

from greeter import Greeter
with Greeter("云朵君") as grt:
print(f"{grt.age} does not exist")

你好 云朵君
一会儿见, 云朵君
Traceback (most recent call last):
File "<stdin>", line 2, in <module>
AttributeError: 'Greeter' object has no attribute 'age'

Wie Sie sehen können, gilt auch bei Fehlern im Code: „Bis später, Herr Yun Duo“ wird noch gedruckt.

Contextlib verstehen und verwenden

Jetzt haben wir ein vorläufiges Verständnis davon, was ein Kontextmanager ist und wie man einen eigenen erstellt. Im obigen Beispiel haben wir eine Klasse geschrieben, nur um einen Kontextmanager zu erstellen. Wenn Sie nur eine einfache Funktion implementieren möchten, ist das Schreiben einer Klasse etwas zu kompliziert. Zu diesem Zeitpunkt dachten wir, es wäre großartig, wenn wir den Kontextmanager implementieren könnten, indem wir nur eine Funktion schreiben.

Python hat daran bereits gedacht. Es stellt uns einen Dekorator zur Verfügung. Sie können dieses Funktionsobjekt in einen Kontextmanager umwandeln, solange Sie den Funktionsinhalt gemäß seinem Codeprotokoll implementieren.

我们按照 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('test.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('test.txt') as file_in:
for line in file_in:
1/0
print(line)

Python 标准库中的 contextlib包括定义新上下文管理器的便捷方法，以及可用于关闭对象、抑制错误甚至什么都不做的现成上下文管理器！

创建 Python 计时器上下文管理器

了解了上下文管理器的一般工作方式后，要想知道它们是如何帮助处理时序代码呢？假设如果可以在代码块之前和之后运行某些函数，那么就可以简化 Python 计时器的工作方式。其实，上下文管理器可以自动为计时时显式调用 .start() 和.stop()。

同样，要让 Timer 作为上下文管理器工作，它需要遵守上下文管理器协议，换句话说，它必须实现 .__enter__() 和 .__exit__() 方法来启动和停止 Python 计时器。从目前的代码中可以看出，所有必要的功能其实都已经可用，因此只需将以下方法添加到之前编写的的 Timer 类中即可：

# timer.py
@dataclass
class Timer:
# 其他代码保持不变

def __enter__(self):
"""Start a new timer as a context manager"""
self.start()
return self

def __exit__(self, *exc_info):
"""Stop the context manager timer"""
self.stop()

Timer 现在就是一个上下文管理器。实现的重要部分是在进入上下文时， .__enter__() 调用 .start() 启动 Python 计时器，而在代码离开上下文时， .__exit__() 使用 .stop() 停止 Python 计时器。

from timer import Timer
import time
with Timer():
time.sleep(0.7)

Elapsed time: 0.7012 seconds

此处注意两个更微妙的细节：

• .__enter__()​ 返回self​，Timer 实例，它允许用户使用as​ 将Timer ​实例绑定到变量。例如，使用with Timer() as t:​ 将创建指向Timer ​对象的变量t。
• .__exit__()​ 需要三个参数，其中包含有关上下文执行期间发生的任何异常的信息。代码中，这些参数被打包到一个名为exc_info 的元组中，然后被忽略，此时 Timer 不会尝试任何异常处理。

在这种情况下不会处理任何异常。上下文管理器的一大特点是，无论上下文如何退出，都会确保调用.__exit__()。在以下示例中，创建除零公式模拟异常查看代码功能：

from timer import Timer
with Timer():
for num in range(-3, 3):
print(f"1 / {num} = {1 / num:.3f}")

1 / -3 = -0.333
1 / -2 = -0.500
1 / -1 = -1.000
Elapsed time: 0.0001 seconds
Traceback (most recent call last):
File "<stdin>", line 3, in <module>
ZeroDivisionError: division by zero

注意 ，即使代码抛出异常，Timer 也会打印出经过的时间。

使用 Python 定时器上下文管理器

现在我们将一起学习如何使用 Timer 上下文管理器来计时 "下载数据" 程序。回想一下之前是如何使用 Timer 的：

# download_data.py
import requests
from timer import Timer
def main():
t = Timer()
t.start()
source_url = 'https://cloud.tsinghua.edu.cn/d/e1ccfff39ad541908bae/files/?p=%2Fall_six_datasets.zip&dl=1'
headers = {'User-Agent': 'Mozilla/5.0'}
res = requests.get(source_url, headers=headers) 
t.stop()
with open('dataset/datasets.zip', 'wb') as f:
f.write(res.content)

if __name__ == "__main__":
main()

我们正在对 requests.get() 的调用进行记时监控。使用上下文管理器可以使代码更短、更简单、更易读：

# download_data.py
import requests
from timer import Timer
def main():
source_url = 'https://cloud.tsinghua.edu.cn/d/e1ccfff39ad541908bae/files/?p=%2Fall_six_datasets.zip&dl=1'
headers = {'User-Agent': 'Mozilla/5.0'}
with Timer():
res = requests.get(source_url, headers=headers)

with open('dataset/datasets.zip', 'wb') as f:
f.write(res.content)

if __name__ == "__main__":
main()

此代码实际上与上面的代码相同。主要区别在于没有定义无关变量t，在命名空间上无多余的东西。

写在最后

将上下文管理器功能添加到 Python 计时器类有几个优点：

• 省时省力：只需要一行额外的代码即可为代码块的执行计时。
• 可读性高：调用上下文管理器是可读的，你可以更清楚地可视化你正在计时的代码块。

使用 Timer 作为上下文管理器几乎与直接使用 .start() 和 .stop() 一样灵活，同时它的样板代码更少。在该系列下一篇文章中，云朵君将和大家一起学习如何将 Timer 也用作装饰器，并用于代码中，从而更加容易地监控代码完整运行过程，我们一起期待吧！

Das obige ist der detaillierte Inhalt vonSo erweitern Sie Python-Timer mit Kontextmanagern. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!