Frameworks Python¶

L'écosystème Python propose un choix large de frameworks web, d'ORM et d'outils de traitement asynchrone. Le bon choix dépend de la taille du projet, des contraintes de performance et de la maturité souhaitee. Cette section couvre les options les plus utilisées en production en 2024-2025.

Comparatif des frameworks web¶

Framework	Style	Async natif	ORM intégré	Points forts	Idéal pour
Django	Full-stack	Partiel	Oui	Admin, auth, batteries included	Applications métier complexes
FastAPI	API-first	Oui	Non	Performance, OpenAPI auto, type hints	APIs REST/GraphQL modernes
Flask	Micro	Non (ext.)	Non	Liberté totale, faible surface	Prototypes, APIs simples
Litestar	API-first	Oui	Non	Strict, performant, OpenAPI avance	APIs enterprise strictement typees

Django¶

Django est le framework "batteries included" de Python. Il embarque un ORM, un système de templates, un panneau d'administration, la gestion des utilisateurs et des migrations de base de données.

Installation et projet minimal¶

# Installation
# pip install django

# Creer un projet
# django-admin startproject monprojet
# python manage.py startapp monapp

# monapp/models.py
from django.db import models


class Article(models.Model):
    titre = models.CharField(max_length=200)
    contenu = models.TextField()
    publie_le = models.DateTimeField(auto_now_add=True)
    actif = models.BooleanField(default=True)

    class Meta:
        ordering = ["-publie_le"]

    def __str__(self) -> str:
        return self.titre

# monapp/views.py
from django.http import JsonResponse
from django.views import View
from .models import Article


class ArticleListView(View):
    def get(self, request):
        articles = Article.objects.filter(actif=True).values(
            "id", "titre", "publie_le"
        )
        return JsonResponse(list(articles), safe=False)

# monapp/urls.py
from django.urls import path
from .views import ArticleListView

urlpatterns = [
    path("articles/", ArticleListView.as_view(), name="article-list"),
]

Django REST Framework

Pour des APIs REST complètes avec Django, utilisez Django REST Framework (DRF) qui ajoute serializers, viewsets et authentification par tokens. Installez avec pip install djangorestframework.

FastAPI¶

FastAPI est le choix dominant pour les APIs modernes en Python. Il généré automatiquement la documentation OpenAPI, exploite les type hints Python et offre des performances comparables a Node.js grâce à Starlette et uvicorn.

Installation et API minimale¶

# pip install fastapi uvicorn[standard]

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel

app = FastAPI(title="Mon API", version="1.0.0")


class Item(BaseModel):
    nom: str
    prix: float
    disponible: bool = True


# Stockage en memoire pour l'exemple
items: dict[int, Item] = {}
counter: int = 0


@app.get("/items", response_model=list[Item])
async def lister_items() -> list[Item]:
    """Retourne tous les items disponibles."""
    return list(items.values())


@app.post("/items", response_model=Item, status_code=201)
async def creer_item(item: Item) -> Item:
    """Cree un nouvel item."""
    global counter
    counter += 1
    items[counter] = item
    return item


@app.get("/items/{item_id}", response_model=Item)
async def lire_item(item_id: int) -> Item:
    """Retourne un item par son identifiant."""
    if item_id not in items:
        raise HTTPException(status_code=404, detail="Item non trouve")
    return items[item_id]

# Lancement du serveur de developpement
uvicorn main:app --reload
# Documentation disponible sur http://localhost:8000/docs

Flask¶

Flask est un micro-framework minimaliste. Il ne fournit que le strict nécessaire (routing, contexte de requête, templates Jinja2) et laisse le développeur choisir ses outils pour le reste.

Application minimale¶

# pip install flask

from flask import Flask, jsonify, request, abort

app = Flask(__name__)

# Stockage en memoire
catalogue: list[dict] = []


@app.get("/produits")
def lister_produits():
    return jsonify(catalogue)


@app.post("/produits")
def ajouter_produit():
    data = request.get_json()
    if not data or "nom" not in data:
        abort(400, description="Champ 'nom' requis")
    catalogue.append({"id": len(catalogue) + 1, **data})
    return jsonify(catalogue[-1]), 201


