){kind=small}
Das ultimative Kräftemessen: Flask vs. FastAPI
Die Wahl eines Rahmens ist nicht einfach, und deshalb bin ich hier, um Ihnen zu helfen, die Kopfschmerzen loszuwerden.
Warum sollten wir überhaupt vergleichen Flachmann und FastAPI?
Sie sind sich ähnlich. Beide sind abgespeckte Python-Microframeworks ohne den überflüssigen Schnickschnack, was eine schnellere Entwicklungszeit und mehr Flexibilität bedeutet. Außerdem werden beide für die Entwicklung von APIs und Webanwendungen verwendet.
Sie sind auch unterschiedlich. Flask ist kampferprobter, also etwas zuverlässiger, und es ist weit verbreitet. FastAPI ist ein neueres, moderneres Framework, das für seine Geschwindigkeit bekannt ist und eine Menge eingebauter Unterstützung wie Pydantic und SwaggerUI bietet.
Da Sie nun ein besseres Verständnis für die einzelnen Rahmenbedingungen haben, kann unser Wettstreit beginnen!
Manchmal ist es am schwierigsten, etwas Neues zu lernen, wenn man überhaupt anfangen kann. Deshalb beginnen wir mit der Installation.
Es ist relativ einfach, sowohl Flask als auch FastAPI mit Pythons bevorzugtem Installationsprogramm pip zu installieren. Es ist auch eine gute Praxis, beide innerhalb einer virtuellen Umgebung zu installieren, einer isolierten Umgebung für jedes Ihrer Python-Projekte, die Kollisionsfehler ausschließt.
$ pip install flask
$ pip install fastapi uvicornSchlussfolgerung: Beachten Sie, dass Sie FastAPI mit Uvicorn installieren. Stellen Sie sich Uvicorn als einen blitzschnellen Server vor, der Ihre Anwendungen schneller machen kann.
Wenn Sie in Ihrem ganzen Leben nur eine einzige Codezeile geschrieben haben, dann war es bestimmt so etwas wie diese:
print(“Hello World”)
Es ist so, als ob Sie eine andere Sprache lernen würden, sagen wir Mandarin. Es gibt ein System namens Pinyin, das chinesische Schriftzeichen ins Englische umschreibt, damit man sie aussprechen kann. Es ist so konzipiert, dass Sie schnell loslegen können, genau wie eine Hello World-Anwendung.
Schauen wir uns an, wie eine Hallo-Welt-Anwendung in Flask und FastAPI aussieht.
# inside of a Python .py file
from flask import Flask
app = Flask(__name__)
@app.route("/", methods=\[“GET”])
def home():
return {"Hello": "World"}
if __name__ == "__main__":
app.run()
from flask import Flask
app = Flask(__name__)
@app.get("/")
def home():
return {"Hello": "World"}
if __name__ == "__main__":
app.run()
# inside of a Python .py file
import uvicorn
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
def home():
return {"Hello": "World"}
if __name__ == "__main__":
uvicorn.run("main:app")Schlussfolgerung: In den neueren Versionen von Flask können Sie die @app.get() und @app.post() Dekoratoren als Abkürzungen für das Routing verwenden. Die bisherige Art der Verwendung von @app.route() erforderte die Übergabe von HTTP-Verben an eine Methodenliste, etwa so: methods=\[“GET”, “POST”].
Hinweis: Flask verwendet standardmäßig ein
GETstandardmäßig, so dass Sie es nicht in der Methodenliste angeben müssen.
Diese Methoden kommen auch in FastAPI mit Unterstützung für die folgenden dekorierten Routen für jede HTTP-Methode:
@app.get()@app.post()@app.put()@app.delete()
Wenn Sie Ihre "Hello World"-Anwendung geschrieben haben, sollten Sie sie zunächst in der Entwicklungsumgebung - oder lokal auf Ihrem Rechner - ausführen, bevor Sie sie für die ganze Welt in Produktion geben. Wenn Ihre Anwendung nicht wie erwartet funktioniert, werden die Leute mit Sicherheit ausflippen. Sie wollen das Ausrasten so gering wie möglich halten.
Führen Sie also in Ihrem Terminal diese Befehle aus:
$ export FLASK_APP=app.py
$ export FLASK_ENV=development
$ flask run
$ uvicorn main:app --reloadSchlussfolgerung: FastAPI verwendet Hot Reloading, wodurch die Anwendung weiterläuft, während Sie Codeänderungen vornehmen. Daher müssen Sie den Entwicklungsserver nicht ständig neu starten. Bei Flask benötigen Sie einen zusätzlichen Terminalbefehl: export FLASK_ENV=developmentDamit können Sie Codeänderungen vornehmen, ohne Ihren Entwicklungsserver neu zu starten.
Im Hello World-Beispiel haben wir gesehen, wie ein GET in Flask und FastAPI aussieht, also schauen wir uns jetzt eine POST-Methode genauer an.
@app.route("/teams", methods=["POST"])
def create_team():
team = {
"team_name": "Phoenix Suns",
"players": [
{
"name": "Chris Paul",
"age": 36
}
]
}
teams.append(team)
return (jsonify(teams))
@app.post("/teams")
def create_team():
team = {
"team_name": "Phoenix Suns",
"players": [
{
"name": "Chris Paul",
"age": 36
}
]
}
teams.append(team)
return (jsonify(teams))
@app.post("/teams")
def create_team():
team = {
"team_name": "Phoenix Suns",
"players": [
{
"name": "Chris Paul",
"age": 36
}
]
}
teams.append(team)
return {'teams':teams}Schlussfolgerung: Flask 2.0 und FastAPI sehen sich sehr ähnlich, wenn sie eine POST-Methode verwenden. Der Trick ist zu sehen, wie neue Daten erstellt werden.
Mit Flask müssen Sie ein Tool wie Postman verwenden, das als Client fungiert, damit Sie Ihre POST-Anfragen und die von Ihnen erstellten Daten im JSON-Format sehen können.
FastAPI wird standardmäßig mit Pydantic und SwaggerUI ausgeliefert, wodurch Sie eine automatische Dokumentation verwenden können, um mit Ihren Anfragen aus dem Browser zu interagieren, einschließlich POST-Anfragen.
Flask kann auch automatische Dokumentation verwenden, aber Sie müssen sie mit flask-swagger installieren. Außerdem ist eine Menge Konfiguration erforderlich, damit es funktioniert. Im nächsten Abschnitt sehen wir uns an, wie Sie Ihre POST-Anfragen in FastAPI sehen können.
Wenn Sie an Magie glauben, werden Sie die Automatische Dokumentation mit Sicherheit lieben.
FastAPI basiert auf Pydantic, einem Framework zur einfachen Modellierung und Validierung von Objekten. Es ist bereits im Lieferumfang enthalten und muss daher nicht installiert werden. Pydantic nimmt Ihnen die Mühe ab, Konstruktoren zu schreiben, und Sie erhalten alle magischen Methoden. Pydantic führt auch eine Datenvalidierung durch, die freundlichere Fehler anzeigt und Python-Typ-Hinweise verwendet, was die Debugging-Zeit reduziert. Um auf Ihre automatische Dokumentation zuzugreifen, vergewissern Sie sich, dass Ihr Entwicklungsserver läuft, gehen Sie dann zu Ihrem localhost und dem Port, auf dem Ihre Anwendung läuft:
http://127.0.0.1:8000/docsSie werden Ihre POST-Anfrage wie im folgenden Beispiel sehen; wenn Sie andere HTTP-Methoden verwenden, werden diese ebenfalls sichtbar sein.
FastAPI Python automatic documentation POST request using Pydantic
Lassen Sie uns etwas viel Cooleres machen, damit wir die Schönheit der automatischen Dokumentation sehen können. Nehmen wir an, wir haben diesen Code in FastAPI:
from pydantic import BaseModel
app = FastAPI()
class Player(BaseModel):
player_name: str
player_team: str
player_age: int
@app.post("/teams")
def create_team(request: Player):
return {'teams':request}Beachten Sie, dass Sie, um Pydantic zu verwenden, die BaseModel die die Player Klasse erben wird. Wir deklarieren auch Variablen als Typ-Hinweise innerhalb unserer Klasse und geben ein Wörterbuch in unserer POST-Anfrage zurück.
Wenn Sie Ihre automatische Dokumentation aufrufen, sehen Sie ein Schema. Dieses Schema ist ein Grundgerüst für Ihr Modell mit Variablen, in dem Sie sehen können, welche Felder erforderlich und welche optional sind.
FastAPI Python automatic documentation with Pydantic POST request and schema
Sie können es auch "ausprobieren" und Ihren API-Endpunkt testen, indem Sie Werte für die Variablen übergeben. Hier zum Beispiel geben wir in “Michael Jordan” für die Variable player_name vom Typ String.
FastAPI Python automatic documentation with Pydantic POST request and request body
Wenn Sie dann auf Execute klicken, erhalten Sie den Response Body. Es ist nicht nötig, ein zusätzliches Tool wie Postman zu verwenden.
FastAPI Python automatic documentation with Pydantic POST request and response body
Ihre interaktive Dokumentation generiert auch einen curl-Befehl für Sie, so dass Sie ihn nicht von Grund auf neu schreiben müssen:
FastAPI Python automatic documentation with Pydantic POST request and Curl
Schlussfolgerung: Da die automatische Dokumentation zusammen mit Pydantic und Swagger UI bereits im Lieferumfang von FastAPI enthalten ist, werden diese Funktionen Ihre Entwicklungszeit definitiv verkürzen. Sie müssen keine externen Tools installieren, um Ihre Anfragen zu testen.
Da unser lieber Freund Pydantic bei der Installation mit FastAPI ausgeliefert wird, erhalten Sie bei Problemen mit Ihrem Code freundliche Fehlermeldungen.
from pydantic import BaseModel
from typing import Optional
class Login(BaseModel):
username: str
password: str
agree_to_terms: Optional\[bool]
@app.post("/login")
def login(request: Login):
if request.username == "janedoe" and request.password == "password12345":
return {"message": "Success"}
return {"message": "Authentication Failed"}Hier erstellen wir eine Klasse Login, die vom Pydantic BaseModel erbt und in der wir Variablen mit Typ-Hinweisen verwenden. Wir prüfen zunächst, ob die username ist. janedoe und die password ist. passworld12345sind, dann geben wir eine Erfolgs- oder Fehlermeldung zurück.
Wir wenden uns der automatischen Dokumentation zu und testen unseren Request Body durch die Übergabe von None an den Benutzernamen:
FastAPI Python automatic documentation with Pydantic POST request and change request body
Pydantic wird seine Arbeit tun, und Sie erhalten eine freundliche Meldung, die Ihnen genau sagt, wo der Fehler liegt. In diesem Fall gibt es den Fehler Expecting Valuezurück, der genau ins Schwarze trifft, denn wir haben in None an die username.
FastAPI Python automatic documentation with Pydantic error message
Schlussfolgerung: Flask verfügt über keine eigene Unterstützung für die Datenvalidierung. Sie können das leistungsstarke Pydantic-Paket zur Datenvalidierung verwenden, indem Sie es mit Flask-Pydantic.
Mit einem Pfad- oder URL-Parameter wird ein einzelnes Element abgerufen. Nehmen wir an, wir wollen einen einzelnen Spieler abrufen. Derjenige Spieler, der die gleiche Kennung wie die in der URL angegebene hat, wird an den Benutzer zurückgegeben.
Angenommen, wir haben eine Liste von Wörterbüchern und möchten einen Spieler aus dieser JSON-Datei abrufen:
players = [
{
"player_id": 1,
"name": "Giannis"
},
{
"player_id": 2,
"name": "Luka"
}
]
@app.get('/players/<int:player_id>')
def get_player_details(player_id):
for player in players:
if player["player_id"] == player_id:
return jsonify(player)
Hier geben wir unsere Route zu localhost an Port 5000 mit der ID 2 ein und erhalten den Player mit der ID 2 zurück.
Flask Python url or path parameters running on localhost returning JSON as response body
@app.get("/player/{player_id}")
def get_player_details(player_id: int):
for player in players:
if player['player_id'] == player_id:
return {'player':player['name']}Hier geben wir unsere Route an localhost auf Port 8000 mit einer ID von 1 ein und erhalten den Player mit der ID 1 zurück.
FastAPI Python url or path parameters running on localhost returning JSON as response body
Schlussfolgerung: Da FastAPI mit Python Type Hinting arbeitet, können Sie Ihren Code auf andere Frameworks wie Django portieren. Mit Flask ist es nicht portierbar, weil wir Framework-spezifisches Type Hinting verwenden, nicht Python Hinting.
Der Vorlagenordner speichert Ihre HTML-Dateien, wenn Sie eine Webanwendung in Flask oder FastAPI erstellen, und Sie müssen Jinja verwenden, um Ihre Variablen in HTML anzuzeigen. Jinja ist eine Template-Engine, mit der Sie Code ähnlich wie in Python schreiben können, um HTML anzuzeigen.
Standardmäßig sucht Flask nach Vorlagen in einem "templates"-Ordner. Sie müssen nur einen solchen in Ihrer Dateistruktur erstellen.
Flask Python templates folder in file structure to render HTML files
Flask Python templates folder in file structure to render HTML files
Dann können Sie Jinja verwenden, um Ihre Variablen anzuzeigen, indem Sie sie mit doppelten geschweiften Klammern umgeben:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Players</title>
</head>
<body>
<h1>Display Players</h1>
{{ player.name }}
{{ player.jersey_number }}
</body>
</html>
Schlussfolgerung: Jijnja wird bei der Installation von Flask mitgeliefert, was ein großes Plus ist. Bei FastAPI müssen Sie Jinja installieren und den Vorlagenordner in Ihrem Code definieren.
Irgendwann möchten Sie Ihre Anwendung bereitstellen und sie der Welt zeigen.
Flask verwendet einen Webserver namens WSGI, was für Web Server Gateway Interface steht und seit vielen Jahren der Python-Standard ist. Der Nachteil ist, dass es synchron ist. Das heißt, wenn Sie eine Reihe von Anfragen haben, müssen diese in der Warteschlange warten, bis sie abgeschlossen sind.
FastAPI verwendet einen Webserver namens ASGI (Asynchronous Server Gateway Interface), der blitzschnell ist, weil er - Sie ahnen es - asynchron ist. Wenn Sie also eine Reihe von Anfragen erhalten, müssen diese nicht warten, bis die anderen abgeschlossen sind, bevor sie bearbeitet werden.
Schlussfolgerung: ASGI sorgt für eine schnellere Leistung in Ihren Webanwendungen, da sie Anfragen asynchron verarbeiten.
Trommelwirbel, bitte.
Der Gewinner ist... nun, das kommt darauf an.
So können Sie wählen.
Verwendung Flachmann wenn Sie wollen:
Ein kampferprobter Rahmen, da er schon seit langem existiert
Zur Entwicklung eines schnellen Prototyps
Entwicklung von Webanwendungen
Verwenden Sie FastAPI wenn Sie wollen:
Geschwindigkeit, d.h. Entwicklungszeit und Leistung
So verringern Sie die Anzahl der Bugs und Fehler in Ihrem Code
So erstellen Sie APIs von Grund auf
Ok, Sie haben also sowohl Flask als auch FastAPI in Aktion gesehen. Sie haben nun ein besseres Verständnis für beide und wissen nun, welche von beiden für Ihr nächstes Projekt besser geeignet ist.
Für welchen Rahmen haben Sie sich entschieden? Tweeten Sie uns @VonageDev oder @tonyasims.
