Wir starten mit den wichtigsten Features und typischen Anwendungsfällen von FastAPI. Danach führen wir unsere erste Anwendung aus und probieren sie aus! Zum Schluss lernen wir im Detail, wie GET- und POST-Operationen mit Request-Parametern unterstützt werden, und entwickeln und testen diese Endpunkte.

Warum FastAPI?

Erste Anwendung

FastAPI vs. Django

GET-Operationen

Hello World

Hallo, wer?

POST-Operationen

Pydantic-Modell

POST-Operation in Aktion

FastAPI-Grundlagen

Zunächst lernst du, wie du mit FastAPI PUT- und DELETE-Operationen unterstützt. Dann sehen wir uns an, wie verschiedene Fehlerarten behandelt werden und wie du in der Response stets einen passenden Statuscode zurückgibst. Abschließend lernst du, wie du mit async gleichzeitige Anfragen ermöglichst, die höhere Lasten bewältigen können.

PUT- und DELETE-Operationen

from fastapi import FastAPI
from pydantic import BaseModel

# Define model Item
class Item(BaseModel):
    ____: str
    ____: str

# Define items at application start
items = {"bananas": "Yellow fruit."}

app = FastAPI()


@app.put("/items")
def update_item(item: Item):
    name = item.name
    # Update the description
    items[____] = item.____
    return item

from fastapi import FastAPI
from pydantic import BaseModel

# Define model Item
class Item(BaseModel):
    name: str
    description: str

# Define items at application startup
items = {"bananas": "Yellow fruit."}

app = FastAPI()


@app.put("/items")
def update_item(item: Item):
    name = item.name
    # Update the description
    items[name] = item.description
    return item

PUT-Operation in Aktion

from fastapi import FastAPI
from pydantic import BaseModel

# Define model Item
class Item(BaseModel):
    ____: str

# Define items at application start
items = {"apples", "oranges", "bananas"}

app = FastAPI()


@app.delete("/items")
def delete_item(item: Item):
    name = item.name
    # Delete the item
    items.remove(____)
    return {}

from fastapi import FastAPI
from pydantic import BaseModel

# Define model Item
class Item(BaseModel):
    name: str

# Define items at application startup
items = {"apples", "oranges", "bananas"}

app = FastAPI()


@app.delete("/items")
def delete_item(item: Item):
    name = item.name
    # Delete the item
    items.remove(name)
    return {}

DELETE-Operation in Aktion

Fehler behandeln

Optionen

Erfolg

Kein Erfolg

Klassifikation von Statuscodes

from fastapi import FastAPI, ____
from pydantic import BaseModel

# Define model Item
class Item(BaseModel):
    name: str

# Define items at application startup
items = {"apples", "oranges"}

app = FastAPI()


@app.delete("/items")
def delete_item(item: Item):
    name = item.name
    if name in items:
        items.remove(name)
    else:
        # Raise HTTPException with status code for "not found"
        raise ____(status_code=____, detail="Item not found.")
    return {}

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel

# Define model Item
class Item(BaseModel):
    name: str

# Define items at application startup
items = {"apples", "oranges"}

app = FastAPI()


@app.delete("/items")
def delete_item(item: Item):
    name = item.name
    if name in items:
        items.remove(name)
    else:
        # Raise HTTPException with status code for "not found"
        raise HTTPException(status_code=404, detail="Item not found.")
    return {}

Einen Client-Fehler behandeln

Async für gleichzeitige Aufgaben nutzen

Wann sollten wir async verwenden?

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel

# Define model Item
class Item(BaseModel):
    name: str

app = FastAPI()

items = {"rock", "paper", "scissors"}


@app.delete("/items")
# Make asynchronous
____ def root(item: Item):
    name = item.name
    # Check if name is in items
    if ____ not in ____:
        # Return the status code for not found
        raise HTTPException(status_code=___, detail="Item not found.")
    items.remove(name)
    return {"message": "Item deleted"}

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel

# Define model Item
class Item(BaseModel):
    name: str

app = FastAPI()

items = {"rock", "paper", "scissors"}


