Asynchrone Anfragen in Python

1. Asynchrone Anfragen in Python
2. Bedeutung der Verwendung asynchroner Anfragen in Python
3. der einfachste Weg, asynchrone Anfragen in Python zu schreiben
4. Behandeln Sie asynchrone Anfragen in Python
5. Erforderliche Python-Bibliotheken für asynchrone Anfragen
6. Asynchrone Anfragen vs. reguläre Anfragen
7. Async-Anfragen in Python

Heute werden wir etwas über asynchrone Anfragen lernen; Diese Diskussion führt zum Codebeispiel, um zu sehen, wie wir asynchrone Anfragen in Python schreiben können.

Asynchrone Anfragen in Python

Asynchrone Anfragen sind das Herzstück unseres Systems. Wir können sie uns wie folgt vorstellen:

Wenn ein Benutzer unsere Seite (Website oder Web-App) lädt, beginnt der Benutzer sofort, den Inhalt zu sehen. Aber es ist noch nicht ganz fertig. Wir laden also den Inhalt asynchron im Hintergrund, während der Benutzer weiter mit der Seite interagiert.

Diese Anforderungen blockieren nicht die Ausführung des nachfolgenden Codes, während auf eine Antwort gewartet wird. Das bedeutet, dass anderer Code weiter ausgeführt werden kann, während die Anfrage verarbeitet wird.

Dies kann beim Umgang mit externen Ressourcen wie API-Aufrufen hilfreich sein, deren Beantwortung einige Zeit in Anspruch nehmen kann. Es kann auch Ihren Code reaktionsschneller machen, da die Benutzeroberfläche weiterhin aktualisiert werden kann, während eine Anfrage verarbeitet wird.

Bedeutung der Verwendung asynchroner Anfragen in Python

Asynchrone Anfragen sind eine großartige Möglichkeit, die Leistung unserer Python-Anwendung zu verbessern. Wenn eine Anfrage gestellt wird, kann der Python-Interpreter weiterhin anderen Code ausführen, während die Anfrage verarbeitet wird.

Dies kann zu einer erheblichen Geschwindigkeitssteigerung führen, insbesondere bei Anwendungen, die viele Anforderungen stellen. Im Folgenden sind jedoch einige wichtige Punkte aufgeführt, die Sie bei der Verwendung asynchroner Anforderungen beachten sollten.

1. Erstens müssen wir vermeiden, zu viele Anfragen gleichzeitig zu stellen. Der Dolmetscher kann überfordert und langsamer werden, wenn wir zu viele Anfragen stellen.
2. Zweitens müssen wir bereit sein, mit Fehlern umzugehen. Wenn eine Anfrage fehlschlägt, kann der Interpreter den Code nicht weiter ausführen.

Insgesamt sind asynchrone Anfragen ein großartiges Werkzeug, um die Leistung unserer Python-Anwendung zu verbessern. Aber verwenden Sie es vorsichtig; Sie können dazu beitragen, dass unsere Anwendung schneller und reibungsloser läuft.

der einfachste Weg, asynchrone Anfragen in Python zu schreiben

Asynchrone Anfragen werden einfach mit dem Modul asyncio gestellt. Darüber hinaus bietet Pythons asyncio-Bibliothek Werkzeuge zum Schreiben von asynchronem Code. Beispielsweise können wir asyncio.sleep() verwenden, um eine Coroutine anzuhalten, und asyncio.wait(), um auf den Abschluss einer Coroutine zu warten.

Um eine asynchrone Anfrage zu schreiben, müssen wir zuerst eine Coroutine erstellen. Wir können dies mit der Funktion asyncio.ensure_future() tun. Sobald wir eine Coroutine haben, können wir die Funktion asyncio.sleep() verwenden, um sie anzuhalten, und die Funktion asyncio.wait(), um auf ihren Abschluss zu warten.

Behandeln Sie asynchrone Anfragen in Python

Wenn wir die asynchronen Anfragen in Python ausführen möchten, sollten Sie zunächst die Python-Bibliothek von aiohttp installieren, indem Sie den folgenden Befehl verwenden.

pip install aiohttp

Wir können asynchrone Anfragen verwenden, um die Leistung von Python-Anwendungen zu verbessern. Indem wir Anfragen parallel stellen, können wir den Prozess erheblich beschleunigen.

Es gibt verschiedene Möglichkeiten, asynchrone Anfragen in Python zu verarbeiten. Am beliebtesten ist die Bibliothek asyncio. Diese Bibliothek bietet leistungsstarke Tools für den Umgang mit asynchronen Anfragen.

Eine weitere beliebte Option ist die Bibliothek grequests. Diese Bibliothek ist etwas einfacher zu verwenden als asyncio, aber sie kann genauso effektiv sein.

Welche Option wir wählen, hängt von unseren spezifischen Bedürfnissen ab. Aber wofür wir uns auch entscheiden, wir werden mit Sicherheit einen erheblichen Leistungsschub erleben, wenn wir unsere Anfragen asynchron machen.

import grequests

urls = [
    "http://www.heroku.com",
    "http://tablib.org",
    "http://httpbin.org",
    "http://python-requests.org",
    "http://kennethreitz.com",
]

rs = (grequests.get(u) for u in urls)
grequests.map(rs)

Erforderliche Python-Bibliotheken für asynchrone Anfragen

Wir können zahlreiche Python-Bibliotheken verwenden, um asynchrone Anfragen zu stellen. Die beliebtesten sind aiohttp und asyncio.

