Erste FastAPI-Anwendung
In diesem Abschnitt wird anhand eines vollständigen Beispiels erläutert, wie Sie eine FastAPI-Anwendung von Grund auf erstellen und verstehen, was jede Codezeile bedeutet.
Minimale Anwendung
Erstellen Sie eine Datei namensmain.pyund fügen Sie den folgenden Code hinzu:
Beispiel
# Schritt 1: FastAPI-Klasse importieren
# Schritt 2: Anwendungsinstanz erstellen
app = FastAPI()
# Schritt 3: Pfadoperations-Dekorator definieren
# Schritt 4: Pfadoperationsfunktion definieren
@app.get("/")
async def root():
# Schritt 5: Antwortinhalt zurückgeben
return {"message": "Hello World"}
Anwendung starten:
$ uvicorn main:app --reload
Besuchen Siehttp://127.0.0.1:8000, gibt zurück:
{"message": "Hello World"}
Code-Aufschlüsselung
1. FastAPI importieren
from fastapi import FastAPI
FastAPIEs ist eine Python-Klasse, die die gesamte Kernfunktionalität für Ihre API bereitstellt. Sie erbt direkt von Starlette, sodass Sie auch alle Funktionen von Starlette nutzen können.
2. App-Instanz erstellen
app = FastAPI()
eine FastAPI-Instanz erstellen, typischerweise mit dem Variablennamenapp. Diese Instanz ist das Hauptinteraktionsobjekt zum Erstellen aller APIs. Im Gegensatz zu Flask muss bei FastAPI nicht übergeben werden__name__Parameter.
3. Den Pfadoperations-Decorator definieren
@app.get("/")
Diese Codezeile teilt FastAPI mit: Wenn ein Benutzer über dieGET-Methode auf den Root-Pfad/zugreift, wird die folgende Funktion ausgeführt.
Dabei geht es um zwei Konzepte:
| Konzepte | Beschreibung | Beispiel |
|---|---|---|
| Pfad | vom ersten ... in der URL/der hintere Teil des Pfads, auch bekannt als "Endpunkt" oder "Route" | /items/foo |
| Aktion | HTTP-Methoden entsprechen unterschiedlichen operationalen Semantiken | GET、POST、PUT、DELETE |
FastAPI unterstützt Decorators für alle HTTP-Methoden:
| Dekorator | HTTP-Methoden | Übliche Verwendungen |
|---|---|---|
@app.get() | GET | Daten abrufen/lesen |
@app.post() | POST | Neue Daten erstellen |
@app.put() | PUT | Daten vollständig aktualisieren |
@app.patch() | PATCH | Daten teilweise aktualisieren |
@app.delete() | DELETE | Daten löschen |
4. Definieren Sie die Pfadoperation-Funktion
async def root():
Dies ist die Pfadoperation-Funktion; wann immer FastAPIGET /eine Anfrage empfängt, ruft es die Funktion auf. Sie können die Funktion beliebig benennen, aber es wird empfohlen, einen aussagekräftigen Namen zu wählen.
Sie könnenasync defoder normalesdefum die Funktion zu definieren. FastAPI behandelt den Unterschied zwischen beiden automatisch. Wenn Sie mit asynchroner Programmierung nicht vertraut sind, verwenden Sie normalesdefund das ist in Ordnung; spätere Kapitel werden async im Detail behandeln.
5. Antwortinhalt zurückgeben
return {"message": "Hello World"}
Die Funktion gibt ein Dictionary zurück, und FastAPI konvertiert es automatisch in eine JSON-Antwort. Sie können zurückgebendict、list、str、intsolche Typen, und FastAPI übernimmt die JSON-Konvertierung automatisch.
Weitere Routen hinzufügen
Als Nächstes fügen wir Pfadparameter und Query-Parameter hinzu, um die Funktionalität der Anwendung zu erweitern:
Beispiel
app = FastAPI()
@app.get("/")
async def root():
"""Root-Pfad, gibt Willkommensnachricht zurück"""
return {"message": "Hello World"}
@app.get("/items/{item_id}")
async def read_item(item_id: int, q: str | None = None):
"""Ein Element anhand der ID abrufen, mit optionalem Query-Parameter q"""
return {"item_id": item_id, "q": q}
Parameterbeschreibung für die neu hinzugefügte Route:
| Parameter | Type | Source | Beschreibung |
|---|---|---|---|
item_id | int | Pfadparameter | aus dem URL-Pfad entnommen; FastAPI konvertiert die Zeichenkette automatisch in eine Ganzzahl |
q | str | None | Query-Parameter | Aus der URL?q=xxxaus einem Teil abgerufen, mit einem Standardwert vonNone, was optional bedeutet |
Zugriffstest:
# 访问根路径
GET http://127.0.0.1:8000/
响应: {"message": "Hello World"}
# 访问带路径参数的路由
GET http://127.0.0.1:8000/items/5
响应: {"item_id": 5, "q": null}
# 同时传递路径参数和查询参数
GET http://127.0.0.1:8000/items/5?q=example
响应: {"item_id": 5, "q": "example"}
Hinweisitem_idDer Wert ist eine Ganzzahl5Statt einer Zeichenkette"5"Dies ist FastAPIs Datenkonvertierungsfunktion basierend auf Typdeklarationen. Wenn eine Nicht-Ganzzahl übergeben wird (z. B.,/items/foo), gibt FastAPI eine klare Validierungsfehlermeldung zurück.
Eine POST-Anfrage hinzufügen
Im Folgenden fügen wir eine POST-Route hinzu, die einen Request-Body verwendet:
Beispiel
from pydantic import BaseModel
app = FastAPI()
# Das Datenmodell für den Request-Body definieren
class Item(BaseModel):
name: str # Erforderlich: Produktname
description: str | None = None # Optional: Produktbeschreibung
price: float # Erforderlich: Produktpreis
tax: float | None = None # Optional: Steuer
@app.post("/items/")
async def create_item(item: Item):
"""Erstellt ein neues Produkt, akzeptiert einen JSON-Request-Body."""
return item
@app.put("/items/{item_id}")
async def update_item(item_id: int, item: Item):
"""Aktualisiert das angegebene Produkt unter Verwendung sowohl von Pfadparametern als auch des Request-Bodys"""
return {"item_id": item_id, "item_name": item.name}
Hier verwenden wir PydanticsBaseModelum die Struktur des Request-Bodys zu definieren. FastAPI wird automatisch:
- die JSON-Daten aus der Anfrage parsen in
ItemObjekt - Datentypen und erforderliche Felder validieren
- die Struktur des Request-Bodys in der API-Dokumentation anzeigen
Pydantic ist eine Kernabhängigkeit von FastAPI und wird für Datenvalidierung und Serialisierung verwendet. In späteren Kapiteln wird seine Verwendung ausführlich behandelt.
FastAPI-Regeln zur Parametererkennung
FastAPI identifiziert Parameterquellen automatisch anhand der folgenden Regeln:
| Parameterquelle | Erkennungsbedingung | Beispiel |
|---|---|---|
| Pfadparameter | Der Parametername erscheint im Routenpfad{}Mittel | item_idIn/items/{item_id}Mittel |
| Query-Parameter | Der Parameter ist ein einzelner Typ (int、str、boolusw.) | q: str | None = None |
| Request-Body | der Parametertyp ist ein Pydantic-Modell | item: Item |
Sie können diese drei Arten von Parametern in derselben Funktion mischen, und FastAPI holt die Daten automatisch vom richtigen Ort.
Zusammenfassung
Zentrale Schritte zum Erstellen einer FastAPI-Anwendung:
- Importieren
FastAPI - App-Instanz erstellen
app = FastAPI() - Verwenden von Dekoratoren (wie z. B.
@app.get()) zum Definieren von Pfadoperationen - Pfadoperationsfunktionen definieren und Parameter mithilfe von Typannotationen deklarieren.
- Nutzung
uvicorn main:app --reloadEntwicklungsserver ausführen