Python – Warten Sie, bis die Async-Funktion abgeschlossen ist

1. Verwenden Sie das Schlüsselwort await und erstellen Sie eine asynchrone Funktion
2. Verwenden Sie create_task(), um eine Aufgabe zur Behebung eines Problems zu erstellen

Dieser Artikel zeigt, wie Sie eine asynchrone Funktion erstellen und das Schlüsselwort await verwenden, um einen Prozess zu unterbrechen. Wir werden auch lernen, wie man Aufgaben anstelle von Threads in Python verwendet.

Verwenden Sie das Schlüsselwort await und erstellen Sie eine asynchrone Funktion

Asynchrone Programmierung ist kein Multithreading; es handelt sich nicht um eine Mehrfachverarbeitung, sondern um eine gleichzeitige Programmierung.

Wir werden nicht über die ganze Idee der gleichzeitigen Programmierung und das gesamte Codierungsmuster sprechen, aber wir werden über die Grundprinzipien sprechen und wie wir diese in Python implementieren können.

Schauen wir uns nun ein kurzes Beispiel an; wir haben eine Func_1, Func_2 und Func_3, die aufgerufen werden.

Func_1()
Func_2()
Func_3()

Wenn diese Funktionen asynchron aufgerufen werden, bedeutet dies, dass wir Func_1() aufrufen und dann Func_2() aufrufen werden.

Wenn Func_1() so zurückkehrt, rufen wir nur Func_2() auf, und wenn Func_2() zurückkehrt, rufen wir Func_3() auf.

Wenn wir Multi-Threading oder Multi-Processing verwenden, wäre das nicht dasselbe wie asynchrone Programmierung. Denn beim Multithreading würden wir in diesem Fall drei Threads definieren und all diese Funktionen gleichzeitig ausführen.

Oder wir werden ungefähr gleichzeitig versuchen, sie gleichzeitig auszuführen oder zumindest die Illusion einer gleichzeitigen Ausführung zu erzeugen.

Aber wir wollen, sagen wir, Func_1() macht etwas Produktives, und dann fordert es einige Daten von einer Datenbank, von einer API an, oder es schläft im Allgemeinen nur um des Wartens willen.

Wenn das passiert, wollen wir keine CPU-Zeit verschwenden und mit der Ausführung von Func_2() beginnen, obwohl diese Funktion noch nicht zurückgekehrt ist. Wir können also nur eine Aufgabe gleichzeitig ausführen; Wir führen kein Multi-Processing oder Multi-Threading durch.

Aber wenn Func_1() schläft oder wartet oder unproduktiv ist, können wir diese Zeit nutzen, um mit der Ausführung von Func_2() und vielleicht Func_3() zu beginnen. Um in Python asynchron zu programmieren, müssen wir eine Bibliothek namens asyncio importieren.

Da wir nicht das gesamte Programm als asynchron definieren werden, sind bestimmte Funktionen asynchron; Wir müssen das Schlüsselwort async verwenden, um eine asynchrone Funktion anzugeben.

Wenn wir nur diese Main_Func() haben, wird das ganze Programm asynchron sein, aber wir werden im nächsten Beispiel andere Funktionen hinzufügen. Innerhalb dieser Funktion verwenden wir zwei print()-Funktionen.

Und dazwischen gehen wir schlafen, aber wir schlafen nicht mit time.sleep(); Wir werden asyncio.sleep() verwenden.

Wir müssen das Schlüsselwort await verwenden, bevor wir asyncio.sleep() aufrufen, was bedeutet, dass wir warten, bis die zweite print-Anweisung beendet ist. Bevor wir fertig sind, werden wir nichts weiter tun.

Um die Funktion Main_Func() auszuführen, müssen wir asyncio.run() verwenden und innerhalb der Funktion run() übergeben wir die Funktion Main_Func(). Wir müssen die Funktion Main_Func() aufrufen; wir bezeichnen es nicht nur als Multi-Threading.

import asyncio


async def Main_Func():
    print("Before waiting")
    await asyncio.sleep(1)
    print("After waiting")


asyncio.run(Main_Func())

Ausgang:

Lassen Sie uns eine weitere asynchrone Funktion namens Func_2() einführen; Wir drucken zwei Anweisungen und schlafen zwei Sekunden lang.

Innerhalb der Funktion Main_Func() rufen wir, anstatt zu schlafen, die Funktion Func_2() mit dem Schlüsselwort await auf, aber das wird nicht asynchron sein.

import asyncio


async def Main_Func():
    print("Before waiting")
    await Func_2()
    print("After waiting")


async def Func_2():
    print("Func_2: Before waiting")
    await asyncio.sleep(2)
    print("Func_2: After waiting")


asyncio.run(Main_Func())

