Verwendung von Datenklassen

FastAPI basiert auf Pydantic und ich habe Ihnen gezeigt, wie Sie Pydantic-Modelle verwenden können, um Requests und Responses zu deklarieren.

Aber FastAPI unterstützt auf die gleiche Weise auch die Verwendung von dataclasses:

from dataclasses import dataclass
from typing import Union

from fastapi import FastAPI


@dataclass
class Item:
    name: str
    price: float
    description: Union[str, None] = None
    tax: Union[float, None] = None


app = FastAPI()


@app.post("/items/")
async def create_item(item: Item):
    return item

Das ist dank Pydantic ebenfalls möglich, da es dataclasses intern unterstützt.

Auch wenn im obige Code Pydantic nicht explizit vorkommt, verwendet FastAPI Pydantic, um diese Standard-Datenklassen in Pydantics eigene Variante von Datenklassen zu konvertieren.

Und natürlich wird das gleiche unterstützt:

• Validierung der Daten
• Serialisierung der Daten
• Dokumentation der Daten, usw.

Das funktioniert genauso wie mit Pydantic-Modellen. Und tatsächlich wird es unter der Haube mittels Pydantic auf die gleiche Weise bewerkstelligt.

Info

Bedenken Sie, dass Datenklassen nicht alles können, was Pydantic-Modelle können.

Daher müssen Sie möglicherweise weiterhin Pydantic-Modelle verwenden.

Wenn Sie jedoch eine Menge Datenklassen herumliegen haben, ist dies ein guter Trick, um sie für eine Web-API mithilfe von FastAPI zu verwenden. 🤓

Datenklassen als response_model

Sie können dataclasses auch im Parameter response_model verwenden:

from dataclasses import dataclass, field
from typing import List, Union

from fastapi import FastAPI


@dataclass
class Item:
    name: str
    price: float
    tags: List[str] = field(default_factory=list)
    description: Union[str, None] = None
    tax: Union[float, None] = None


app = FastAPI()


@app.get("/items/next", response_model=Item)
async def read_next_item():
    return {
        "name": "Island In The Moon",
        "price": 12.99,
        "description": "A place to be playin' and havin' fun",
        "tags": ["breater"],
    }

Die Datenklasse wird automatisch in eine Pydantic-Datenklasse konvertiert.

Auf diese Weise wird deren Schema in der Benutzeroberfläche der API-Dokumentation angezeigt:

Datenklassen in verschachtelten Datenstrukturen

Sie können dataclasses auch mit anderen Typannotationen kombinieren, um verschachtelte Datenstrukturen zu erstellen.

In einigen Fällen müssen Sie möglicherweise immer noch Pydantics Version von dataclasses verwenden. Zum Beispiel, wenn Sie Fehler in der automatisch generierten API-Dokumentation haben.

In diesem Fall können Sie einfach die Standard-dataclasses durch pydantic.dataclasses ersetzen, was einen direkten Ersatz darstellt:

from dataclasses import field  # (1)
from typing import List, Union

from fastapi import FastAPI
from pydantic.dataclasses import dataclass  # (2)


@dataclass
class Item:
    name: str
    description: Union[str, None] = None


@dataclass
class Author:
    name: str
    items: List[Item] = field(default_factory=list)  # (3)


app = FastAPI()


@app.post("/authors/{author_id}/items/", response_model=Author)  # (4)
async def create_author_items(author_id: str, items: List[Item]):  # (5)
    return {"name": author_id, "items": items}  # (6)


@app.get("/authors/", response_model=List[Author])  # (7)
def get_authors():  # (8)
    return [  # (9)
        {
            "name": "Breaters",
            "items": [
                {
                    "name": "Island In The Moon",
                    "description": "A place to be playin' and havin' fun",
                },
                {"name": "Holy Buddies"},
            ],
        },
        {
            "name": "System of an Up",
            "items": [
                {
                    "name": "Salt",
                    "description": "The kombucha mushroom people's favorite",
                },
                {"name": "Pad Thai"},
                {
                    "name": "Lonely Night",
                    "description": "The mostests lonliest nightiest of allest",
                },
            ],
        },
    ]

1. Wir importieren field weiterhin von Standard-dataclasses.

2. pydantic.dataclasses ist ein direkter Ersatz für dataclasses.

3. Die Datenklasse Author enthält eine Liste von Item-Datenklassen.

4. Die Datenklasse Author wird im response_model-Parameter verwendet.

5. Sie können andere Standard-Typannotationen mit Datenklassen als Requestbody verwenden.

   In diesem Fall handelt es sich um eine Liste von Item-Datenklassen.

6. Hier geben wir ein Dictionary zurück, das items enthält, welches eine Liste von Datenklassen ist.

   FastAPI ist weiterhin in der Lage, die Daten nach JSON zu serialisieren.

7. Hier verwendet das response_model als Typannotation eine Liste von Author-Datenklassen.

   Auch hier können Sie dataclasses mit Standard-Typannotationen kombinieren.

8. Beachten Sie, dass diese Pfadoperation-Funktion reguläres def anstelle von async def verwendet.

   Wie immer können Sie in FastAPI def und async def beliebig kombinieren.

   Wenn Sie eine Auffrischung darüber benötigen, wann welche Anwendung sinnvoll ist, lesen Sie den Abschnitt „In Eile?“ in der Dokumentation zu async und await.

9. Diese Pfadoperation-Funktion gibt keine Datenklassen zurück (obwohl dies möglich wäre), sondern eine Liste von Dictionarys mit internen Daten.

   FastAPI verwendet den Parameter response_model (der Datenklassen enthält), um die Response zu konvertieren.

Sie können dataclasses mit anderen Typannotationen auf vielfältige Weise kombinieren, um komplexe Datenstrukturen zu bilden.

Weitere Einzelheiten finden Sie in den Bemerkungen im Quellcode oben.

Mehr erfahren

Sie können dataclasses auch mit anderen Pydantic-Modellen kombinieren, von ihnen erben, sie in Ihre eigenen Modelle einbinden, usw.

Weitere Informationen finden Sie in der Pydantic-Dokumentation zu Datenklassen.

Version

Dies ist verfügbar seit FastAPI-Version 0.67.0. 🔖