Qu'est-ce que FastAPI et pourquoi est-il populaire ?

Question

Accepted Answer

**FastAPI** est un framework web Python moderne et performant pour construire des API, basé sur les **indications de type Python**. Il utilise ces indications pour piloter la validation, la sérialisation et la génération automatique de documentation — vous donnant vitesse, sécurité et excellente expérience développeur tout à la fois.

## Une API complète en quelques lignes

```python
from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Item(BaseModel):      # a Pydantic model — defines & validates the shape
    name: str
    price: float

@app.post("/items")
def create_item(item: Item):   # the type hint `item: Item` does the work
    return {"name": item.name, "total": item.price * 1.1}
# automatic: JSON parsing, validation, error responses, AND interactive docs
```

À partir de cette simple annotation de type, FastAPI analyse et **valide** le corps de la requête, retourne une erreur 422 claire en cas de mauvaise entrée, sérialise la réponse et génère une **documentation API interactive** — tout sans code supplémentaire.

## Pourquoi c'est populaire

```text
✓ FAST — among the fastest Python frameworks (built on Starlette + async)
✓ Type-hint-driven — validation, serialization, and editor autocomplete from types
✓ Automatic interactive docs (Swagger UI + ReDoc) generated from your code
✓ Pydantic validation — robust input validation with clear errors, for free
✓ Async-native — first-class async/await for high-concurrency I/O
✓ Great DX — minimal boilerplate, excellent editor support, easy to learn
```

## FastAPI vs Django/Flask

```text
FastAPI → modern, async, type-driven, API-first; minimal but powerful
Django  → batteries-included, full-stack (ORM, admin, templates), sync-first
Flask   → minimal, flexible, but you add validation/docs/async yourself
→ FastAPI excels for APIs/microservices needing speed, validation, and docs.
```

## Pourquoi c'est important

FastAPI est rapidement devenu un choix privilégié pour construire des API Python car il offre haute performance, validation automatique et documentation interactive auto-générée à partir d'une unique source de vérité — les **indications de type Python** — avec un minimum de code passe-partout.

Comprendre ce qui le rend spécial (validation/sérialisation pilotée par types via Pydantic, conception native async et documentation interactive gratuite) explique pourquoi il est si productif et pourquoi il est préféré pour les API modernes et les microservices par rapport aux frameworks plus anciens.

Cela encadre tout le reste du travail avec lui : presque chaque fonctionnalité découle de la déclaration de types.