Teil: Erstellen einer Todo-API mit FastAPI: Schritt-für-Schritt-Anleitung

Erstellen einer Todo-API mit FastAPI: Schritt-für-Schritt-Anleitung

Code finden Sie hier: GitHub – jamesbmour/blog_tutorials:

I. Einleitung

Im vorherigen Beitrag haben wir FastAPI vorgestellt und eine grundlegende Projektstruktur eingerichtet. Jetzt gehen wir noch einen Schritt weiter und erstellen eine funktionale Todo-API. Am Ende dieses Tutorials verfügen Sie über ein funktionierendes Backend, das Aufgabenelemente erstellen, lesen, aktualisieren und löschen kann.

Was wir abdecken werden:

• Entwerfen des Todo-Datenmodells
• CRUD-Operationen implementieren
• API-Endpunkte erstellen
• Eingabevalidierung und Fehlerbehandlung hinzufügen
• Testen der API
• Code umgestalten und organisieren

II. Entwerfen des Todo-Datenmodells

Um Aufgaben zu verwalten, müssen wir ein Datenmodell definieren, das einen Aufgabeneintrag darstellt. FastAPI verwendet Pydantic-Modelle zum Validieren und Analysieren von Daten, daher werden wir dies hier nutzen.

A. Definieren des Todo-Schemas

Wir erstellen zwei Modelle mit Pydantic:

• TodoCreate: Für Eingabedaten beim Erstellen oder Aktualisieren einer Todo.
• Todo: Für den vollständigen ToDo-Eintrag, einschließlich Feldern wie „id“ und „created_at“.

from pydantic import BaseModel
from typing import Optional
from datetime import datetime

class TodoCreate(BaseModel):
    title: str
    description: Optional[str] = None
    completed: bool = False

class Todo(BaseModel):
    id: str
    title: str
    description: Optional[str] = None
    completed: bool
    created_at: datetime

B. Erklären der Felder

• id: Eindeutige Kennung für jede Aufgabe.
• Titel: Hauptinhalt der Aufgabe.
• Beschreibung: Zusätzliche Details (optional).
• abgeschlossen: Boolescher Status der Aufgabe (ob sie erledigt ist oder nicht).
• created_at: Zeitstempel, der angibt, wann die Aufgabe erstellt wurde.

III. Erstellen von CRUD-Operationen für Todos

CRUD steht für „Create“, „Read“, „Update“ und „Delete“ – die vier grundlegenden Vorgänge zur Datenverwaltung. Für dieses Tutorial implementieren wir diese Vorgänge mithilfe einer In-Memory-Datenbank (einer einfachen Liste).

A. Einrichten einer In-Memory-Datenbank

Wir verwenden eine Liste, um unsere Aufgaben zu speichern. Der Einfachheit halber fügen wir auch ein paar Beispiel-Todos hinzu.

from uuid import uuid4
from datetime import datetime

todos = [
    {
        "id": str(uuid4()),
        "title": "Learn FastAPI",
        "description": "Go through the official FastAPI documentation and tutorials.",
        "completed": False,
        "created_at": datetime.now(),
    },
    {
        "id": str(uuid4()),
        "title": "Build a Todo API",
        "description": "Create a REST API for managing todo items using FastAPI.",
        "completed": False,
        "created_at": datetime.now(),
    },
    {
        "id": str(uuid4()),
        "title": "Write blog post",
        "description": "Draft a blog post about creating a Todo API with FastAPI.",
        "completed": False,
        "created_at": datetime.now(),
    },
]

B. Implementieren von Hilfsfunktionen

Wir implementieren eine einfache Hilfsfunktion, um eine Aufgabe anhand ihrer ID zu finden.

def get_todo_by_id(todo_id: str):
    for todo in todos:
        if todo["id"] == todo_id:
            return todo
    return None

IV. API-Endpunkte implementieren

A. Erstellen eines neuen Todo

Der POST-Endpunkt ermöglicht Benutzern das Erstellen eines neuen Aufgabenelements.

@app.post("/todos/", response_model=Todo)
def create_todo(todo: TodoCreate):
    new_todo = Todo(
        id=str(uuid4()),
        title=todo.title,
        description=todo.description,
        completed=todo.completed,
        created_at=datetime.now()
    )
    todos.append(new_todo.dict())
    return new_todo

B. Alle Todos abrufen

Der GET-Endpunkt ruft alle Aufgaben aus unserer In-Memory-Datenbank ab.

@app.get("/todos/", response_model=List[Todo])
def get_all_todos():
    return todos

C. Abrufen eines einzelnen Todo

