Par exemple, vous pouvez créer une `PNGStreamingResponse` qui définit l'en-tête `Content-Type` à `image/png` en utilisant l'attribut `media_type` :

{* ../../docs_src/stream_data/tutorial002_py310.py ln[6,19:20] hl[20] *}

Il existe plusieurs façons de procéder, en fonction de votre cas d'utilisation spécifique et des outils que vous
utilisez.

Vous pouvez **déployer un serveur** vous-même en utilisant une combinaison d'outils, vous pouvez utiliser un **service
cloud** qui fait une partie du travail pour vous, ou encore d'autres options possibles.

aurait pour résultat quelque chose d'équivalent à :

```Python
UserInDB(
    username="john",
    password="secret",
    email="******@****.***",
    full_name=None,
)
```

Ou plus exactement, en utilisant `user_dict` directement, quels que soient ses contenus futurs :

```Python
UserInDB(
    username = user_dict["username"],
    password = user_dict["password"],
    email = user_dict["email"],

{* ../../docs_src/additional_responses/tutorial002_py310.py hl[17:22,26] *}

/// note | Remarque

Notez que vous devez retourner l'image en utilisant directement un `FileResponse`.

///

/// info

Mais un fichier dotenv n'a pas forcément exactement ce nom de fichier.

///

Pydantic prend en charge la lecture depuis ce type de fichiers en utilisant une bibliothèque externe. Vous pouvez en lire davantage ici : [Pydantic Settings : prise en charge de Dotenv (.env)](https://docs.pydantic.dev/latest/concepts/pydantic_settings/#dotenv-env-support).

/// tip | Astuce

    * Ceci sera utilisé par la **documentation automatique**.
    * Ceci sera également utilisé par les outils de génération automatique de code client.
* **Sérialiser** les données renvoyées en JSON en utilisant Pydantic, qui est écrit en **Rust**, ce qui sera **beaucoup plus rapide**.

Mais surtout :

* Il **limitera et filtrera** les données de sortie à ce qui est défini dans le type de retour.

{* ../../docs_src/body/tutorial001_py310.py hl[16] *}

... et déclarez que son type est le modèle que vous avez créé : `Item`.

## Résultats { #results }

En utilisant uniquement les déclarations de type Python, **FastAPI** réussit à :

* Lire le contenu de la requête en tant que JSON.
* Convertir les types correspondants (si nécessaire).
* Valider la donnée.

* `list`
* `tuple`
* `set`
* `dict`

#### Liste { #list }

Par exemple, définissons une variable comme une `list` de `str`.

Déclarez la variable, en utilisant la même syntaxe avec deux-points (`:`).

Comme type, mettez `list`.

Comme la liste est un type qui contient des types internes, mettez-les entre crochets :

### `Query` comme valeur par défaut ou dans `Annotated` { #query-as-the-default-value-or-in-annotated }

Gardez à l’esprit qu’en utilisant `Query` à l’intérieur de `Annotated`, vous ne pouvez pas utiliser le paramètre `default` de `Query`.

Utilisez à la place la valeur par défaut réelle du paramètre de fonction. Sinon, ce serait incohérent.

* validation des données
* sérialisation des données
* documentation des données, etc.

Cela fonctionne de la même manière qu'avec les modèles Pydantic. Et, en réalité, c'est mis en œuvre de la même façon en interne, en utilisant Pydantic.

/// info

Gardez à l'esprit que les dataclasses ne peuvent pas tout ce que peuvent faire les modèles Pydantic.

Vous pourriez donc avoir encore besoin d'utiliser des modèles Pydantic.