Da wir auf die Funktion warten, was dasselbe ist wie ein asynchroner Aufruf, wird sie nicht ausgeführt, bis alle Anweisungen wie von uns definiert ausgeführt wurden.

Before waiting
Func_2: Before waiting
Func_2: After waiting
After waiting

Es ist nicht asynchron; Wenn wir jedoch so etwas tun möchten, wenn die Funktion Main_Func() aufruft, dann sollte die Steuerung die erste print-Anweisung der Funktion Main_Func() ausgeben.

Rufen Sie dann die Funktion Func_2() auf und drucken Sie so die erste print-Anweisung dieser Funktion.

Während diese Funktion schläft, sollte sie die zweite print-Anweisung der Main_Func()-Funktion drucken, und sobald dies erledigt ist, sollte sie die zweite print-Anweisung der Func_2()-Funktion drucken.

Verwenden Sie create_task(), um eine Aufgabe zur Behebung eines Problems zu erstellen

Dazu müssen wir mit tasks arbeiten, also erstellen wir zu Beginn der Funktion Main_Func() eine Aufgabe, während wir asyncio.create_task() aufrufen, und innerhalb der Aufgabe werden wir das tun Übergeben Sie Func_2().

Das bedeutet, dass wir diese Aufgabe nennen, sobald wir etwas Leerlaufzeit haben.

import asyncio


async def Main_Func():
    Task = asyncio.create_task(Func_2())
    print("Before waiting")
    print("After waiting")


async def Func_2():
    print("Func_2: Before waiting")
    await asyncio.sleep(2)
    print("Func_2: After waiting")


asyncio.run(Main_Func())

Nachdem wir den Code ausgeführt haben, können wir sehen, dass die beiden Druckanweisungen von der Funktion Main_Func() gedruckt werden, dann ist es fertig. Und die erste print-Anweisung wird ausgeführt, aber die Ausführung wird vor dem Drucken der zweiten print-Anweisung beendet.

Before waiting
After waiting
Func_2: Before waiting

Da Main_Func() die Hauptfunktion ist, wartet die Steuerung nicht auf die Funktion Func_2(), was bedeutet, dass die Steuerung die Ausführung beendet, sobald die Steuerung das Ende der Funktion Main_Func() erreicht .

Die Steuerung muss nicht warten, bis die zweite print-Anweisung der Funktion Func_2() beendet ist, damit die Steuerung sie überspringt. Um dies zu beheben, verwenden wir await Task am Ende der Funktion Main_Func().

import asyncio


async def Main_Func():
    Task = asyncio.create_task(Func_2())
    print("Before waiting")
    print("After waiting")
    await Task


async def Func_2():
    print("Func_2: Before waiting")
    await asyncio.sleep(2)
    print("Func_2: After waiting")


asyncio.run(Main_Func())

Jetzt können wir sehen, dass es so gedruckt wird, wie es definiert wurde.

Before waiting
After waiting
Func_2: Before waiting
Func_2: After waiting

Wenn wir sehen wollen, wie dies asynchron funktioniert, können wir dies mit der Funktion sleep() zwischen den print-Anweisungen tun.

Das bedeutet, dass wir eine erste print-Anweisung von Main_Func() ausführen, und dann wird die Steuerung für eine Sekunde schlafen, was bedeutet, dass die Hauptfunktion jetzt Leerlaufzeit hat.

Und jetzt hat die Aufgabe Zeit, ausgeführt zu werden, bis die Main_Func() vollständig ausgeführt ist. Da die Funktion Main_Func() schläft, haben wir jetzt CPU-Zeit zur Verfügung, um die Ausführung der Funktion Func_2() zu starten, indem wir sie mit der Aufgabe aufrufen.

Aber die Funktion Func_2() geht auch schlafen, was bedeutet, dass die Steuerung innerhalb dieser Funktion zwei Sekunden wartet und die Steuerung zur Funktion Main_Func() geht, um eine zweite print-Anweisung auszugeben.

Dann bricht sie ab, dh die Steuerung interessiert sich nicht mehr für den Rest der Funktion Func_2().

async def Main_Func():
    Task = asyncio.create_task(Func_2())
    print("Before waiting")
    await asyncio.sleep(1)
    print("After waiting")

Ausgang:

Before waiting
Func_2: Before waiting
After waiting

Wenn wir daran interessiert sein wollen, müssen wir await Task am Ende der Main_Func()-Funktion verwenden.

Es ist asynchron; Wie Sie sehen können, ist die Reihenfolge so, dass die Funktion Main_Func() die erste print-Anweisung druckt, dann druckt Func_2() zuerst, dann druckt Main_Func() die zweite sowie Func_2() druckt die zweite.

Denn wenn die Funktion schlafen geht, wird Leerlaufzeit verwendet, damit keine CPU-Zeit verschwendet wird.