Top 9 Asynchrone Web Frameworks für Python

Asynchrone Programmierung ist jetzt ein erstklassiger Bürger in Python. Wenn Sie ein Webentwickler sind, gibt es erstaunliche Gerüste Sie können wählen aus!

Zum Zeitpunkt des Schreibens ist Asynchron nicht mehr nur ein Schlagwort in der Python-Community. Mit der Veröffentlichung seiner Asyncio In der Version 3.5 von Python erkannte Python die Auswirkungen von Node.js auf die Webentwicklung an und führte zwei neue Schlüsselwörter in die Sprache ein: async und await.

Dies war ein sehr Eine große Sache, da die Python-Sprache bei der Erweiterung der Kernsyntax äußerst vorsichtig ist, es sei denn, es besteht ein dringender Bedarf, der nur darauf hinweist, wie wichtig die Python-Entwickler die asynchronen Funktionen betrachteten.

Infolgedessen wurden Schleusen für die asynchrone Programmierung geöffnet: Neue und alte Bibliotheken begannen, die Coroutinen-Funktion zu nutzen, asynchrone Frameworks wurden immer beliebter, und auch heute noch werden neue geschrieben.

Eine Leistung auf Augenhöhe oder besser als die von Node.js ist keine Seltenheit, und wenn Ihre Lademuster nicht viele CPU-lastige Aufgaben beinhalten, gibt es keinen Grund, warum Sie nicht ein paar tausend Anfragen pro Sekunde stellen können.

Aber genug Motivation!

Lassen Sie uns einen Blick auf die aktuelle Python-Landschaft werfen und einige der wichtigsten asynchronen Frameworks untersuchen.

Tornado

Überraschenderweise, Tornado ist überhaupt kein neues Framework. Die Erstveröffentlichung erfolgte im Jahr 2009 und seitdem liegt der Schwerpunkt auf der Bereitstellung einer absolut soliden asynchronen Programmierung mit hoher Parallelität.

Tornado ist im Grunde kein Webframework. Es ist eine Sammlung von asynchronen Modulen, die auch zum Erstellen des Webframework-Moduls verwendet werden. Insbesondere sind diese Module:

• Coroutinen und andere Grundelemente (tornado.gen, tornado.locks, tornado.queues, Usw.)
• Netzwerkmodule (tornado.ioloop, tornado.iostream, Usw.)
• Asynchrone Server und Clients (tornado.httpserver, tornado.httpclient, Usw.)

Diese wurden kombiniert, um die endgültigen Framework-Module zu erstellen: tornado.web, tornado.routing, tornado.template, usw.

import tornado.ioloop
import tornado.web

class MainHandler(tornado.web.RequestHandler):
    def get(self):
        self.write("Hello, world")

def make_app():
    return tornado.web.Application([
        (r"/", MainHandler),
    ])

if __name__ == "__main__":
    app = make_app()
    app.listen(8888)
    tornado.ioloop.IOLoop.current().start()

Tornado hat eine starke und engagierte Anhängerschaft in der Python-Community und wird von erfahrenen Architekten verwendet, um hochleistungsfähige Systeme zu erstellen. Es ist ein Framework, das seit langem die Antwort auf die Probleme der Parallelität hat, aber möglicherweise nicht zum Mainstream geworden ist, da es den WSGI-Standard nicht unterstützt und zu viel Buy-In war (denken Sie daran, dass der Großteil der Python-Bibliotheken immer noch synchron ist ).

Sanic

Sanic ist ein „modernes“ Framework im wahrsten Sinne des Wortes: Es unterstützt keine Python-Version unter 3.6, unterstützt die einfache und universelle Async / Wait-Syntax und lässt Sie daher keine Lasten lesen von Dokumentation und behalten Sie Randfälle im Kopf, bevor Sie Ihren ersten HTTP-Handler schreiben können.

Infolgedessen ist die resultierende Syntax recht angenehm (zumindest meiner Meinung nach); Es ähnelt Code, den Sie mit jedem anderen Mikroframework (z. B. Flask, CherryPy) mit nur wenigen schreiben würden async bestreut in:

