Nous avons créé la première classe timer Python ci-dessus, puis avons progressivement étendu notre classe Timer, et son code est également relativement riche et puissant. Nous ne pouvons pas nous contenter de cela et devons encore modéliser du code pour utiliser le Timer :
Python a une construction unique pour appeler des fonctions avant et après un bloc de code : un gestionnaire de contexte.
Les gestionnaires de contexte sont une partie importante de Python depuis longtemps. Introduit en 2005 par PEP 343 et implémenté pour la première fois dans Python 2.5. Les gestionnaires de contexte dans votre code peuvent être identifiés à l'aide du mot-clé with :
with EXPRESSION as VARIABLE: BLOCK
EXPRESSION sont des expressions Python qui renvoient des gestionnaires de contexte. Tout d'abord, le gestionnaire de contexte est lié au nom de variable VARIABLE, BLOCK peut être n'importe quel bloc de code Python standard. Le gestionnaire de contexte garantit que le programme appelle du code avant l'exécution de BLOCK et un autre code après l'exécution de BLOCK. De cette façon, même si BLOCK lève une exception, cette dernière sera quand même exécutée.
L'utilisation la plus courante des gestionnaires de contexte consiste à gérer différentes ressources telles que les fichiers, les verrous et les connexions à la base de données. Les gestionnaires de contexte sont utilisés pour libérer et nettoyer les ressources après leur utilisation. L'exemple suivant montre la structure de base de timer.py en imprimant uniquement les lignes contenant des deux-points. De plus, il montre l'expression courante pour ouvrir des fichiers en Python :
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:Notez qu'en utilisant open() comme gestionnaire de contexte, le pointeur de fichier fp n'est pas fermé explicitement, vous pouvez confirmer que fp est fermé automatiquement :
fp.closed
True
Ici dans l'exemple, open("timer.py") est une expression qui renvoie le gestionnaire de contexte. Ce gestionnaire de contexte est lié au nom fp. Le gestionnaire de contexte est valide lors de l'exécution de print(). Ce bloc de code d'une seule ligne est exécuté dans le contexte de fp .
fp est un gestionnaire de contexte. Qu'est-ce que cela signifie ? Techniquement parlant, fp implémente le protocole de gestion de contexte. Il existe de nombreux protocoles différents sous-jacents au langage Python. Considérez un protocole comme un contrat qui indique les méthodes spécifiques que notre code doit implémenter.
Le protocole du gestionnaire de contexte se compose de deux méthodes :
En d'autres termes, pour créer vous-même un gestionnaire de contexte, vous devez écrire une classe qui implémente .__enter__() et .__exit__() . Essayez l'exemple de gestionnaire de contexte Hello, World :
# 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 est un gestionnaire de contexte qui implémente le protocole de gestion de contexte et est utilisé comme ceci :
from studio import Studio
with Studio("云朵君"):
print("正在忙 ...")你好 云朵君 正在忙 ... 一会儿见, 云朵君
Tout d'abord, remarquez comment .__enter__() est appelé avant de faire quoi que ce soit, et .__exit__. () est appelé après avoir fait quelque chose. Dans cet exemple, le gestionnaire de contexte n'est pas référencé, il n'est donc pas nécessaire d'utiliser as pour nommer le gestionnaire de contexte.
Ensuite, notez que la valeur de retour de self.__enter__() est soumise à des contraintes. Lors de la création d'un gestionnaire de contexte, vous souhaitez généralement revenir self depuis .__enter__() . La valeur de retour peut être utilisée comme suit :
from greeter import Greeter
with Greeter("云朵君") as grt:
print(f"{grt.name} 正在忙 ...")你好 云朵君 云朵君 正在忙 ... 一会儿见, 云朵君
Lors de l'écriture de la fonction __exit__, vous devez y prêter attention. Elle doit avoir ces trois paramètres :
Ces trois paramètres sont utilisés pour la gestion des erreurs dans le gestionnaire de contexte, et ils sont renvoyés avec la valeur de retour de sys.exc_info(). Lorsque le code logique principal ne signale pas d'exception, ces trois paramètres seront tous Aucun.
Si une exception se produit lors de l'exécution du bloc, le code appellera .__exit__() avec le type d'exception, l'instance d'exception et l'objet de trace (c'est-à-dire exc_type, exc_value et exc_tb). Normalement, ceux-ci sont ignorés dans le gestionnaire de contexte, et .__exit__() est appelé avant que l'exception ne soit levée :
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'
Comme vous pouvez le voir, même s'il y a des erreurs dans le code, "A bientôt, M. Yun Duo" est toujours imprimé.
Nous avons maintenant une compréhension préliminaire de ce qu'est un gestionnaire de contexte et comment créer le vôtre. Dans l'exemple ci-dessus, nous avons écrit une classe uniquement pour créer un gestionnaire de contexte. Si vous souhaitez simplement implémenter une fonction simple, écrire une classe est un peu trop compliqué. À ce moment-là, nous avons pensé que ce serait formidable si nous pouvions implémenter le gestionnaire de contexte en écrivant une seule fonction.
Python y a déjà pensé. Il nous fournit un décorateur. Vous pouvez transformer cet objet fonction en gestionnaire de contexte tant que vous implémentez le contenu de la fonction selon son protocole de code.
我们按照 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 计时器的工作方式。其实，上下文管理器可以自动为计时时显式调用 .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
此处注意两个更微妙的细节：
在这种情况下不会处理任何异常。上下文管理器的一大特点是，无论上下文如何退出，都会确保调用.__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 也会打印出经过的时间。
现在我们将一起学习如何使用 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 也用作装饰器，并用于代码中，从而更加容易地监控代码完整运行过程，我们一起期待吧！
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
