Comment utiliser le module asynchrone Python

Les coroutines, également connues sous le nom de micro-threads, sont une technologie de changement de contexte en mode utilisateur. En bref, il s'agit en fait de changer de bloc de code à exécuter via un thread. La prise en charge des coroutines par Python est implémentée via des générateurs.

Dans le générateur, nous pouvons non seulement parcourir la boucle for, mais aussi appeler en continu la fonction next() pour obtenir la valeur suivante renvoyée par l'instruction rendement. Le rendement de Python peut non seulement être utilisé pour renvoyer des valeurs, mais peut également recevoir des paramètres transmis par l'appelant.

1. Qu'est-ce qu'un générateur ?

Le mécanisme appelé générateur en Python est calculé en boucle. En donnant un algorithme puis en calculant la vraie valeur lors de l'appel.

Vous pouvez utiliser next() lorsque vous avez besoin d'obtenir la valeur du générateur, mais utilisez généralement une boucle for pour l'obtenir.

générateur de méthode d'implémentation du générateur, utilisez () pour représenter

tels que : [1, 2, 3, 4, 5], méthode du générateur :

data = [1, 2, 3, 4, 5]
(x * x for x in len(data))

définition de la fonction Dans certains scénarios logiquement complexes, utilisez la première méthode La méthode est ne convient pas, il existe donc des moyens de définir des fonctions de type, telles que :

def num(x):
    while (x < 10):
        print(x * x)
        x += 1
g = num(1)
for item in g:
    print(item)

Lorsque le rendement apparaît dans la fonction, il devient un générateur à ce moment-là

def num(x):
    while (x < 10):
        yield x * x  # 返回结果，下次从这个地方继续？
        x += 1
g = num(1)  # 返回的是generator对象
for item in g:
    print(item)

Devient une fonction génératrice, qui est exécutée à chaque fois que next() est appelé , revient lorsqu'il rencontre une instruction rendement et continue l'exécution à partir de la dernière instruction rendement renvoyée lors de sa nouvelle exécution.

2. Utilisez asyncio pour implémenter l'io asynchrone

L'io asynchrone est implémenté via une boucle d'événement et une fonction coroutine

La boucle d'événement surveille en permanence les tâches internes et les exécute si elles existent. Les tâches sont divisées en exécutables et en exécution déterminées par l'événement ; boucle Tâches de traitement, si la liste des tâches est vide, l'événement se termine.

import asyncio
# 生成或获取事件循环对象loop;类比Java的Netty，我理解为开启一个selector
loop = asyncio.get_event_loop()  
# 将协程函数（任务）提交到事件循环的任务列表中，协程函数执行完成之后终止。
# run_until_complete 会检查协程函数的运行状态,并执行协程函数
loop.run_until_complete( func() )

test demo

import asyncio
import time
async def test():
    print("io等待")
    await asyncio.sleep(1)
    return 'hello'
async def hello():
    print("Hello world")
    r = await test()
    print("hello again")
loop = asyncio.get_event_loop()
tasks = [hello(), hello()]
loop.run_until_complete(asyncio.wait(tasks))
loop.close()

Fonction coroutine : une fonction modifiée par async def ; par rapport à def ordinaire, comme def func(), vous pouvez recevoir directement la valeur renvoyée par la fonction mais pour les retours de fonction coroutine ; un objet coroutine.

Si vous souhaitez exécuter la fonction coroutine, vous devez transmettre cet objet à la boucle d'événements pour traitement.

# 测试协程
import asyncio
import time, datetime
# 异步函数不同于普通函数，调用普通函数会得到返回值
# 而调用异步函数会得到一个协程对象。我们需要将协程对象放到一个事件循环中才能达到与其他协程对象协作的效果
# 因为事件循环会负责处理子程 序切换的操作。
async def Print():
    return "hello"
loop = asyncio.get_event_loop()
loop.run_until_complete(Print)

await:

Awaitableobjects : objets coroutine, Future, Task les objets peuvent être compris comme IO wait

response : le résultat de l'attente wait rencontrera des opérations IO Suspendre le coroutine actuelle (tâche). Lorsque la coroutine actuelle est suspendue, la boucle d'événements peut exécuter d'autres coroutines (tâches). Remarque : si l'objet attendu est un objet coroutine, il deviendra série. S'il s'agit d'un objet Task, l'objet Task. s'exécutera simultanément, plusieurs tâches peuvent être ajoutées à la liste des boucles d'événements. Vous pouvez utiliser `asyncio.create_task()` pour créer un objet `Task`, et le paramètre passé est l'objet coroutine

import asyncio
import time, datetime
async def display(num):
    pass
tasks = []
for num in range(10):
    tasks.append(display(num))  # 生成任务列表
loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(tasks))

asnyc et wait sont une nouvelle syntaxe, l'ancienne version est : @asyncio.coroutine et rendement from

3. aiohttp

asyncio peut implémenter des opérations d'E/S simultanées monothread. S’il n’est utilisé que côté client, il ne sera pas très puissant. Si asyncio est utilisé côté serveur, comme un serveur Web, puisque les connexions HTTP sont des opérations d'E/S, un seul thread + coroutine peut être utilisé pour obtenir une prise en charge simultanée élevée pour plusieurs utilisateurs.

aiohttp est un framework HTTP basé sur asyncio.

Vous pouvez envoyer une requête comme get request like requêtes

Vous pouvez spécifier les paramètres à transmettre via le paramètre params

async def fetch(session):
    async with session.get("http://localhost:10056/test/") as response:
        data = json.loads(await response.text())
        print(data["data"])

Post request

Exécuter deux tâches de manière asynchrone
Dans les requêtes réseau, une requête est une session, puis aiohttp utilise ClientSession pour gérer la session
Utilisez session.method pour envoyer des requêtes
Pour la réponse aux informations de réponse, utilisez status pour obtenir le code d'état de la réponse, text() pour obtenir le contenu de la réponse ; vous pouvez utiliser text( ) pour spécifier le format d'encodage. Avant d'attendre le résultat de la réponse, vous devez ajouter le mot-clé wait

• async def init(num):
      async with aiohttp.ClientSession() as session:
          if num == 1:
              time.sleep(5)
          print("session begin", num)
          async with session.post("http://localhost:10056/hello/", data=json.dumps({"data": "hello"})) as response:
              print("client begin", num)
              data = json.loads(await response.text())
  
              print(data["data"])
          print("session end", num)
      print("other")
  if __name__ == '__main__':
      loop = asyncio.get_event_loop()
      tasks = [init(1), init(2)]
      loop.run_until_complete(asyncio.wait(tasks))

  Copier après la connexion

  avant réponse.text()

  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!