from sanic import Sanic
from sanic.response import json

app = Sanic()

@app.route("/")
async def test(request):
    return json({"hello": "world"})

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=8000)

Sanic ist wohl das beliebteste und beliebteste asynchrone Framework in der Python-Welt. Es bietet fast alle Funktionen, die Sie für Ihre Projekte benötigen - Routing, Middleware, Cookies, Versionierung, Blaupausen, klassenbasierte Ansichten, statische Dateien, Streaming, Sockets usw. - und was es nicht sofort bietet - Vorlagen, Datenbankunterstützung, Datei-E / A, Warteschlangen - können hinzugefügt werden, da derzeit nur genügend asynchrone Bibliotheken für diese vorhanden sind.

Vibora

Vibora ist ein enger Verwandter von Sanic, außer dass es darauf fixiert ist, der schnellste Python-Webserver da draußen zu werden. Tatsächlich begrüßt Sie der allererste Besuch seiner Website mit einem Rahmenvergleich:

Wie Sie sehen können, behauptet Vibora, um ein Vielfaches schneller als die klassischen Frameworks und mehr als doppelt so schnell wie Sanic, sein nächster Konkurrent. Benchmarks sind natürlich mit einem Körnchen Salz zu nehmen. 🙂

Obwohl Vibora in Bezug auf Syntax und Funktionen mit Sanic vergleichbar ist (oder vielleicht sogar etwas besser, da es beliebte Bibliotheken bündelt und Dinge wie Vorlagen sofort verfügbar sind), würde ich Sanic als ausgereifter betrachten, da es schon länger existiert und hat eine größere Gemeinschaft.

from vibora import Vibora, JsonResponse

app = Vibora()

@app.route('/')
async def home():
    return JsonResponse({'hello': 'world'})

if __name__ == '__main__':
    app.run(host="0.0.0.0", port=8000)

Wenn Sie jedoch ein Performance-Junkie sind, kann Vibora Ihr Boot schwimmen lassen. Das heißt, zum Zeitpunkt des Schreibens wird Vibora komplett neu geschrieben, um noch schneller zu werden Link zu seiner Leistungsversion sagt, dass es unter "starker Entwicklung" ist. Es wird eine Enttäuschung für diejenigen sein, die Vibora früher aufgegriffen haben und sich bald bahnbrechenden Veränderungen stellen müssen, aber hey, es ist noch früh in der asynchronen Python-Welt, und niemand erwartet, dass die Dinge stabil sind.

Quart

Wenn Sie gerne in Flask entwickeln, aber den Mangel an asynchroner Unterstützung bereuen, werden Sie es genießen Quart viel.

Quart ist konform mit dem ASGIA Standard, der ein Nachfolger des berühmten WSGI-Standards ist und asynchrone Unterstützung bietet. Das Interessante an Quart ist, dass es nicht nur Flask ähnelt, sondern auch mit der Flask-API kompatibel ist! Der Autor dieses Frameworks wollte das Flask-Feeling beibehalten und nur Async-, WebSockets- und HTTP 2-Unterstützung hinzufügen. Infolgedessen können Sie Quart direkt aus der Flask-Dokumentation lernen, wobei Sie jedoch berücksichtigen, dass die Funktionen in Quart asynchron sind.

from quart import Quart

app = Quart(__name__)

@app.route('/')
async def hello():
    return 'hello'

app.run()

Fühlt sich (fast) genau wie Flask an, nicht wahr?!

Da Quart eine Weiterentwicklung von Flask ist, stehen alle Funktionen in Flask zur Verfügung: Routing, Middleware, Sitzungen, Vorlagen, Blaupausen usw. Sie können sogar Flask-Erweiterungen direkt in Quart verwenden. Ein Haken ist, dass Python 3.7+ nur unterstützt wird. Wenn Sie jedoch nicht die neueste Version von Python ausführen, ist Async möglicherweise nicht der richtige Pfad. 🙂

