+
+### Tipleri ekle
+
+Önceki sürümden sadece bir satırı değiştirelim.
+
+Tam olarak bu parçayı, işlevin parametrelerini değiştireceğiz:
+
+```Python
+ first_name, last_name
+```
+
+ve bu hale getireceğiz:
+
+```Python
+ first_name: str, last_name: str
+```
+
+Bu kadar.
+
+İşte bunlar "tip belirteçleri":
+
+```Python hl_lines="1"
+{!../../../docs_src/python_types/tutorial002.py!}
+```
+
+Bu, aşağıdaki gibi varsayılan değerleri bildirmekle aynı şey değildir:
+
+```Python
+ first_name="john", last_name="doe"
+```
+
+Bu tamamen farklı birşey
+
+İki nokta üst üste (`:`) kullanıyoruz , eşittir (`=`) değil.
+
+Normalde tip belirteçleri eklemek, kod üzerinde olacakları değiştirmez.
+
+Şimdi programı sıfırdan birdaha yazdığınızı hayal edin.
+
+Aynı noktada, `Ctrl+Space` ile otomatik tamamlamayı tetiklediniz ve şunu görüyorsunuz:
+
+
+
+Aradığınızı bulana kadar seçenekleri kaydırabilirsiniz:
+
+
+
+## Daha fazla motivasyon
+
+Bu fonksiyon, zaten tür belirteçlerine sahip:
+
+```Python hl_lines="1"
+{!../../../docs_src/python_types/tutorial003.py!}
+```
+
+Editör değişkenlerin tiplerini bildiğinden, yalnızca otomatik tamamlama değil, hata kontrolleri de sağlar:
+
+
+
+Artık `age` değişkenini `str(age)` olarak kullanmanız gerektiğini biliyorsunuz:
+
+```Python hl_lines="2"
+{!../../../docs_src/python_types/tutorial004.py!}
+```
+
+## Tip bildirme
+
+Az önce tip belirteçlerinin en çok kullanıldığı yeri gördünüz.
+
+ **FastAPI**ile çalışırken tip belirteçlerini en çok kullanacağımız yer yine fonksiyonlardır.
+
+### Basit tipler
+
+Yalnızca `str` değil, tüm standart Python tiplerinin bildirebilirsiniz.
+
+Örneğin şunları kullanabilirsiniz:
+
+* `int`
+* `float`
+* `bool`
+* `bytes`
+
+```Python hl_lines="1"
+{!../../../docs_src/python_types/tutorial005.py!}
+```
+
+### Tip parametreleri ile Generic tipler
+
+"dict", "list", "set" ve "tuple" gibi diğer değerleri içerebilen bazı veri yapıları vardır. Ve dahili değerlerinin de tip belirtecleri olabilir.
+
+Bu tipleri ve dahili tpileri bildirmek için standart Python modülünü "typing" kullanabilirsiniz.
+
+Bu tür tip belirteçlerini desteklemek için özel olarak mevcuttur.
+
+#### `List`
+
+Örneğin `str` değerlerden oluşan bir `list` tanımlayalım.
+
+From `typing`, import `List` (büyük harf olan `L` ile):
+
+```Python hl_lines="1"
+{!../../../docs_src/python_types/tutorial006.py!}
+```
+
+Değişkenin tipini yine iki nokta üstüste (`:`) ile belirleyin.
+
+tip olarak `List` kullanın.
+
+Liste, bazı dahili tipleri içeren bir tür olduğundan, bunları köşeli parantez içine alırsınız:
+
+```Python hl_lines="4"
+{!../../../docs_src/python_types/tutorial006.py!}
+```
+
+!!! ipucu
+ Köşeli parantez içindeki bu dahili tiplere "tip parametreleri" denir.
+
+ Bu durumda `str`, `List`e iletilen tür parametresidir.
+
+Bunun anlamı şudur: "`items` değişkeni bir `list`tir ve bu listedeki öğelerin her biri bir `str`dir".
+
+Bunu yaparak, düzenleyicinizin listedeki öğeleri işlerken bile destek sağlamasını sağlayabilirsiniz:
+
+
+
+Tip belirteçleri olmadan, bunu başarmak neredeyse imkansızdır.
+
+`item` değişkeninin `items` listesindeki öğelerden biri olduğuna dikkat edin.
+
+Ve yine, editör bunun bir `str` olduğunu biliyor ve bunun için destek sağlıyor.
+
+#### `Tuple` ve `Set`
+
+`Tuple` ve `set`lerin tiplerini bildirmek için de aynısını yapıyoruz:
+
+```Python hl_lines="1 4"
+{!../../../docs_src/python_types/tutorial007.py!}
+```
+
+Bu şu anlama geliyor:
+
+* `items_t` değişkeni sırasıyla `int`, `int`, ve `str` tiplerinden oluşan bir `tuple` türündedir .
+* `items_s` ise her öğesi `bytes` türünde olan bir `set` örneğidir.
+
+#### `Dict`
+
+Bir `dict` tanımlamak için virgülle ayrılmış iki parametre verebilirsiniz.
+
+İlk tip parametresi `dict` değerinin `key` değeri içindir.
+
+İkinci parametre ise `dict` değerinin `value` değeri içindir:
+
+```Python hl_lines="1 4"
+{!../../../docs_src/python_types/tutorial008.py!}
+```
+
+Bu şu anlama gelir:
+
+* `prices` değişkeni `dict` tipindedir:
+ * `dict` değişkeninin `key` değeri `str` tipindedir (herbir item'ın "name" değeri).
+ * `dict` değişkeninin `value` değeri `float` tipindedir (lherbir item'ın "price" değeri).
+
+#### `Optional`
+
+`Optional` bir değişkenin `str`gibi bir tipi olabileceğini ama isteğe bağlı olarak tipinin `None` olabileceğini belirtir:
+
+```Python hl_lines="1 4"
+{!../../../docs_src/python_types/tutorial009.py!}
+```
+
+`str` yerine `Optional[str]` kullanmak editorün bu değerin her zaman `str` tipinde değil bazen `None` tipinde de olabileceğini belirtir ve hataları tespit etmemizde yardımcı olur.
+
+#### Generic tipler
+
+Köşeli parantez içinde tip parametreleri alan bu türler, örneğin:
+
+* `List`
+* `Tuple`
+* `Set`
+* `Dict`
+* `Optional`
+* ...and others.
+
+**Generic types** yada **Generics** olarak adlandırılır.
+
+### Tip olarak Sınıflar
+
+Bir değişkenin tipini bir sınıf ile bildirebilirsiniz.
+
+Diyelim ki `name` değerine sahip `Person` sınıfınız var:
+
+```Python hl_lines="1-3"
+{!../../../docs_src/python_types/tutorial010.py!}
+```
+
+Sonra bir değişkeni 'Person' tipinde tanımlayabilirsiniz:
+
+```Python hl_lines="6"
+{!../../../docs_src/python_types/tutorial010.py!}
+```
+
+Ve yine bütün editör desteğini alırsınız:
+
+
+
+## Pydantic modelleri
+
+
+
+!!! info
+ À nouveau, en utilisant uniquement les déclarations de type Python, **FastAPI** vous fournit automatiquement une documentation interactive (via Swagger UI).
+
+ On voit bien dans la documentation que `item_id` est déclaré comme entier.
+
+## Les avantages d'avoir une documentation basée sur une norme, et la documentation alternative.
+
+Le schéma généré suivant la norme OpenAPI,
+il existe de nombreux outils compatibles.
+
+Grâce à cela, **FastAPI** lui-même fournit une documentation alternative (utilisant ReDoc), qui peut être lue
+sur http://127.0.0.1:8000/redoc :
+
+
+
+De la même façon, il existe bien d'autres outils compatibles, y compris des outils de génération de code
+pour de nombreux langages.
+
+## Pydantic
+
+Toute la validation de données est effectué en arrière-plan avec Pydantic,
+dont vous bénéficierez de tous les avantages. Vous savez donc que vous êtes entre de bonnes mains.
+
+## L'ordre importe
+
+Quand vous créez des *fonctions de chemins*, vous pouvez vous retrouver dans une situation où vous avez un chemin fixe.
+
+Tel que `/users/me`, disons pour récupérer les données sur l'utilisateur actuel.
+
+Et vous avez un second chemin : `/users/{user_id}` pour récupérer de la donnée sur un utilisateur spécifique grâce à son identifiant d'utilisateur
+
+Les *fonctions de chemin* étant évaluées dans l'ordre, il faut s'assurer que la fonction correspondant à `/users/me` est déclarée avant celle de `/users/{user_id}` :
+
+```Python hl_lines="6 11"
+{!../../../docs_src/path_params/tutorial003.py!}
+```
+
+Sinon, le chemin `/users/{user_id}` correspondrait aussi à `/users/me`, la fonction "croyant" qu'elle a reçu un paramètre `user_id` avec pour valeur `"me"`.
+
+## Valeurs prédéfinies
+
+Si vous avez une *fonction de chemin* qui reçoit un *paramètre de chemin*, mais que vous voulez que les valeurs possibles des paramètres soient prédéfinies, vous pouvez utiliser les `Enum` de Python.
+
+### Création d'un `Enum`
+
+Importez `Enum` et créez une sous-classe qui hérite de `str` et `Enum`.
+
+En héritant de `str` la documentation sera capable de savoir que les valeurs doivent être de type `string` et pourra donc afficher cette `Enum` correctement.
+
+Créez ensuite des attributs de classe avec des valeurs fixes, qui seront les valeurs autorisées pour cette énumération.
+
+```Python hl_lines="1 6-9"
+{!../../../docs_src/path_params/tutorial005.py!}
+```
+
+!!! info
+ Les énumérations (ou enums) sont disponibles en Python depuis la version 3.4.
+
+!!! tip "Astuce"
+ Pour ceux qui se demandent, "AlexNet", "ResNet", et "LeNet" sont juste des noms de modèles de Machine Learning.
+
+### Déclarer un paramètre de chemin
+
+Créez ensuite un *paramètre de chemin* avec une annotation de type désignant l'énumération créée précédemment (`ModelName`) :
+
+```Python hl_lines="16"
+{!../../../docs_src/path_params/tutorial005.py!}
+```
+
+### Documentation
+
+Les valeurs disponibles pour le *paramètre de chemin* sont bien prédéfinies, la documentation les affiche correctement :
+
+
+
+### Manipuler les *énumérations* Python
+
+La valeur du *paramètre de chemin* sera un des "membres" de l'énumération.
+
+#### Comparer les *membres d'énumération*
+
+Vous pouvez comparer ce paramètre avec les membres de votre énumération `ModelName` :
+
+```Python hl_lines="17"
+{!../../../docs_src/path_params/tutorial005.py!}
+```
+
+#### Récupérer la *valeur de l'énumération*
+
+Vous pouvez obtenir la valeur réel d'un membre (une chaîne de caractères ici), avec `model_name.value`, ou en général, `votre_membre_d'enum.value` :
+
+```Python hl_lines="20"
+{!../../../docs_src/path_params/tutorial005.py!}
+```
+
+!!! tip "Astuce"
+ Vous pouvez aussi accéder la valeur `"lenet"` avec `ModelName.lenet.value`.
+
+#### Retourner des *membres d'énumération*
+
+Vous pouvez retourner des *membres d'énumération* dans vos *fonctions de chemin*, même imbriquée dans un JSON (e.g. un `dict`).
+
+Ils seront convertis vers leurs valeurs correspondantes (chaînes de caractères ici) avant d'être transmis au client :
+
+```Python hl_lines="18 21 23"
+{!../../../docs_src/path_params/tutorial005.py!}
+```
+
+Le client recevra une réponse JSON comme celle-ci :
+
+```JSON
+{
+ "model_name": "alexnet",
+ "message": "Deep Learning FTW!"
+}
+```
+
+## Paramètres de chemin contenant des chemins
+
+Disons que vous avez une *fonction de chemin* liée au chemin `/files/{file_path}`.
+
+Mais que `file_path` lui-même doit contenir un *chemin*, comme `home/johndoe/myfile.txt` par exemple.
+
+Donc, l'URL pour ce fichier pourrait être : `/files/home/johndoe/myfile.txt`.
+
+### Support d'OpenAPI
+
+OpenAPI ne supporte pas de manière de déclarer un paramètre de chemin contenant un *chemin*, cela pouvant causer des scénarios difficiles à tester et définir.
+
+Néanmoins, cela reste faisable dans **FastAPI**, via les outils internes de Starlette.
+
+Et la documentation fonctionne quand même, bien qu'aucune section ne soit ajoutée pour dire que la paramètre devrait contenir un *chemin*.
+
+### Convertisseur de *chemin*
+
+En utilisant une option de Starlette directement, vous pouvez déclarer un *paramètre de chemin* contenant un *chemin* avec une URL comme :
+
+```
+/files/{file_path:path}
+```
+
+Dans ce cas, le nom du paramètre est `file_path`, et la dernière partie, `:path`, indique à Starlette que le paramètre devrait correspondre à un *chemin*.
+
+Vous pouvez donc l'utilisez comme tel :
+
+```Python hl_lines="6"
+{!../../../docs_src/path_params/tutorial004.py!}
+```
+
+!!! tip "Astuce"
+ Vous pourriez avoir besoin que le paramètre contienne `/home/johndoe/myfile.txt`, avec un slash au début (`/`).
+
+ Dans ce cas, l'URL serait : `/files//home/johndoe/myfile.txt`, avec un double slash (`//`) entre `files` et `home`.
+
+## Récapitulatif
+
+Avec **FastAPI**, en utilisant les déclarations de type rapides, intuitives et standards de Python, vous bénéficiez de :
+
+* Support de l'éditeur : vérification d'erreurs, auto-complétion, etc.
+* "Parsing" de données.
+* Validation de données.
+* Annotations d'API et documentation automatique.
+
+Et vous n'avez besoin de le déclarer qu'une fois.
+
+C'est probablement l'avantage visible principal de **FastAPI** comparé aux autres *frameworks* (outre les performances pures).
diff --git a/docs/fr/mkdocs.yml b/docs/fr/mkdocs.yml
index 4973d170e..01cf8d5e0 100644
--- a/docs/fr/mkdocs.yml
+++ b/docs/fr/mkdocs.yml
@@ -59,6 +59,7 @@ nav:
- fastapi-people.md
- python-types.md
- Tutoriel - Guide utilisateur:
+ - tutorial/path-params.md
- tutorial/query-params.md
- tutorial/body.md
- tutorial/background-tasks.md
From 08410ca5688e81963d681cbeb8aeef69486942eb Mon Sep 17 00:00:00 2001
From: github-actions
+
+```console
+$ uvicorn main:app --reload
+
+INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
+INFO: Started reloader process [28720]
+INFO: Started server process [28722]
+INFO: Waiting for application startup.
+INFO: Application startup complete.
+```
+
+
+
+!!! note
+ La commande `uvicorn main:app` fait référence à :
+
+ * `main` : le fichier `main.py` (le module Python).
+ * `app` : l'objet créé dans `main.py` via la ligne `app = FastAPI()`.
+ * `--reload` : l'option disant à uvicorn de redémarrer le serveur à chaque changement du code. À ne pas utiliser en production !
+
+Vous devriez voir dans la console, une ligne semblable à la suivante :
+
+```hl_lines="4"
+INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
+```
+
+Cette ligne montre l'URL par laquelle l'app est actuellement accessible, sur votre machine locale.
+
+### Allez voir le résultat
+
+Ouvrez votre navigateur à l'adresse http://127.0.0.1:8000.
+
+Vous obtiendrez cette réponse JSON :
+
+```JSON
+{"message": "Hello World"}
+```
+
+### Documentation interactive de l'API
+
+Rendez-vous sur http://127.0.0.1:8000/docs.
+
+Vous verrez la documentation interactive de l'API générée automatiquement (via Swagger UI) :
+
+
+
+### Documentation alternative
+
+Ensuite, rendez-vous sur http://127.0.0.1:8000/redoc.
+
+Vous y verrez la documentation alternative (via ReDoc) :
+
+
+
+### OpenAPI
+
+**FastAPI** génère un "schéma" contenant toute votre API dans le standard de définition d'API **OpenAPI**.
+
+#### "Schéma"
+
+Un "schéma" est une définition ou une description de quelque chose. Pas le code qui l'implémente, uniquement une description abstraite.
+
+#### "Schéma" d'API
+
+Ici, OpenAPI est une spécification qui dicte comment définir le schéma de votre API.
+
+Le schéma inclut les chemins de votre API, les paramètres potentiels de chaque chemin, etc.
+
+#### "Schéma" de données
+
+Le terme "schéma" peut aussi faire référence à la forme de la donnée, comme un contenu JSON.
+
+Dans ce cas, cela signifierait les attributs JSON, ainsi que les types de ces attributs, etc.
+
+#### OpenAPI et JSON Schema
+
+**OpenAPI** définit un schéma d'API pour votre API. Il inclut des définitions (ou "schémas") de la donnée envoyée et reçue par votre API en utilisant **JSON Schema**, le standard des schémas de données JSON.
+
+#### Allez voir `openapi.json`
+
+Si vous êtes curieux d'à quoi ressemble le schéma brut **OpenAPI**, **FastAPI** génère automatiquement un (schéma) JSON avec les descriptions de toute votre API.
+
+Vous pouvez le voir directement à cette adresse : http://127.0.0.1:8000/openapi.json.
+
+Le schéma devrait ressembler à ceci :
+
+
+```JSON
+{
+ "openapi": "3.0.2",
+ "info": {
+ "title": "FastAPI",
+ "version": "0.1.0"
+ },
+ "paths": {
+ "/items/": {
+ "get": {
+ "responses": {
+ "200": {
+ "description": "Successful Response",
+ "content": {
+ "application/json": {
+
+
+
+...
+```
+
+#### À quoi sert OpenAPI
+
+Le schéma **OpenAPI** est ce qui alimente les deux systèmes de documentation interactive.
+
+Et il existe des dizaines d'alternatives, toutes basées sur **OpenAPI**. Vous pourriez facilement ajouter n'importe laquelle de ces alternatives à votre application **FastAPI**.
+
+Vous pourriez aussi l'utiliser pour générer du code automatiquement, pour les clients qui communiquent avec votre API. Comme par exemple, des applications frontend, mobiles ou IOT.
+
+## Récapitulatif, étape par étape
+
+### Étape 1 : import `FastAPI`
+
+```Python hl_lines="1"
+{!../../../docs_src/first_steps/tutorial001.py!}
+```
+
+`FastAPI` est une classe Python qui fournit toutes les fonctionnalités nécessaires au lancement de votre API.
+
+!!! note "Détails techniques"
+ `FastAPI` est une classe héritant directement de `Starlette`.
+
+ Vous pouvez donc aussi utiliser toutes les fonctionnalités de Starlette depuis `FastAPI`.
+
+### Étape 2 : créer une "instance" `FastAPI`
+
+```Python hl_lines="3"
+{!../../../docs_src/first_steps/tutorial001.py!}
+```
+
+Ici la variable `app` sera une "instance" de la classe `FastAPI`.
+
+Ce sera le point principal d'interaction pour créer toute votre API.
+
+Cette `app` est la même que celle à laquelle fait référence `uvicorn` dans la commande :
+
+
+
+```console
+$ uvicorn main:app --reload
+
+INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
+```
+
+
+
+Si vous créez votre app avec :
+
+```Python hl_lines="3"
+{!../../../docs_src/first_steps/tutorial002.py!}
+```
+
+Et la mettez dans un fichier `main.py`, alors vous appeleriez `uvicorn` avec :
+
+
+
+```console
+$ uvicorn main:my_awesome_api --reload
+
+INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
+```
+
+
+
+### Étape 3: créer une *opération de chemin*
+
+#### Chemin
+
+Chemin, ou "path" fait référence ici à la dernière partie de l'URL démarrant au premier `/`.
+
+Donc, dans un URL tel que :
+
+```
+https://example.com/items/foo
+```
+
+...le "path" serait :
+
+```
+/items/foo
+```
+
+!!! info
+ Un chemin, ou "path" est aussi souvent appelé route ou "endpoint".
+
+
+#### Opération
+
+"Opération" fait référence à une des "méthodes" HTTP.
+
+Une de :
+
+* `POST`
+* `GET`
+* `PUT`
+* `DELETE`
+
+...ou une des plus exotiques :
+
+* `OPTIONS`
+* `HEAD`
+* `PATCH`
+* `TRACE`
+
+Dans le protocol HTTP, vous pouvez communiquer avec chaque chemin en utilisant une (ou plus) de ces "méthodes".
+
+---
+
+En construisant des APIs, vous utilisez généralement ces méthodes HTTP spécifiques pour effectuer une action précise.
+
+Généralement vous utilisez :
+
+* `POST` : pour créer de la donnée.
+* `GET` : pour lire de la donnée.
+* `PUT` : pour mettre à jour de la donnée.
+* `DELETE` : pour supprimer de la donnée.
+
+Donc, dans **OpenAPI**, chaque méthode HTTP est appelée une "opération".
+
+Nous allons donc aussi appeler ces dernières des "**opérations**".
+
+
+#### Définir un *décorateur d'opération de chemin*
+
+```Python hl_lines="6"
+{!../../../docs_src/first_steps/tutorial001.py!}
+```
+
+Le `@app.get("/")` dit à **FastAPI** que la fonction en dessous est chargée de gérer les requêtes qui vont sur :
+
+* le chemin `/`
+* en utilisant une opération get
+
+!!! info "`@décorateur` Info"
+ Cette syntaxe `@something` en Python est appelée un "décorateur".
+
+ Vous la mettez au dessus d'une fonction. Comme un joli chapeau décoratif (j'imagine que ce terme vient de là 🤷🏻♂).
+
+ Un "décorateur" prend la fonction en dessous et en fait quelque chose.
+
+ Dans notre cas, ce décorateur dit à **FastAPI** que la fonction en dessous correspond au **chemin** `/` avec l'**opération** `get`.
+
+ C'est le "**décorateur d'opération de chemin**".
+
+Vous pouvez aussi utiliser les autres opérations :
+
+* `@app.post()`
+* `@app.put()`
+* `@app.delete()`
+
+Tout comme celles les plus exotiques :
+
+* `@app.options()`
+* `@app.head()`
+* `@app.patch()`
+* `@app.trace()`
+
+!!! tip "Astuce"
+ Vous êtes libres d'utiliser chaque opération (méthode HTTP) comme vous le désirez.
+
+ **FastAPI** n'impose pas de sens spécifique à chacune d'elle.
+
+ Les informations qui sont présentées ici forment une directive générale, pas des obligations.
+
+ Par exemple, quand l'on utilise **GraphQL**, toutes les actions sont effectuées en utilisant uniquement des opérations `POST`.
+
+### Étape 4 : définir la **fonction de chemin**.
+
+Voici notre "**fonction de chemin**" (ou fonction d'opération de chemin) :
+
+* **chemin** : `/`.
+* **opération** : `get`.
+* **fonction** : la fonction sous le "décorateur" (sous `@app.get("/")`).
+
+```Python hl_lines="7"
+{!../../../docs_src/first_steps/tutorial001.py!}
+```
+
+C'est une fonction Python.
+
+Elle sera appelée par **FastAPI** quand une requête sur l'URL `/` sera reçue via une opération `GET`.
+
+Ici, c'est une fonction asynchrone (définie avec `async def`).
+
+---
+
+Vous pourriez aussi la définir comme une fonction classique plutôt qu'avec `async def` :
+
+```Python hl_lines="7"
+{!../../../docs_src/first_steps/tutorial003.py!}
+```
+
+!!! note
+ Si vous ne connaissez pas la différence, allez voir la section [Concurrence : *"Vous êtes pressés ?"*](../async.md#vous-etes-presses){.internal-link target=_blank}.
+
+### Étape 5 : retourner le contenu
+
+```Python hl_lines="8"
+{!../../../docs_src/first_steps/tutorial001.py!}
+```
+
+Vous pouvez retourner un dictionnaire (`dict`), une liste (`list`), des valeurs seules comme des chaines de caractères (`str`) et des entiers (`int`), etc.
+
+Vous pouvez aussi retourner des models **Pydantic** (qui seront détaillés plus tard).
+
+Il y a de nombreux autres objets et modèles qui seront automatiquement convertis en JSON. Essayez d'utiliser vos favoris, il est fort probable qu'ils soient déjà supportés.
+
+## Récapitulatif
+
+* Importez `FastAPI`.
+* Créez une instance d'`app`.
+* Ajoutez une **décorateur d'opération de chemin** (tel que `@app.get("/")`).
+* Ajoutez une **fonction de chemin** (telle que `def root(): ...` comme ci-dessus).
+* Lancez le serveur de développement (avec `uvicorn main:app --reload`).
diff --git a/docs/fr/mkdocs.yml b/docs/fr/mkdocs.yml
index 01cf8d5e0..6242a88fd 100644
--- a/docs/fr/mkdocs.yml
+++ b/docs/fr/mkdocs.yml
@@ -59,6 +59,7 @@ nav:
- fastapi-people.md
- python-types.md
- Tutoriel - Guide utilisateur:
+ - tutorial/first-steps.md
- tutorial/path-params.md
- tutorial/query-params.md
- tutorial/body.md
From fb1f34123124641850d5cfbe1d247a654ab51586 Mon Sep 17 00:00:00 2001
From: github-actions