Was sind die Implementierungsmethoden von Python-Coroutinen?

Was ist Coroutine? In Python ist Coroutine eine einfache Methode zur gleichzeitigen Programmierung, die durch kollaboratives Multitasking eine effiziente gleichzeitige Ausführung erreichen kann. Die Verwendung des Schlüsselworts yield, um die Ausführung einer Funktion anzuhalten und den aktuellen Ausführungsstatus zu speichern, ist eine Besonderheit von Coroutinen. Daher kann eine Coroutine als eine besondere Art von Generatorfunktion betrachtet werden. Wenn eine Coroutine angehalten wird, kann ihre Ausführung mit der send-Methode wieder aufgenommen werden, und bei der Wiederaufnahme wird ein Wert zurückgegeben.

Vor Python 3.4 wurde das Schlüsselwort yield häufig zur Implementierung von Coroutinen verwendet, was als „Generator-Coroutinen“ bezeichnet wurde. Nachdem das Asyncio-Modul in Python 3.4 eingeführt wurde, können Sie das Schlüsselwort async/await verwenden, um Coroutine-Funktionen, sogenannte „native Coroutinen“, zu definieren.

Im Vergleich zu Threads und Prozessen haben Coroutinen die folgenden Vorteile:

Leichtgewicht: Die Kontextwechselkosten von Coroutinen sind sehr gering und eine große Anzahl von Coroutinen kann gleichzeitig in einem einzelnen Thread ausgeführt werden.
Geringe Latenz: Während der Ausführung der Coroutine entsteht kein Mehraufwand für Threadwechsel oder Sperren und Entsperren, was eine schnellere Reaktion auf externe Ereignisse ermöglicht.
Effizienz: Coroutine-Code ist in der Regel prägnanter und lesbarer als Multi-Thread- und Multi-Prozess-Code und hat geringere Wartungskosten.
Zu den Einsatzszenarien von Coroutinen gehören Netzwerkprogrammierung, asynchrone E/A, Datenflussverarbeitung, Aufgaben mit hoher Parallelität usw.

Generator-Coroutine

In Python 3 bezieht sich Generator-Coroutine auf eine Coroutine, die mithilfe von Generatorfunktionen implementiert wird. Eine Generatorfunktion ist eine spezielle Funktion, die ein Generatorobjekt zurückgibt. Die Ausführung der Funktion kann durch die yield-Anweisung angehalten werden und wird dann fortgesetzt, wenn die

"next"

()-Methode des Generatorobjekts das nächste Mal aufgerufen wird. Das Folgende ist ein Beispiel für eine einfache Generator-Coroutine, die eine Generator-Funktions-Coroutine und eine einfache asynchrone E/A-Operation enthält:

import asyncio

def coroutine():
    print('Coroutine started')
    while True:
        result = yield
        print('Coroutine received:', result)

async def main():
    print('Main started')
    c = coroutine()
    next(c)
    c.send('Hello')
    await asyncio.sleep(1)
    c.send('World')
    print('Main finished')

asyncio.run(main())

Ergebnisausgabe:

[root@workhost k8s]# python3 test .py

Main gestartet.

Coroutine gestartet.



Erstellen Sie ein Generatorobjekt c und rufen Sie next(c) auf, um seine Ausführung bei der ersten yield-Anweisung anzuhalten.

Verwenden Sie c.send('Hello'), um die Ausführung der Generatorfunktion fortzusetzen und verwenden Sie 'Hello' als Rückgabewert der Generatorfunktion.

• Während sie 1 Sekunde wartet, pausiert die Hauptfunktion die Ausführung und wartet darauf, dass die Ereignisschleife die nächste Aufgabe initiiert.

• Nachdem Sie 1 Sekunde gewartet haben, verwenden Sie c.send('World'), um die Ausführung der Generatorfunktion fortzusetzen und verwenden Sie 'World' als Rückgabewert der Generatorfunktion.

• Die Hauptfunktion nimmt die Ausführung wieder auf und gibt „Haupt beendet“ aus.

• Durch die Verwendung der Generatorfunktions-Coroutine implementiert dieser Code eine einfache Coroutine. Eine Generatorfunktion unterbricht die Ausführung der Funktion mithilfe der yield-Anweisung, die dann über die send-Methode fortgesetzt werden kann und den Wert an die Generatorfunktion übergibt. Auf diese Weise können Sie Generatorfunktionen verwenden, um asynchrone Parallelität zu erreichen. Verwenden Sie eine Generatorfunktion, um die Ergebnisse eines asynchronen E/A-Vorgangs zu akzeptieren und auszudrucken, wie im Beispiel gezeigt.

Native Coroutine

• Python 3 führt Native Coroutine als neuen Coroutine-Typ ein. Native Coroutinen werden mithilfe des Schlüsselworts async/await definiert und können im Gegensatz zu Generator-Coroutinen Werte wie normale Funktionen mithilfe der Return-Anweisung anstelle der Yield-Anweisung zurückgeben.

Das Folgende ist ein einfaches natives Coroutine-Beispiel, das eine mit dem Schlüsselwort async geänderte Coroutine-Funktion und eine einfache asynchrone E/A-Operation enthält:

• import asyncio
  
  async def coroutine():
      print('Coroutine started')
      await asyncio.sleep(1)
      print('Coroutine finished')
  
  async def main():
      print('Main started')
      await coroutine()
      print('Main finished')
  
  asyncio.run(main())

  Ergebnisausgabe:

[root@workhost k8s] # python3 test.py

Main gestartet

Coroutine gestartet

Coroutine beendet

Main beendet

Sehen Sie sich weiterhin den Ausführungsprozess an:

Die Hauptfunktion beginnt mit der Ausführung und gibt „Main gestartet“ aus.

Rufen Sie die Coroutine-Funktion auf und führen Sie sie als Coroutine-Objekt aus.

In der Coroutine-Funktion wird Coroutine gestartet ausgedruckt.

• In der Coroutine-Funktion verwenden Sie „await asyncio.sleep(1)“, um die Ausführung der Funktion anzuhalten und 1 Sekunde zu warten.

• Nach 1 Sekunde die Ausführung der Coroutine-Funktion fortsetzen und ausdrucken, dass Coroutine fertig ist.

• Die Hauptfunktion nimmt die Ausführung wieder auf und gibt „Haupt beendet“ aus.

• Im obigen Code wird eine native Coroutine-Funktions-Coroutine mithilfe des Schlüsselworts async definiert und das Schlüsselwort „await“ darin verwendet, um die Ausführung der Funktion anzuhalten und auf den Abschluss des asynchronen E/A-Vorgangs zu warten. Durch die Verwendung nativer Coroutinen können Sie gleichzeitig asynchronen Code schreiben und so die Effizienz und Leistung des Codes verbessern.

  两种协程对比

  Python 3 中，原生协程和生成器协程是不同的协程实现方式，它们分别具有独特的特点和适用场景。下面，通过对比它们的区别和优缺点，才可以更好地理解它们之间的异同，以便选择适合自己的协程实现方式，从而更好地编写高效、可维护的异步程序。

  1.区别：

  • 定义方式不同：原生协程使用 async/await 关键字来定义，而生成器协程使用 yield 关键字来定义。

  • 返回方式不同：原生协程使用 return 语句来返回结果，而生成器协程使用 yield 语句来返回结果。

  • 调用方式不同：原生协程使用 await 关键字来调用，而生成器协程使用 yield from 或 yield 语句来调用。

  • 原生协程与生成器协程的实现方式不同，前者使用 asyncio 库，后者则是 Python 语言内置的特性。

  2.优缺点：

  原生协程的优点：

  • 代码简洁易懂：使用 async/await 关键字，可以编写出更简洁易懂的协程代码。

  • 性能更高：原生协程不需要创建生成器对象，也不需要通过 yield 语句来控制函数的执行流程，因此能够更加高效地处理异步操作。

  • 支持异步 I/O 和任务处理：原生协程可以支持异步 I/O 操作和并发任务处理，可以在处理异步操作时更加灵活。

  原生协程的缺点：

  • 兼容性差：原生协程是 Python 3.5 版本之后才引入的新特性，因此在旧版本的 Python 中无法使用。

  • 异常处理不方便：原生协程在处理异常时比较麻烦，需要使用 try/except 语句来处理。

  生成器协程的优点：

  • 兼容性好：生成器协程是 Python 2 和 Python 3 都支持的特性。

  • 可读性好：生成器协程使用 yield 关键字来实现，代码逻辑清晰易懂。

  • 异常处理方便：生成器协程在处理异常时比较方便，可以使用 try/except 语句来处理。

  生成器协程的缺点：

  • 性能相对较低：生成器协程需要创建生成器对象，也需要通过 yield 语句来控制函数的执行流程，因此处理异步操作时性能相对较低。

  • 功能有限：生成器协程不能像原生协程一样支持异步 I/O 操作和任务处理。

  实战案例

  接下来，模拟一个场景，假设实现一个异步的批量处理任务的工具，使用原生协程来实现。

  看下面代码：

  import asyncio
  import random
  
  async def batch_process_task(tasks, batch_size=10):
      # 将任务列表划分为多个批次
      for i in range(0, len(tasks), batch_size):
          batch = tasks[i:i+batch_size]
          # 使用原生协程来异步处理每个批次的任务
          await asyncio.gather(*[process_task(task) for task in batch])
  
  async def process_task(task):
      # 模拟任务处理过程
      await asyncio.sleep(random.uniform(0.5, 2.0))
      print("Task {} processed".format(task))
  
  async def main():
      # 构造任务列表
      tasks = [i for i in range(1, 101)]
      # 并发处理批量任务
      await batch_process_task(tasks, batch_size=10)
  
  if __name__ == '__main__':
      asyncio.run(main())

  输出：

  [root@workhost k8s]# python3 test.py 
  Task 9 processed
  Task 10 processed
  Task 1 processed
  Task 8 processed
  Task 6 processed
  Task 4 processed
  Task 3 processed
  Task 2 processed
  Task 5 processed
  ...
  ...

  batch_process_task函数使用原生协程来处理每个批次的任务，而process_task函数则是处理每个任务的函数。在main函数中，任务列表会被构造，并使用batch_process_task函数来异步地处理批量任务。

Das obige ist der detaillierte Inhalt vonWas sind die Implementierungsmethoden von Python-Coroutinen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!