Die Dokumentation ist wirklich mangelhaft, wenn Sie keine früheren Erfahrungen mit Flask haben, aber ich kann Quart empfehlen, da es wahrscheinlich das einzige asynchrone Framework ist, das kurz vor der Veröffentlichung von 1.0 steht.

FastAPI

Das letzte (aber beeindruckendste) Framework auf dieser Liste ist FastAPI. Nein, es handelt sich nicht nur um ein API-Framework. Tatsächlich scheint FastAPI das funktionsreichste und dokumentationsreichste Framework zu sein, auf das ich bei der Untersuchung asynchroner Python-Frameworks gestoßen bin.

Es ist interessant festzustellen, dass der Framework-Autor mehrere andere Frameworks eingehend untersucht hat, von zeitgenössischen wie Django bis zu modernen wie Sanic, und sich mit Technologien in NestJS (einem Node.js, Typescript-Webframework) befasst. Ihre Entwicklungsphilosophie und umfangreiche Vergleiche können gelesen werden hier .

Die Syntax ist sehr angenehm; Man kann sogar behaupten, dass es viel angenehmer ist als die anderen Frameworks, auf die wir gestoßen sind:

rom fastapi import FastAPI

app = FastAPI()

@app.get("/users/me")
async def read_user_me():
    return {"user_id": "the current user"}

@app.get("/users/{user_id}")
async def read_user(user_id: str):
    return {"user_id": user_id}

Und jetzt die Liste der Killer-Funktionen, die FastAPI andere Frameworks übertreffen lassen:

Automatische API-Dokumentgenerierung: Sobald Ihre Endpunkte geschrieben wurden, können Sie mit der API über eine standardkonforme Benutzeroberfläche spielen. SwaggerUI, ReDoc und andere werden unterstützt.

Das Framework führt auch eine automatische Datenmodelldokumentation mit JSON Schema durch.

Moderne Entwicklung: Ja, das Wort "modern" wird viel herumgeworfen, aber ich fand, dass FastAPI tatsächlich das Gespräch führt. Abhängigkeitsinjektion und Typhinweise sind erstklassige Bürger, die nicht nur gute Codierungsprinzipien durchsetzen, sondern auf lange Sicht Fehler und Verwirrung verhindern.

Umfangreiche Dokumentation: Ich weiß nichts über dich, aber ich bin ein totaler Trottel für gute Dokumentation. Und in diesem Bereich gewinnt FastAPI zweifellos. Es gibt Seiten für Seiten mit Dokumenten, die fast jede Kleinigkeit erklären und „aufgepasst!“. Momente für Entwickler aller Ebenen. Ich spüre hier ein klares „Herz und eine Seele“ in den Dokumenten, und der einzige Vergleich, den ich finden kann, sind die Django-Dokumente (ja, FastAPI-Dokumente sind so gut!).

Über die Grundlagen hinausgehend: FastAPI unterstützt WebSockets, Streaming sowie GraphQL und verfügt über alle herkömmlichen Helfer wie CORS, Sitzungen, Cookies usw.

Und was ist mit der Leistung? Nun, FastAPI basiert auf der erstaunlichen Starlette-Bibliothek, was zu einer Leistung führt, die der von Node und in einigen Fällen sogar von Go! Alles in allem habe ich wirklich das Gefühl, dass FastAPI als bestes asynchrones Framework für Python voranschreiten wird.

BlackSheep

Schwarzschaf kann verwendet werden, um serverseitige oder Full-Stack-Anwendungen mit einem MVC-Muster zu erstellen.

Einige der Funktionen, die BlackSheep bietet, sind

• Eine Rich-Code-API.
• Integrierte Abhängigkeitsinjektion.
• Eingebaute Generierung von OpenAPI-Dokumentation.
• Automatische Bindung von Request-Handlern.

Projektaufbau

Lassen Sie uns eine einfache serverseitige Anwendung mit BlackSheep erstellen. Führen Sie die folgenden Befehle schnell nacheinander aus, um das Projekt einzurichten.