@app.delete("/items")
# Make asynchronous
async def root(item: Item):
    name = item.name
    # Check if name is in items
    if name not in items:
        # Return the status code for not found
        raise HTTPException(status_code=404, detail="Item not found.")
    items.remove(name)
    return {"message": "Item deleted"}

Asynchrone DELETE-Operation

Fortgeschrittene Themen in FastAPI

Wir beginnen damit, Systemtests zu schreiben, um einzelne FastAPI-Endpunkte zu validieren. Als Nächstes bauen wir eine vollständige JSON-CRUD-API, um Objektlebenszyklen über HTTP zu verwalten. Schließlich lernst du, wie du unterschiedliche Anwendungsschnittstellen im Zusammenspiel mit manuellen Funktionstests prüfst.

Automatisierte Tests mit FastAPI

Unit-Tests vs. Systemtests

Systemtest

Eine JSON-CRUD-API erstellen

HTTP-Operationen & CRUD-Schritte

Antwort auf eine DELETE-Operation

Vollständige JSON-CRUD-API

Einen manuellen Funktionstest schreiben

Systemtests vs. Funktionstests

Funktionaler Test

Abschluss

Erstellen und Testen einer JSON-CRUD-API

In diesem Kurs lernst du, produktionsreife Webanwendungen mit FastAPI zu entwickeln, einem beliebten Python-Framework für das Erstellen von APIs. Du lernst, alle vier HTTP-Operationen zu bedienen, Request- und Response-Schemas zu definieren, API-Anfragen zu validieren und passende HTTP-Statuscodes zurückzugeben. Außerdem behandelst du asynchrone Codeausführung zur Leistungssteigerung. Am Ende entwickelst du eine CRUD-API und testest Workflows mit dem Python-Modul requests. Der Kurs richtet sich an erfahrene Python-Programmierer und vermittelt dir die Fähigkeiten, Daten mit FastAPI zu verwalten – eine ideale Vorbereitung, um robuste Datenmanagement- und ML-Modell-Serving-Pipelines aufzubauen.

<h2>Einführung in FastAPI und seine Anwendungen</h2> APIs sind echt beliebt, um Daten im Web zu verwalten, und FastAPI ist ein angesagtes neues Web-Framework, um APIs mit Python zu erstellen. Daten- und Machine-Learning-Ingenieure nutzen FastAPI, um Anwendungen zu entwickeln, die als kontextbezogene Datentransaktionen und Pipelines im Web dienen.<br><br> <h2>Entwicklung produktionsreifer Webanwendungen mit FastAPI</h2> In diesem Kurs lernst du, wie du mit deinen Python-Kenntnissen und dem FastAPI-Framework Webanwendungen für den produktiven Einsatz entwickelst. Am Ende wirst du die wichtigsten Anwendungsfälle für FastAPI im Vergleich zu anderen Python-Webframeworks verstehen. Du lernst, APIs mit allen vier Arten von HTTP-Operationen zu erstellen und Anfrage- und Antwortschemata zu definieren. Außerdem checkst du API-Anfragen, antwortest mit den richtigen HTTP-Statuscodes und -Meldungen und führst Code asynchron aus, um die Leistung der Anwendung zu verbessern. Ein praktisches Projekt zeigt dir, wie du eine klassische CRUD-API (Create, Read, Update, Delete) aufbaust und Workflows mit dem Python-Modul „requests“ testest.<br><br> <h2>Kursziele und Zielgruppe</h2> Dieser Kurs ist für Leute gedacht, die schon Python programmieren können und Web-Apps entwickeln wollen, die Daten mit FastAPI verwalten. Nach dem Abschluss dieses Kurses hast du die nötigen Grundlagen, um FastAPI-Projekte zu erstellen, die für die Datenverwaltung mit hohem Durchsatz und ML-Modell-Serving-Pipelines geeignet sind.

Introduction to APIs in Python

Introduction to Object-Oriented Programming in Python

Erstellen Sie robuste APIs mit FastAPI, beherrschen Sie HTTP, Validierung und asynchrone Ausführung.

Einführung in FastAPI

In diesem Kurs entwickelst du mit FastAPI robuste, produktionsreife APIs und lernst, effiziente Daten- und ML-Pipelines zu erstellen.


Klassifikation von Statuscodes

Interaktive praktische Übung