[PYTHON] Paramètres de requête FastAPI Tutorial Memo Part 3

introduction

FastAPI Souce: https://github.com/tiangolo/fastapi FastAPI Document: https://fastapi.tiangolo.com

Cible: Paramètres de requête

Notes pour le didacticiel FastAPI. En gros, je me réfère au tutoriel officiel de Fast API, mais j'oublie certaines parties ou change l'ordre de mon propre apprentissage. Veuillez vous référer à la documentation officielle pour les informations correctes et détaillées.

Étant donné que je suis un débutant en Web et Python et que je compte sur Google et DeepL pour la traduction, j'apprécierais que vous puissiez signaler les erreurs.

Cliquez ici pour les notes précédentes

Environnement de développement

Ubuntu 20.04 LTS Python 3.8.2 pipenv 2018.11.26

Cible

procédure

Intro La dernière fois (FastAPI Tutorial Note # 2 Path Parameters), vous avez appris à transmettre ** Path Parameters ** en tant que paramètres de fonction. Cette fois, j'aimerais savoir comment transmettre les ** paramètres de requête **.

Dans FastAPI, si vous déclarez un paramètre qui n'est pas un paramètre Path en tant qu'argument de fonction, il sera automatiquement interprété comme un ** paramètre de requête **. Vérifiez le code ci-dessous.

main.py


from fastapi import FastAPI

app = FastAPI()

fake_items_db = [{"item_name": "Foo"}, {"item_name": "Bar"}, {"item_name": "Baz"}]


@app.get("/items/")
async def read_item(skip: int = 0, limit: int = 10):    # <-Le paramètre Query est spécifié.
    return fake_items_db[skip : skip + limit]

Dans les URI HTTP, les ** requêtes ** sont essentiellement exprimées en connectant les paires «clé» et «valeur» qui suivent «?» Avec «=». Si vous en spécifiez plusieurs, séparez les URI par &. Si vous souhaitez faire correspondre le code ci-dessus, par exemple, l'URL suivante est supposée:

http://127.0.0.1:8000/items/?skip=0&limit=10

Le ** paramètre de requête ** dans ce cas est

--skip avec une valeur de 0 --limit avec une valeur de 10

Sont passés à la fonction.

Comme ils font partie de l'URL, ils doivent normalement être interprétés comme des chaînes (str). Cependant, dans le code ci-dessus, lors de la spécification d'un paramètre en tant qu'argument, il est déclaré avec le type Python de type ʻint, donc le paramètre est converti et vérifié dans le type ʻint.

Cela signifie que les avantages suivants appliqués avec le ** paramètre Path ** s'appliquent également au ** paramètre Query **.

Ces avantages sont pris en charge non seulement par Path et Query, mais également par divers paramètres gérés par Fast API.

Par défaut

Le ** paramètre de requête ** n'est pas fixé par le chemin de l'URI, mais est un paramètre facultatif, il est donc possible de spécifier une valeur par défaut.

Dans le code ci-dessus, vous pouvez voir que skip = 0 et limit = 10 sont spécifiés comme valeurs par défaut. Par conséquent, une telle URL:

http://127.0.0.1:8000/items/

Lors de l'accès à partir d'un navigateur

http://127.0.0.1:8000/items/?skip=0&limit=10

Les deux URL ci-dessus ont la même sortie.

Aussi, par exemple, l'URL suivante:

http://127.0.0.1:8000/items/?skip=20

Si vous accédez à, les paramètres de la fonction seront:

--skip = 20 défini dans l'URL --Valeur par défaut limit = 10

Optional parameters Il est également possible de déclarer des ** paramètres de requête ** qui peuvent être utilisés comme options en définissant la valeur par défaut sur «Aucun». A titre d'exemple, vérifiez le code ci-dessous.

main.py


from typing import Optional     #Importation facultative à partir du package de saisie

from fastapi import FastAPI

app = FastAPI()


@app.get("/items/{item_id}")
async def read_item(item_id: str, q: Optional[str] = None):     #Paramètre de requête"q"Est déclaré comme paramètre facultatif
    if q:
        return {"item_id": item_id, "q": q}
    return {"item_id": item_id}

Dans ce cas, le paramètre de fonction «q» est traité comme une option et est traité comme «Aucun» par défaut.

Notez que l'API Fast comprend que ʻitem_id est un ** paramètre Path ** et q` est un ** paramètre Query ** au lieu d'un ** paramètre Path **. ..

De plus, l'API rapide reconnaît que q est un paramètre facultatif simplement en déclarant = None. ʻOptionaln'est pas utilisé par l'API Fast elle-même. Le but de le spécifier comme optionnel comme ʻOptional [str]est que le support de l'éditeur peut détecter l'erreur à l'avance.

Conversion de type de paramètre de requête

Vous pouvez déclarer le type bool comme un ** paramètre de requête **, auquel cas l'API rapide convertira le paramètre dans la forme appropriée. A titre d'exemple, vérifiez le code ci-dessous.

main.py


from typing import Optional

from fastapi import FastAPI

app = FastAPI()


@app.get("/items/{item_id}")
#Le type booléen est spécifié dans le paramètre de requête de l'argument
async def read_item(item_id: str, q: Optional[str] = None, short: bool = False):
    item = {"item_id": item_id}
    if q:
        item.update({"q": q})
    if not short:
        item.update(
            {"description": "This is an amazing item that has a long description"}
        )
    return item

Pour un tel code, vous pouvez y accéder comme suit:

Pour ces URL, tous les paramètres «short» sont traités comme «True» avec une «valeur booléenne». (La même chose est vraie même si la première lettre est changée du bas vers le haut) Si la valeur est différente de celle ci-dessus, elle sera «False». De cette façon, si vous spécifiez le type booléen dans le ** paramètre de requête **, la conversion sera effectuée par l'API rapide.

Plusieurs paramètres de chemin et de requête

Dans FastAPI, cela fonctionne bien même si vous déclarez plusieurs ** paramètres de chemin ** et ** paramètres de requête ** en même temps que des arguments de fonction. Vous n'avez pas non plus à les déclarer dans un ordre particulier. En effet, FastAPI reconnaît les paramètres par leur nom.

Par exemple, si vous avez un code comme celui-ci:

main


from typing import Optional

from fastapi import FastAPI

app = FastAPI()


@app.get("/users/{user_id}/items/{item_id}")    # <- {user_id}Quand{item_id}をPathパラメータQuandして指定
async def read_user_item(
    user_id: int, item_id: str, q: Optional[str] = None, short: bool = False    # <-Pas un paramètre de chemin"q"Quand"short"はQueryパラメータQuandして扱う
):
    item = {"item_id": item_id, "owner_id": user_id}
    if q:
        item.update({"q": q})
    if not short:
        item.update(
            {"description": "This is an amazing item that has a long description"}
        )
    return item

Dans ce cas, il n'y a pas de problème même si l'ordre des arguments de la fonction est modifié. FastAPI reconnaît chaque paramètre en fonction du nom du paramètre.

Paramètres de requête requis

Si vous déclarez une valeur par défaut avec un paramètre autre que Path (bien que vous n'appreniez que les paramètres de requête pour le moment), ce paramètre n'est plus un paramètre obligatoire. En effet, si le paramètre est omis, la valeur par défaut est spécifiée.

Vous pouvez également déclarer un paramètre en tant que paramètre facultatif sans ajouter de valeur spécifique en définissant la valeur par défaut sur «Aucun».

Ensuite, que faire lorsque vous souhaitez définir le ** paramètre de requête ** comme paramètre essentiel indispensable peut être obtenu en ne déclarant pas la valeur par défaut.

main


from fastapi import FastAPI

app = FastAPI()


@app.get("/items/{item_id}")
async def read_user_item(item_id: str, needy: str):     # <-Déclarer le paramètre needley sans spécifier de valeur par défaut
    item = {"item_id": item_id, "needy": needy}
    return item

Le paramètre needy ci-dessus est déclaré comme un type str obligatoire ** Paramètre de requête **. Si vous avez une URL comme celle-ci:

http://127.0.0.1:8000/items/foo-item

Si vous ouvrez le dans un navigateur, vous verrez l'erreur suivante car le paramètre requis «needy» n'a pas été ajouté.

{
    "detail": [
        {
            "loc": [
                "query",
                "needy"
            ],
            "msg": "field required",
            "type": "value_error.missing"
        }
    ]
}

needy est un paramètre obligatoire, vous devez donc le spécifier dans l'URL comme ci-dessous:

http://127.0.0.1:8000/items/foo-item?needy=sooooneedy

Cette URL devrait ressembler à ceci:

{
    "item_id": "foo-item",
    "needy": "sooooneedy"
}

Bien entendu, il est possible de définir en même temps les paramètres requis, les paramètres avec des valeurs par défaut et les paramètres optionnels.

main


from typing import Optional

from fastapi import FastAPI

app = FastAPI()


@app.get("/items/{item_id}")
async def read_user_item(
    item_id: str, needy: str, skip: int = 0, limit: Optional[int] = None    # <-
):
    item = {"item_id": item_id, "needy": needy, "skip": skip, "limit": limit}
    return item

Dans le code ci-dessus, trois paramètres de requête sont déclarés.

--needy: paramètre obligatoire de type str (sans valeur par défaut) --skip: paramètre de type ʻint avec la valeur par défaut 0 --limit: paramètre facultatif de type ʻint

Vous pouvez utiliser ʻEnum` dans ** paramètre de requête ** ainsi que ** paramètre de chemin **. Voir Paramètres de chemin pour plus de détails.

À la fin

Cette fois, j'ai appris à utiliser le ** paramètre de requête **. Tout le code utilisé dans cet article est tiré de la documentation officielle (https://fastapi.tiangolo.com/tutorial/query-params/), J'ai confirmé que cela fonctionne dans mon environnement local.

La prochaine fois, nous étudierons ** Request Body **.

Recommended Posts

Paramètres de requête FastAPI Tutorial Memo Part 3
Paramètres de chemin du mémo du didacticiel FastAPI Partie 2
Mémo du didacticiel FastAPI, partie 1
mémo du didacticiel django
[Pour mémoire] Linux Partie 2
Liste de rédaction de mémo partie 2
Mémo de base Python - Partie 2
Mémo du didacticiel Python OpenCV
Mémo de base Python - Partie 1
Mémo d'enquête Android HCE (partie 2)
mémo tutoriel pyramide (compte bancaire)
Collection de techniques de requête de puissance, partie 1
Obtenir les paramètres de requête pour Flask GET
Mémo 1 du manuel standard Linux, partie 2
Mémo de grammaire de base Python (1)
Mémo du manuel standard Linux, partie 6