python -m venv basic-app
cd basic-app
source bin/activate
pip install blacksheep uvicorn

Wir sind mit der Einrichtung des Projekts fertig. Lassen Sie uns eine Datei namens erstellen server.py und fügen Sie den folgenden Code ein.

from blacksheep import Application

app = Application()

@app.router.get("/")
def home():
    return "Hello, World!"

Wir haben unsere berühmteste Hallo-Welt-Anwendung erstellt. Es gibt nur eine Route mit HTTP GET Methode für jetzt, und es ist /. Die Funktion home wird in BlackSheep Request-Handler genannt.

Wir haben a verwendet router Dekorateur aus der App. Es gibt eine andere Möglichkeit, Routen zu erstellen, dh route. Wir werden die verwenden router in diesem Tutorial. Sie können mehr darüber finden route der docs.

Lassen Sie uns die Anwendung mit dem folgenden Befehl ausführen.

uvicorn server:app --port 8000 --reload

Gehen Sie zum http://localhost:8000/ im Browser. Sie sehen hello Welt im Browser. Lassen Sie uns ein wenig über den Befehl sprechen, den wir zum Ausführen der Anwendung verwendet haben.

• Wir haben benutzt uvicorn Paket, um unsere Anwendung auszuführen.
• Die server ist der Dateiname, den wir vergeben haben. Wenn Sie einen anderen Dateinamen verwenden, ändern Sie ihn auch im Startbefehl.
• Die Option --port gibt den Port an, auf dem unsere App laufen soll.
• Schließlich wird das --reload Die Option besteht darin, die Anwendung im Browser neu zu laden, wenn wir Änderungen an der vornehmen server Datei.

JSON-Antwort

In der realen Welt benötigen wir die API-Antworten in den meisten Fällen in JSON. Wir können eine JSON-Antwort von der Methode zurückgeben, indem wir das JSON-Objekt mit umschließen json von dem blacksheep Paket. Mal sehen, wie wir es tun können.

from blacksheep import Application, json

app = Application()

@app.router.get("/")
def home():
    return json({"message": "Hello, World!"})

Wir haben importiert json von dem blacksheep und das JSON-Objekt damit umschlossen. Überprüfen Sie es im Browser auf JSON-Antwort.

Routenparameter

Wir müssen manchmal die Routenparameter für die Anfragen akzeptieren. Wir können dies in BlackSheep tun, indem wir sie innerhalb der HTTP-Methode definieren. Mal sehen.

@app.router.get("/{name}")
def home(name):
    return json({"greetings": f"Hello, {name}!"})

Wir akzeptieren einen Routenparameter namens name. Geh zum http://localhost:8000/Geekflare. Die Methode gibt eine Begrüßung mit dem in der Route angegebenen Namen zurück.

Der Router-Decorator übergibt den gleichnamigen Parameter an die home Funktion, wie sie dem Dekorateur gegeben wird. Hier wird es sein name. Wenn Sie es im Decorator ändern, ändern Sie es im home Funktion auch.

Wir können so viele Routenparameter wie möglich auf ähnliche Weise akzeptieren. Sehen wir uns ein kurzes Beispiel an.

@app.router.get("/{name}/{info}")
def home(name, info):
    return json({"greetings": f"Hello, {name}! Info {info}"})

Wir haben einen weiteren Routenparameter namens akzeptiert info. Gehen Sie zu http://localhost:8000/Geekflare/Chandan, um es zu überprüfen.

Abfrageparameter

Wir müssen nichts tun, um die Abfrageparameter zu akzeptieren. BlackSheep sendet die Abfrageparameter automatisch in Form einer Liste an die Funktion. Sehen wir uns das Beispiel an.

@app.router.get("/")
def home(name):
    print(name)
    return json({"greetings": f"Hello, {name[0]}!"})

