Que sont les coroutines en Python et comment implémenter la programmation asynchrone en Python

2024-07-12

Coroutine

Une coroutine est un composant de programme qui permet à plusieurs points d'entrée d'un programme de suspendre et de reprendre l'exécution à des emplacements spécifiques. Contrairement aux threads et aux processus, la commutation de coroutines est explicitement contrôlée par le programmeur plutôt que planifiée par le système d'exploitation. Cela rend la coroutine plus légère lors des changements de contexte, car il n'est pas nécessaire de sauvegarder et de restaurer l'intégralité de l'environnement d'exécution (comme la pile de threads).

En Python, les coroutines passent principalementasyncetawait Mots-clés à réaliser. Les fonctions définies à l'aide de ces mots-clés sont appelées « fonctions coroutine » et elles ne s'exécutent pas immédiatement lorsqu'elles sont appelées, mais renvoient à la place un objet coroutine. Cet objet coroutine doit être planifié pour être exécuté dans la boucle d'événements.

Programmation asynchrone

La programmation asynchrone est un modèle de concurrence qui permet à un programme de continuer à effectuer d'autres tâches en attendant la fin de certaines opérations de longue durée (telles que les opérations d'E/S). En Python, la programmation asynchrone est souvent utilisée avec des coroutines, dont l'exécution est planifiée via une boucle d'événements.

Comment implémenter la programmation asynchrone en Python

1. Utiliser`async`et`await`

Définir la fonction coroutine:utiliserasync defpour définir la fonction coroutine.
Attendez la coroutine : Dans la fonction coroutine, vous pouvez utiliserawaitpour attendre la fin d'une autre coroutine ou d'une opération asynchrone.

2. Utiliser la boucle d'événements

Pythonasyncio La bibliothèque fournit une implémentation de la boucle d'événements. Vous devez vous assurer que votre code asynchrone s'exécute dans une boucle d'événements.
utiliserasyncio.run(main())pour exécuter votre fonction coroutine principale, qui crée et gère automatiquement la boucle d'événements.

3. Exemple de code

python复制代码

	`import asyncio`

	`# 定义一个异步函数，模拟一个耗时的I/O操作`
	`async def fetch_data(url):`
	`print(f"Fetching {url}...")`
	`# 模拟耗时操作`
	`await asyncio.sleep(1)`
	`return f"Data from {url}"`

	`async def main():`
	`# 同时启动多个异步任务`
	`task1 = asyncio.create_task(fetch_data('http://example.com/data1'))`
	`task2 = asyncio.create_task(fetch_data('http://example.com/data2'))`

	`# 等待所有任务完成`
	`result1, result2 = await asyncio.gather(task1, task2)`
	`print(result1)`
	`print(result2)`

	`# 运行主协程`
	`asyncio.run(main())`

Dans cet exemple,fetch_dataEst une fonction asynchrone qui simule les requêtes réseau.mainDans la fonction, on en a démarré deux en même tempsfetch_dataune tâche asynchrone et une utilisationawait asyncio.gather()Attendez qu'ils terminent en même temps.

4. Précautions

La programmation asynchrone et les coroutines facilitent la gestion de la concurrence, mais introduisent également de nouvelles complexités telles que la gestion du contexte asynchrone, la gestion des erreurs, etc.
Lors de la conception de code asynchrone, portez une attention particulière aux opérations bloquantes (par exemple, les opérations d'E/S synchrones) et utilisez des versions asynchrones des bibliothèques et des API autant que possible.
asyncio Il fait partie de la bibliothèque standard Python et est utilisé pour prendre en charge les coroutines et la programmation asynchrone.Il fournit également des API riches telles queasyncio.Queue、asyncio.Locketc., pour gérer les problèmes de concurrence et de synchronisation dans le code asynchrone.

Partage de technologie