Der GET-Endpunkt ermöglicht das Abrufen einer einzelnen Aufgabe anhand ihrer ID.

@app.get("/todos/{todo_id}", response_model=Todo)
def get_todo(todo_id: str):
    todo = get_todo_by_id(todo_id)
    if not todo:
        raise HTTPException(status_code=404, detail="Todo not found")
    return todo

D. Aktualisieren eines Todo

Der PUT-Endpunkt ermöglicht es Benutzern, eine vorhandene Aufgabe zu aktualisieren.

@app.put("/todos/{todo_id}", response_model=Todo)
def update_todo(todo_id: str, todo_data: TodoCreate):
    todo = get_todo_by_id(todo_id)
    if not todo:
        raise HTTPException(status_code=404, detail="Todo not found")
    todo["title"] = todo_data.title
    todo["description"] = todo_data.description
    todo["completed"] = todo_data.completed
    return Todo(**todo)

E. Löschen eines Todo

Der DELETE-Endpunkt ermöglicht Benutzern das Löschen einer Aufgabe anhand ihrer ID.

@app.delete("/todos/{todo_id}")
def delete_todo(todo_id: str):
    todo = get_todo_by_id(todo_id)
    if not todo:
        raise HTTPException(status_code=404, detail="Todo not found")
    todos.remove(todo)
    return {"detail": "Todo deleted successfully"}

V. Eingabevalidierung und Fehlerbehandlung hinzufügen

A. Eingabevalidierung mit Pydantic

FastAPI validiert Eingabedaten automatisch anhand der von uns definierten Pydantic-Modelle. Dadurch wird sichergestellt, dass die Daten unserem erwarteten Schema entsprechen, bevor sie verarbeitet werden.

B. Benutzerdefinierte Fehlerbehandlung

Wir können Fehlerreaktionen anpassen, indem wir einen Ausnahmehandler hinzufügen.

@app.exception_handler(HTTPException)
def http_exception_handler(request, exc: HTTPException):
    return JSONResponse(
        status_code=exc.status_code,
        content={"detail": exc.detail},
    )

VI. Testen der API

FastAPI verfügt über eine interaktive Swagger-UI-Dokumentation, die das Testen Ihrer API-Endpunkte erleichtert. Führen Sie einfach die Anwendung aus und navigieren Sie in Ihrem Browser zu /docs.

Testbeispiel

• Eine Todo erstellen: Testen Sie den POST-Endpunkt, indem Sie eine neue Todo erstellen.
• Aufgaben abrufen: Verwenden Sie die GET-Endpunkte, um alle Aufgaben oder eine bestimmte Aufgabe nach ID abzurufen.
• Aktualisieren und löschen: Testen Sie die PUT- und DELETE-Endpunkte, um eine Aufgabe zu aktualisieren oder zu entfernen.

VII. Code umgestalten und organisieren

Wenn die Anwendung wächst, ist es wichtig, den Code organisiert zu halten. Hier ein paar Tipps:

A. Modelle in eine separate Datei verschieben

Sie können Ihre Pydantic-Modelle in eine models.py-Datei verschieben, um Ihre Hauptanwendungsdatei sauber zu halten.

B. Erstellen eines Routers für Todo-Endpunkte

Erwägen Sie die Erstellung eines separaten Routers für todo-bezogene Endpunkte, insbesondere wenn Ihre API wächst.

VIII. Nächste Schritte

Im nächsten Beitrag integrieren wir eine echte Datenbank (wie SQLite oder PostgreSQL) in unsere FastAPI-Anwendung. Wir werden uns auch mit der Benutzerauthentifizierung und erweiterten Funktionen befassen.

Vorgeschlagene Verbesserungen:

• Fügen Sie Filterung und Paginierung zu den GET-Endpunkten hinzu.
• Implementieren Sie die Benutzerauthentifizierung, um persönliche Aufgaben zu verwalten.

IX. Abschluss

In diesem Tutorial haben wir eine einfache Todo-API mit FastAPI erstellt. Wir begannen mit dem Entwurf eines Datenmodells, implementierten CRUD-Operationen und erstellten Endpunkte zur Verwaltung von Aufgaben. Wir haben auch die Eingabevalidierung, Fehlerbehandlung und Tests angesprochen. Auf dieser Grundlage können Sie die API weiter erweitern oder in ein Frontend integrieren, um eine vollwertige Anwendung zu erstellen.

Wenn Sie mein Schreiben unterstützen oder mir ein Bier spendieren möchten:
https://buymeacoffee.com/bmours

Das obige ist der detaillierte Inhalt vonTeil: Erstellen einer Todo-API mit FastAPI: Schritt-für-Schritt-Anleitung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!