Gehen Sie zu http://localhost:8000/?name=Geekflare um die Antwort zu überprüfen. Wenn Sie mehrere Abfrageparameter mit demselben Namen haben, fügt BlackSheep sie alle zur Liste hinzu.

Gehen Sie zu http://localhost:8000/?name=Geekflare&name=Chandan und überprüfen Sie die Ausgabe im Terminal. Sie sehen eine Liste mit Geekflare und Chadan da wir zwei gleichnamige Abfrageparameter übergeben haben.

Wenn Sie mehrere Abfrageparameter mit unterschiedlichen wünschen, können Sie dies auch tun. Fügen Sie der Funktion einfach ein weiteres Argument mit dem Namen des Abfrageparameters hinzu und machen Sie damit, was Sie wollen.

Objekt anfordern

Das einzige, was in unseren Grundlagen übrig bleibt, ist das Überprüfen anderer HTTP-Methoden. Bevor wir darauf eingehen, überprüfen wir die request Objekt für die API.

Alle Anfrage-Handler im BalckSheep haben ein Anfrage-Argument, das alle Informationen der kommenden Anfrage enthält. Es enthält Anforderungsheader, Pfadparameter, Abfrageparameter, Daten usw.,

Sehen wir uns ein Beispiel an, um das Anfrageobjekt zu sehen.

@app.router.post("/")
def home(request):
    print(request)
    return "Hello, World!"

Sie können die folgende Ausgabe im Terminal sehen.

<Request POST />

Wir können von der Anfrage aus auf verschiedene Dinge zugreifen. Sie können die Dokumente dafür überprüfen. Hier liegt unser Fokus auf dem Anforderungstext. Sehen wir uns an, wie Sie vom Anfrageobjekt aus auf den Anfragetext zugreifen.

@app.router.post("/")
async def home(request):
    data = await request.json()
    print(data)
    return "Hello, World!"

Es gibt eine Methode namens json in der Anfrage, die die Daten aus der Anfrage zurückgibt. Übergeben Sie einige Daten in der API-Anfrage und rufen Sie sie auf. Sie sehen den Datendruck im Terminal, das Sie an die API übergeben haben.

HTTP-Methoden

Wir haben die GET- und POST-Methoden in den obigen Beispielen gesehen. In ähnlicher Weise können Sie auch die Methoden PUT, DELETE usw. verwenden. Sich selbst auszuprobieren wird kein Problem sein, da sie unkompliziert sind.

AIOHTTP

aiohttp ist ein weiteres Framework, das mit den folgenden Hauptfunktionen ausgestattet ist.

• Es unterstützt sowohl serverseitige als auch clientseitige WebSockets.
• Es unterstützt sowohl die Entwicklung von Server- als auch von Client-Anwendungen.
• Sein Webserver verfügt über Middleware, Signale und steckbares Routing.

Projektaufbau

Lassen Sie uns eine einfache serverseitige Anwendung mit aiohttp erstellen. Führen Sie schnell die folgenden Befehle aus, um das Projekt einzurichten.

python -m venv basic-app
cd basic-app
source bin/activate
pip install aiohttp aiodns

Erstellen Sie eine Datei mit dem Namen server.py und fügen Sie den folgenden Code darin ein.

from aiohttp import web

async def home(request):
    return web.Response(text="Hello, World!")

app = web.Application()
app.add_routes([web.get('/', home)])

web.run_app(app)

Die web.Application Instanz ist unsere Hauptanwendung. Wir haben die HTTP GET-Methode mit der Route hinzugefügt / die unsere Lieblings-Hallo-Welt zurückgibt. Die Funktion web.run_app wird verwendet, um die Anwendung auszuführen, die die web.Application Instanz als Argument.

Die Funktion home wird in aiohttp als Request-Handler bezeichnet. Und es hat ein einziges Argument namens Anfrage, das alle Informationen der eingehenden Anfrage enthält.

Führen Sie die Anwendung mit dem folgenden Befehl aus. Es ist dasselbe wie das Ausführen normaler Python-Programme.

python3 server.py

