So verwenden Sie das Python-Async-Modul

Coroutinen, auch Micro-Threads genannt, sind eine Technologie zur Kontextumschaltung im Benutzermodus. Kurz gesagt, es handelt sich tatsächlich um einen Thread zum Umschalten von Codeblöcken zur Ausführung. Die Unterstützung von Python für Coroutinen wird durch Generatoren implementiert.

Im Generator können wir nicht nur die for-Schleife durchlaufen, sondern auch kontinuierlich die Funktion next() aufrufen, um den nächsten von der yield-Anweisung zurückgegebenen Wert zu erhalten. Pythons yield kann nicht nur zur Rückgabe von Werten verwendet werden, sondern kann auch vom Aufrufer übergebene Parameter empfangen.

1. Was ist ein Generator?

Der Mechanismus namens Generator in Python wird während der Schleife berechnet. Indem Sie einen Algorithmus angeben und dann während des Anrufs den wahren Wert berechnen.

Sie können next() verwenden, wenn Sie den Wert vom Generator abrufen müssen, aber im Allgemeinen verwenden Sie eine for-Schleife, um ihn abzurufen.

Generator-Implementierungsmethodengenerator, verwenden Sie () zur Darstellung von

wie: [1, 2, 3, 4, 5], Generatormethode:

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

Funktionsdefinition Verwenden Sie in einigen logisch komplexen Szenarien die erste Methode. Die Methode ist nicht geeignet, daher gibt es Möglichkeiten, Typfunktionen zu definieren, wie zum Beispiel:

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

Wenn yield in der Funktion erscheint, wird sie zu diesem Zeitpunkt zu einem Generator.

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

Wird eine Generatorfunktion, die jedes Mal ausgeführt wird, wenn next() aufgerufen wird , kehrt zurück, wenn eine Yield-Anweisung auftritt, und setzt die Ausführung bei der letzten zurückgegebenen Yield-Anweisung fort, wenn sie erneut ausgeführt wird.

2. Verwenden Sie Asyncio, um asynchrones IO zu implementieren.

Asynchrones IO wird über eine Ereignisschleife und eine Coroutine-Funktion implementiert. Die Ereignisschleife überwacht kontinuierlich interne Aufgaben und führt sie aus, wenn sie vorhanden sind. Aufgaben werden durch das Ereignis bestimmt Schleife Aufgaben verarbeiten. Wenn die Aufgabenliste leer ist, wird das Ereignis beendet.

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

Testdemo

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()

Coroutine-Funktion: Im Vergleich zu gewöhnlichem Def, wie z. B. def func(), können Sie den von der Funktion zurückgegebenen Wert direkt empfangen ein Coroutine-Objekt.

Wenn Sie die Coroutine-Funktion ausführen möchten, müssen Sie dieses Objekt zur Verarbeitung an die Ereignisschleife übergeben.

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

Warten:

Verwendung: Antwort = Warten + Erwartbares Objekt

Erwartete Objekte: Coroutine-Objekte, Zukunft, Aufgabenobjekte können als IO-Warten verstanden werden

Antwort: Das Ergebnis des Wartens wird auf IO-Operationen stoßen Wenn die aktuelle Coroutine (Aufgabe) angehalten wird, kann die Ereignisschleife andere Coroutinen (Aufgaben) ausführen. Hinweis: Wenn es sich bei dem wartebaren Objekt um ein Task-Objekt handelt, wird es zum Task-Objekt gleichzeitig ausgeführt werden, können mehrere Aufgaben zur Ereignisschleifenliste hinzugefügt werden. Sie können „asyncio.create_task()“ verwenden, um ein „Task“-Objekt zu erstellen, und der übergebene Parameter ist das Coroutine-Objekt 3. aiohttp

asyncio kann gleichzeitige E/A-Vorgänge mit einem Thread implementieren. Wenn es nur auf der Clientseite verwendet wird, ist es nicht sehr leistungsfähig. Wenn Asyncio auf der Serverseite verwendet wird, z. B. auf einem Webserver, kann ein einzelner Thread + Coroutine verwendet werden, um eine hohe Parallelitätsunterstützung für mehrere Benutzer zu erreichen, da es sich bei HTTP-Verbindungen um E / A-Vorgänge handelt.

aiohttp ist ein HTTP-Framework, das auf Asyncio basiert.

Sie können eine Anfrage wie eine Get-Anfrage wie Anfragen senden.

Sie können die Parameter angeben, die über den Parameter params übergeben werden sollen.

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))

.

Anfrage posten Eine Sitzung, und dann verwendet aiohttp ClientSession, um die Sitzung zu verwalten.

Verwenden Sie session.method, um Anfragen zu senden ; Sie können text( ) verwenden, um das Kodierungsformat anzugeben. Bevor Sie auf das Antwortergebnis warten, müssen Sie vor „response.text()“ das Schlüsselwort „await“

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

hinzufügen.

Das obige ist der detaillierte Inhalt vonSo verwenden Sie das Python-Async-Modul. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!