Maison > développement back-end > Tutoriel Python > Quelles sont les méthodes d'implémentation des coroutines Python ?

Quelles sont les méthodes d'implémentation des coroutines Python ?

WBOY
Libérer: 2023-04-23 10:22:06
avant
1782 Les gens l'ont consulté

1. Coroutines

Les coroutines ne sont pas fournies par les ordinateurs. Les ordinateurs fournissent uniquement : des processus et des threads. Coroutine est un micro-processus créé artificiellement pour le changement de mode utilisateur, utilisant un seul thread pour basculer entre plusieurs processus

Plusieurs méthodes pour implémenter coroutine

  • greenlet : module précoce

  • mot-clé de rendement : oui Enregistrer le code, save state

  • asyncio decorator (3.4)

  • async, wait password (3.5) [Recommandé]

1.1greenlet implémente coroutine

pip install greenlet

from greenlet import greenlet
def fun1():
  gre2.switch()#切换到fun2
  pass
def fun2():
  gre1.switch()#切换到fun1
  pass
gre1 = greenlet(func1)
gre2 = greenlet(func2)
gre1.switch()#先去执行fun1
Copier après la connexion

1.2yield mot-clé implémente coroutine

def func1():
    yield 1
    yield from func2()
    yield 2
    
def func2():
    yield 3
    yield 4
f1 = func1()
for item in f1:
    print(item,end=" ")
    
#打印结果
1 3 4 2
Copier après la connexion

1.3 Utilisez le module asyncio pour implémenter des coroutines

Il ne peut être utilisé qu'après la version python3.4 (pas besoin d'installer, il est dans la bibliothèque standard)

import asyncio
#使用该装饰器装饰后,该函数就是一个协程函数
@asyncio.coroutine
def func1():
    print(1)
    #遇到IO操作时,会自动切换到taks中的其他任务函数
    yield from asyncio.sleep(2)
    print(2)

@asyncio.coroutine
def func2():
    print(3)
    yield from asyncio.sleep(2)
    print(4)
    
#将两个协程函数封装成一个tasks列表
tasks = [
    asyncio.ensure_future(func1()),
    asyncio.ensure_future(func2())
]
#
loop = asyncio.get_event_loop()
loop.run_until_complete(func1())
Copier après la connexion

1.4async & wait mots-clés pour implémenter les coroutines

import asyncio
#使用该装饰器装饰后,该函数就是一个协程函数

async def func1():
    print(1)
    #遇到IO操作时,会自动切换到tasks中的其他任务函数
    await asyncio.sleep(2)
    print(2)


async def func2():
    print(3)
    await asyncio.sleep(2)
    print(4)
    
#将两个协程函数封装成一个tasks列表
tasks = [
    asyncio.ensure_future(func1()),
    asyncio.ensure_future(func2())
]

loop = asyncio.get_event_loop()
loop.run_until_complete(tasks)
Copier après la connexion

2 La signification des coroutines

If. le thread rencontre un temps d'attente IO, le thread n'attendra pas bêtement, mais utilisera le temps d'inactivité pour faire autre chose, c'est-à-dire que le processus sera exécuté de manière asynchrone.

#协程请求资源使用第三方库aiohttp
import aiohttp
Copier après la connexion

3. Programmation asynchrone

3.1 Boucle temporelle

compris comme une boucle infinie pour détecter et exécuter certains codes

#伪代码
任务列表 = [task1,task2...]
while True:
  for 就绪任务 in 可执行任务列表:
    执行
  for 已完成任务 in 已完成任务列表:
    从任务列表中删除

import asyncio 

#生成一个书简循环
loop = asyncio.get_event_loop()
#将任务放到任务列表中
loop.run_until_complete(任务)
Copier après la connexion

3.2 Cas

fonction coroutine,

Lors de la définition d'une fonction, utilisez async def Nom de la fonction

Objet coroutine : lors de l'exécution de la fonction coroutine, un objet coroutine est obtenu

async def func():
  pass
result = func()
Copier après la connexion

Remarque : Pour l'objet coroutine obtenu lors de l'exécution de la fonction coroutine, le code à l'intérieur de la fonction ne sera pas exécuté

import asyncio
async def func():
  print("哈喽")

f = func()#协程对象

loop = asyncio.get_event_loop()#创建循环对象
loop.run_until_complete(f)#通过循环对象执行协程对象

#python3.7可以直接
asyncio.run(f)
Copier après la connexion

3.3await mot-clé

wait + objet waitable {Objet Coroutine, Objet Future, Objet Tâche} (similaire à I O wait)

import asyncio
async def func():
  print("哈喽")
  re = await asyncio.sleep(2)
	print(re)
asyncio.run(func())
Copier après la connexion

await consiste à attendre la valeur de l'objet pour obtenir le résultat avant de continuer à exécuter vers le bas

import asyncio
async def other():
  print("start")
  await asyncio.sleep(2)
  print("end")
  return 1

async def fun():
  print("执行协程函数内部代码")
  #遇到IO操作时会挂起当前协程任务,等IO操作完成后再继续往下执行,当前协程挂起时,时间循环对象可以执行其他协程任务
  re = await other()
  print("IO请求结束,结果为:",re)
  
asyncio.run(func())
Copier après la connexion

Résultat de l'exécution

Exécution coroutine Le code interne de la fonction processus
start
end
La requête IO se termine, et le résultat est : 1

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!

Étiquettes associées:
source:yisu.com
Déclaration de ce site Web
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn
Tutoriels populaires
Plus>
Derniers téléchargements
Plus>
effets Web
Code source du site Web
Matériel du site Web
Modèle frontal