Gehen Sie zu http://localhost:8080/ im Browser. Sie sehen hello Welt im Browser.

JSON-Antwort

Wir können die Antwort im JSON-Format mit zurückgeben web.json_response Funktion. Übergeben Sie die JSON-Daten an diese Funktion, während Sie die Antwort zurückgeben. Sehen wir uns das Beispiel an.

async def home(request):
    return web.json_response({"message": "Hello, World!"})

Wenn du nach ... gehst http://localhost:8080/ Sie sehen das JSON-Objekt im Browser.

Routenparameter

Wir können die Routenparameter beim Hinzufügen der Routen definieren. Und sie können von der abgerufen werden request Argument des Request-Handlers. Sehen wir uns ein Beispiel an.

from aiohttp import web

async def home(request):
    return web.json_response({"message": f"Hello, {request.match_info['name']}!"})

app = web.Application()
app.add_routes([web.get('/{name}', home)])

web.run_app(app)

Auf alle Routenparameter kann über die zugegriffen werden request.match_info wie im obigen Beispiel gezeigt. Gehe zu http://localhost:8080/Geekflare um es zu überprüfen.

Wir können auch Regex haben, um die Routen abzugleichen. Nehmen wir an, wir müssen nur akzeptieren /{any_number}. Wir können es tun, indem wir die ersetzen '/{name}' mit r'/{number:\d+}'. Wir haben Regex zum Pfadparameter hinzugefügt, der nur akzeptiert, wenn die Regex übergeben wird.

Lass uns ein Beispiel sehen

from aiohttp import web

async def home(request):
    return web.json_response({"message": f"Hello, {request.match_info['number']}!"})

app = web.Application()
app.add_routes([web.get(r'/{number:\d+}', home)])

web.run_app(app)

Gehen Sie zu http://localhost:8080/Geekflare, Sie erhalten einen 404-Fehler Geekflare stimmt nicht mit dem Regex-Muster überein, das wir angegeben haben. Gehen Sie jetzt zu http://localhost:8080/1234567890 Sie sehen die Antwort im Browser.

Abfrageparameter

Es muss nichts hinzugefügt werden, um Abfrageparameter zu akzeptieren. Wir können die Abfrageparameter aus der übernehmen request.query Objekt. Sehen wir uns ein Beispiel an.

from aiohttp import web

async def home(request):
    return web.json_response({"message": f"Hello, {request.query.get('name')}"})

app = web.Application()
app.add_routes([web.get('/', home)])

web.run_app(app)

Gehen Sie zu http://localhost:8080/?name=Geekflare und überprüfe das Ergebnis. Du wirst sehen Geekflare in der Antwort, auf die wir von zugreifen request.query.

Wir können auch mehrere Abfrageparameter übergeben, auf die mit ihren Schlüsselnamen zugegriffen werden kann.

HTTP-Methoden

Wir haben in den obigen Beispielen gesehen, wie man eine HTTP-GET-Methode erstellt. Wir müssen wissen, wie wir auf die Anfragedaten zugreifen können, bevor wir fortfahren. Sehen wir uns ein Beispiel dafür an.

from aiohttp import web

async def home(request):
    data = await request.json()
    print(data)
    return web.json_response({"message": f"Hello, World!"})

app = web.Application()
app.add_routes([web.post('/', home)])

web.run_app(app)

Im obigen Beispiel haben wir die API-Methode von GET auf POST geändert. Wir haben die Anforderungsdaten mit abgerufen request.json Methode.

Stellen Sie eine Post-Anfrage an http://localhost:8080/, sehen Sie den Ausdruck der Anforderungsdaten im Terminal.

In ähnlicher Weise können Sie auch die Methoden PUT, DELETE usw. verwenden. Probieren Sie sie selbst aus und haben Sie Spaß.

Sie können mehr über das Framework in ihrem erfahren docs.

Falcon

Falke ist ein ASGI-Framework zum Erstellen von REST-APIs und Microservices. Es hat die folgenden Hauptmerkmale.