if __name__ == "__main__":
    app.run(debug=True)

Flask en production

Ne jamais utiliser le serveur de développement Flask (app.run()) en production. Utilisez Gunicorn (gunicorn -w 4 main:app) ou uWSGI derriere un reverse proxy Nginx.

Litestar¶

Litestar (anciennement Starlite) est une alternative strictement typee a FastAPI, avec une architecture plus opiniatree et des fonctionnalités avancees comme le dependency injection intégré et le support OpenAPI complet.

# pip install litestar uvicorn

from litestar import Litestar, get, post
from litestar.exceptions import NotFoundException
from pydantic import BaseModel


class Produit(BaseModel):
    nom: str
    prix: float


stock: dict[int, Produit] = {}


@get("/produits")
async def lister() -> list[Produit]:
    return list(stock.values())


@post("/produits")
async def creer(data: Produit) -> Produit:
    stock[len(stock) + 1] = data
    return data


app = Litestar(route_handlers=[lister, creer])

ORM et accès aux données¶

ORM	Async	SQL pur possible	Intégration	Points forts
SQLAlchemy 2.x	Oui	Oui	Flask, FastAPI, tout	Le plus complet, très flexible
Django ORM	Partiel	Oui	Django uniquement	Simple, migrations intégrées
Tortoise ORM	Natif	Non	FastAPI, Litestar	API Django-like, full async
Peewee	Non	Non	Micro projets	Simple, léger

SQLAlchemy 2.x — exemple de base¶

# pip install sqlalchemy aiosqlite

from sqlalchemy import select, String
from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine

engine = create_async_engine("sqlite+aiosqlite:///./base.db", echo=False)


class Base(DeclarativeBase):
    pass


class Utilisateur(Base):
    __tablename__ = "utilisateurs"

    id: Mapped[int] = mapped_column(primary_key=True)
    nom: Mapped[str] = mapped_column(String(100))
    email: Mapped[str] = mapped_column(String(200), unique=True)


async def lire_utilisateurs(session: AsyncSession) -> list[Utilisateur]:
    result = await session.execute(select(Utilisateur))
    return list(result.scalars().all())

Traitement asynchrone — Celery et Dramatiq¶

Pour les tâches longues (envoi d'emails, traitement de fichiers, appels API tiers), Python dispose de deux solutions principales :

Outil	Broker supporte	Monitoring	Simplicité	Points forts
Celery	Redis, RabbitMQ, SQS	Flower, Prometheus	Moyenne	Écosystème mature, très complet
Dramatiq	Redis, RabbitMQ	Periodiq	Élevée	API plus simple, erreurs claires

# pip install celery redis

from celery import Celery

app = Celery(
    "taches",
    broker="redis://localhost:6379/0",
    backend="redis://localhost:6379/1",
)

app.conf.task_serializer = "json"
app.conf.result_serializer = "json"


@app.task(bind=True, max_retries=3, default_retry_delay=60)
def envoyer_email(self, destinataire: str, sujet: str, corps: str) -> dict:
    """Tache d'envoi d'email avec retry automatique."""
    try:
        # Logique d'envoi ici (SMTP, SendGrid, etc.)
        print(f"Email envoye a {destinataire}: {sujet}")
        return {"statut": "envoye", "destinataire": destinataire}
    except Exception as exc:
        raise self.retry(exc=exc)

# Lancement du worker
celery -A taches worker --loglevel=info

# Appel de la tache depuis le code applicatif
# envoyer_email.delay("user@example.com", "Bienvenue", "Corps du message")

Choisir le bon framework¶

Projet complexe avec admin, auth, migrations ?
    => Django + DRF

API moderne, performances importantes, OpenAPI obligatoire ?
    => FastAPI

Prototype rapide, liberte totale de la stack ?
    => Flask

API strictement typee, equipe senior ?
    => Litestar

FastAPI est le standard emergent

Pour les nouveaux projets d'API en 2025, FastAPI est le choix par défaut dans la majorité des équipes. Sa combinaison de performances, de documentation automatique et d'intégration native avec Pydantic v2 en fait le framework le plus productif pour les APIs modernes.