aiohttp-Bibliothek für asynchrone Anfragen

aiohttp ist eine Bibliothek, die es uns ermöglicht, asynchrone HTTP-Anfragen zu stellen. Es baut auf asyncio auf und bietet eine einfache Schnittstelle zum Erstellen von HTTP-Anforderungen.

asyncio-Bibliothek für asynchrone Anfragen

asyncio ist eine Bibliothek, die die asynchrone Programmierung in Python unterstützt. Es ermöglicht uns, asynchronen Code zu schreiben und macht es einfach, Bibliotheken zu verwenden, die asyncio unterstützen.

Sowohl aiohttp als auch asyncio sind auf PyPI verfügbar und können mit pip installiert werden.

import asyncio
import aiohttp
import json

from text_api_config import apikey

Asynchrone Anfragen vs. reguläre Anfragen

Wir können zwei Arten von Anfragen an einen Server stellen: asynchron und regelmäßig. Asynchrone Anfragen werden im Hintergrund gestellt, während der Benutzer noch mit der Seite interagiert. Typische Anfragen werden gestellt, während die Seite geladen wird.

Asynchrone Anfragen sind im Allgemeinen schneller und effizienter als normale Anfragen, da sie das Laden der Seite nicht blockieren. Sie können jedoch komplexer zu implementieren sein und werden nicht immer von allen Browsern unterstützt.

Codebeispiel:

import requests
import time

start_time = time.time()

for number in range(1, 151):
    url = f"https://pokeapi.co/api/v2/pokemon/{number}"
    resp = requests.get(url)
    pokemon = resp.json()
    print(pokemon["name"])

print("--- %s seconds ---" % (time.time() - start_time))

Ausgang:

bulbasaur
ivysaur
venusaur
....
dragonair
dragonite
mewtwo
--- 68.17992424964905 seconds

das asyncio-Modul in Python

asyncio ist ein Modul für nebenläufiges Programmieren in Python. Es bietet einen Rahmen für die Verwaltung gleichzeitiger Threads, Aufgaben und Ereignisse. asyncio wird verwendet, um Programme zu schreiben, die mehrere Aufgaben gleichzeitig ausführen können.

asyncio basiert auf dem Konzept von Coroutinen. Eine Coroutine ist eine Funktion, die ihre Ausführung aussetzen und die Kontrolle an den Aufrufer zurückgeben kann. Es ermöglicht die gleichzeitige Ausführung mehrerer Coroutinen.

asyncio bietet Tools zum Verwalten von Coroutinen, einschließlich einer Ereignisschleife, eines Aufgabenplaners und gleichzeitiger Datenstrukturen.

asyncio ist ein effizienter Weg, um nebenläufige Programme zu schreiben. Es ist einfach zu bedienen und kann auf große Programme skaliert werden. asyncio ist eine ausgezeichnete Wahl für Programme, die mehrere Aufgaben gleichzeitig erfordern.

Codebeispiel:

import asyncio
import aiohttp
import json
from text_api_config import apikey


async def gather_with_concurrency(n, *tasks):
    semaphore = asyncio.Semaphore(n)

    async def sem_task(task):
        async with semaphore:
            return await task

    return await asyncio.gather(*(sem_task(task) for task in tasks))

das aiohttp-Modul in Python

Das Modul aiohttp ist ein asynchroner HTTP-Client/Server für Python. Es baut auf asyncio auf und bietet eine einfache API für die Arbeit mit HTTP.

Das Modul aiohttp erleichtert das Arbeiten mit HTTP in Python. Es bietet eine einfache API, die das Senden und Empfangen von HTTP-Anforderungen und -Antworten vereinfacht.

Das Modul aiohttp bietet auch eine Möglichkeit, einen asynchronen HTTP-Server zu betreiben.

import asyncio
import aiohttp
import json
from text_api_config import apikey


async def main():
    conn = aiohttp.TCPConnector(limit=None, ttl_dns_cache=300)
    session = aiohttp.ClientSession(connector=conn)
    urls = [summarize_url, ner_url, mcp_url]
    conc_req = 3

Async-Anfragen in Python

Codebeispiel:

import queue


def task1(name, s_queue):
    if s_queue.empty():
        print(f"Task {name} has nothing to do")
    else:
        while not s_queue.empty():
            cnt = s_queue.get()
            total = 0
            for x in range(cnt):
                print(f"Task {name} is working now.")
                total += 1
            print(f"Task {name} is working with a total of: {total}")


def s_async():
    s_queue = queue.Queue()
    for work in [2, 5, 10, 15, 20]:
        s_queue.put(work)
    tasks = [
        (task1, "Async1", s_queue),
        (task1, "Async2", s_queue),
        (task1, "Async3", s_queue),
    ]
    for t, n, q in tasks:
        t(n, q)


if __name__ == "__main__":
    s_async()

Ausgang:

Task Async1 is running now.
Task Async1 is running with a total of: 2
Task Async1 is running now
...
Task Async1 is running now.
Task Async1 is running with a total of: 5
Task Async1 is running now
...
Task Async1 is running now.
Task Async1 is running with a total of: 10
Task Async1 is running now
...
Task Async1 is running now.
Task Async1 is running with a total of: 15
Task Async1 is running now
...
Task Async1 is running now.
Task Async1 is running with a total of: 20
Task Async3 has nothing to do