• Es unterstützt WebSockets.
• Unterstützt Middleware und Hooks für die Anfrageverarbeitung.
• Einfache und unkomplizierte Ausnahmebehandlung.

Projektaufbau

Lassen Sie uns ein Projekt einrichten, um die Grundlagen des Falcon-Frameworks zu lernen. Richten Sie das Projekt mit den folgenden Befehlen ein.

python -m venv basic-app
cd basic-app
source bin/activate
pip install falcon uvicorn

Erstellen Sie eine Datei mit dem Namen server.py und fügen Sie den folgenden Code ein.

from falcon import asgi
import falcon


class Home:
    async def on_get(self, request, response):
        response.status = falcon.HTTP_200  # This is the default status
        response.content_type = falcon.MEDIA_TEXT  # Default is JSON, so override
        response.text = 'Hello, World!'

app = asgi.App()
app.add_route('/', Home())

Wir haben eine Klasse mit erstellt on_get Methode, die HTTP GET-Methode ist. Die Methode hat zwei Argumente. Einer ist request und eine andere, wenn response. Sie sollten erraten haben, was sie durch ihre Namen selbst sind.

Die request Argument enthält alle Informationen der eingehenden Anfrage, auf die zugegriffen werden kann, um die Anfrage zu verarbeiten. Und die response Das Argument wird verwendet, um die Antwort zu senden, indem verschiedene Dinge festgelegt werden.

Im Gegensatz zu BlackSheep und AIOHTTP müssen wir keine Antwort zurückgeben. Wir können die Antwort verwenden und alle Details festlegen, die wir als Antwort senden müssen. Im obigen Beispiel haben wir den Status auf 200, den Inhaltstyp auf Text und den Text auf Hallo Welt gesetzt.

Führen Sie die Anwendung mit dem folgenden Befehl aus

uvicorn server:app --reload

Gehen Sie zu http://localhost:8000/, sehen Sie die hallo Welt als Antwort.

JSON-Antwort

Wir können die Antwort als JSON zurückgeben, indem wir die Daten mit in JSON konvertieren json.dumps Methode. Sehen wir uns ein Beispiel an

from falcon import asgi
import falcon
import json

class Home:
    async def on_get(self, request, response):
        response.text = json.dumps({"greetings": "Hello, World!"})

app = asgi.App()
app.add_route('/', Home())

Gehen Sie zu http://localhost:8000/, sehen Sie die Antwort in JSON.

Routenparameter

Die Anfrageparameter werden als Argumente an die HTTP-Methoden übergeben. Sie können das Beispiel unten zum besseren Verständnis sehen.

from falcon import asgi
import falcon
import json

class Home:
    async def on_get(self, request, response, name):
        response.text = json.dumps({"greetings": f"Hello, {name}!"})

app = asgi.App()
app.add_route('/{name}/', Home())

Die name path Parameter übergeben wird on_get Methode als Argument. Gehe zu http://localhost:8000/Geekflare/ und überprüfen Sie die Antwort. Wir können so viele Routenparameter haben, wie wir wollen.

Abfrageparameter

Wir können auf die Abfrageparameter zugreifen, indem wir verwenden request.get_param(param_name) Methode. Sehen Sie sich das Beispiel unten an.

from falcon import asgi
import falcon
import json

class Home:
    async def on_get(self, request, response):
        response.text = json.dumps({"greetings": f"Hello, {request.get_param('name')}!"})

app = asgi.App()
app.add_route('/', Home())

Gehen Sie zu http://localhost:8000/?name=Geekflare um die Antwort zu überprüfen. Wir können so viele Abfrageparameter haben, wie wir wollen.

HTTP-Methoden

Wir haben die GET-Methode im obigen Beispiel gesehen. Das einzige, was wir für andere Methoden wissen müssen, ist, wie auf Anforderungsdaten zugegriffen wird. Auf die Anfragedaten können wir mit zugreifen request.stream.read Methode. Sehen wir uns ein Beispiel an.

from falcon import asgi
import falcon
import json

class Home:
    async def on_get(self, request, response):
        response.text = json.dumps({"greetings": "Hello, World!"})

    async def on_post(self, request, response):
        data = await request.stream.read()
        print(json.loads(data))
        response.text = "Hello, World!"

app = asgi.App()
app.add_route('/', Home())

Wir haben eine POST-Methode hinzugefügt, in der wir auf die Anforderungsdaten zugegriffen und sie nach der Konvertierung in JSON auf dem Terminal gedruckt haben. Machen Sie eine POST-Anfrage mit einigen Daten, um die Ausgabe zu überprüfen.

Versuchen Sie selbst, andere HTTP-Methoden wie DELETE, PUT usw. hinzuzufügen. Wir haben nur die Grundlagen des Falcon-Frameworks umgesetzt. Aber es steckt viel drin. Geh und lies die docs tiefer darüber zu erfahren.

Starlette

Starlet ist ein leichtgewichtiges ASGI-Framework in Python. Es hat fast alle grundlegenden Funktionen, um serverseitige Anwendungen zu erstellen.

Richten Sie das Projekt mit den folgenden Befehlen ein.

python -m venv basic-app
cd basic-app
source bin/activate
pip install starlette uvicorn

Das Erstellen von APIs mit Starlette ähnelt dem, was wir in den letzten Frameworks gesehen haben. Die Syntax und die Art und Weise, wie APIs erstellt werden, sind unterschiedlich. Alle Konzepte bleiben gleich. Wir werden also alle Dinge in einem einzigen Programm zusammenfassen.

Erstellen Sie eine Datei mit dem Namen server.py und fügen Sie den folgenden Code ein.

from starlette.applications import Starlette
from starlette.responses import PlainTextResponse, JSONResponse
from starlette.routing import Route


def homepage(request):
    return PlainTextResponse('Hello, World!')

def json_response(request):
    return JSONResponse({'message': 'Hello, World!'})

def path_params(request):
    name = request.path_params['name']
    return JSONResponse({'greetings': f'Hello, {name}!'})

def query_params(request):
    name = request.query_params['name']
    return JSONResponse({'greetings': f'Hello, {name}!'})

async def post_method(request):
    data = await request.json()
    print(data)
    return JSONResponse({'message': f'Hello, World!'})

def startup():
    print('Starlette started')

routes = [
    Route('/', homepage),
    Route('/json', json_response),
    Route('/path-params/{name}', path_params),
    Route('/query-params', query_params),
    Route('/post', post_method, methods=['POST']),
]

app = Starlette(debug=True, routes=routes, on_startup=[startup])

Führen Sie die Anwendung mit dem folgenden Befehl aus.

uvicorn server:app --reload

Testen Sie alle Dinge, die wir in den vorherigen Frameworks gesehen haben. Sie können mehr über das Starlette-Framework in seinem erfahren docs.

Fazit

Heutzutage ist in der asynchronen Python-Landschaft viel los. Neu Gerüste tauchen auf, alte werden umgeschrieben und Bibliotheken werden weiterentwickelt, um asynchronem Verhalten zu entsprechen. Während Python über eine integrierte Unterstützung für eine Ereignisschleife verfügt und es möglich ist, Teile Ihrer Anwendung asynchron zu machen, können Sie sich dafür entscheiden, alles zu tun und auf einem der Frameworks hier aufzubauen.

Achten Sie nur darauf, die Langfristigkeit im Auge zu behalten: Einige der asynchronen Python-Frameworks befinden sich noch im Anfangsstadium und werden schnell weiterentwickelt, was Ihrem Entwicklungsprozess schaden und die Geschäftskosten erhöhen wird.

Vorsicht ist angesagt!

Aber alles gesagt und getan; Python ist produktionsbereit und bietet eine hervorragende Leistung, wenn es um Web-Frameworks geht. Wenn Sie so lange über eine Migration auf Node nachgedacht haben, müssen Sie dies jetzt nicht mehr tun! 🙂

Hört sich cool an? Master Python heute!