Python, alternative solide pour le web
Python n’est pas seulement le langage de la data science : c’est aussi un excellent choix pour le développement web. Sa syntaxe claire, son écosystème riche, et ses frameworks matures en font une option sérieuse face à Node.js ou PHP. Deux frameworks dominent : Django pour les applications complètes et structurées, FastAPI pour les API modernes et performantes. Ce tutoriel présente les deux et leur contexte d’usage.
Django : le framework « batteries included »
Django fournit tout ce qu’il faut pour construire une application web complète : ORM puissant, système de template, authentification, administration automatique, migrations de base, internationalisation, sécurité par défaut. Cette exhaustivité accélère considérablement le développement pour les projets classiques.
Créé en 2005 pour un journal en ligne, Django a fait ses preuves sur des sites à fort trafic : Instagram, Pinterest, Mozilla, Disqus. Sa maturité et sa documentation sont exceptionnelles.
Installation et premier projet Django
Créez un environnement virtuel Python : python -m venv venv, activez-le (source venv/bin/activate sur Unix, venv\Scripts\activate sur Windows). Installez Django : pip install django. Créez un projet : django-admin startproject monsite. Lancez : python manage.py runserver.
Une page par défaut s’affiche sur http://localhost:8000. Le projet contient : manage.py (interface en ligne de commande), monsite/ (configuration), db.sqlite3 (base créée au besoin).
Les applications Django
Django organise le code en « applications » réutilisables. python manage.py startapp blog crée une application. Chaque application contient : models.py (modèles de données), views.py (logique), urls.py (routage), templates/ (HTML), admin.py (interface d’administration).
Ajoutez l’application dans INSTALLED_APPS de settings.py pour qu’elle soit reconnue.
Les modèles et l’ORM
Les modèles définissent la structure des données Python :
class Article(models.Model):
titre = models.CharField(max_length=200)
contenu = models.TextField()
auteur = models.ForeignKey('auth.User', on_delete=models.CASCADE)
date_publication = models.DateTimeField(auto_now_add=True)
python manage.py makemigrations puis python manage.py migrate crée la table correspondante. L’ORM Django permet des requêtes expressives : Article.objects.filter(auteur=user).order_by(‘-date_publication’). Pas de SQL direct dans la plupart des cas.
Les vues et le routage
Les vues traitent les requêtes et retournent des réponses. Elles peuvent être basées sur des fonctions (simples) ou sur des classes (plus structurées). Exemple :
def article_detail(request, id):
article = get_object_or_404(Article, id=id)
return render(request, 'article_detail.html', {'article': article})
urls.py mappe les URLs aux vues : path(‘article/<int:id>/’, views.article_detail, name=’article_detail’).
Les templates
Django utilise son propre moteur de templates. Héritage de templates via {% extends %}, blocs extensibles avec {% block %}, boucles et conditions avec {% for %}, {% if %}, interpolation avec {{ variable }}. Ces constructions permettent des mises en page flexibles avec peu de code.
L’admin automatique
Fonction signature de Django : une interface d’administration générée automatiquement à partir des modèles. Après avoir enregistré les modèles dans admin.py, les administrateurs disposent d’un CRUD complet sans avoir à le coder. Pour les projets internes ou les back-offices, cela représente un gain de temps immense.
L’authentification et les permissions
Django intègre un système d’authentification complet : utilisateurs, groupes, permissions, login/logout, réinitialisation de mot de passe, sessions. Les décorateurs @login_required protègent les vues. Les permissions par objet permettent des règles fines.
Django REST Framework
Pour construire des API, Django REST Framework (DRF) est le complément naturel de Django. Il ajoute : serializers (conversion modèle/JSON), viewsets (vues génériques pour CRUD), authentification (JWT, tokens, basic auth), pagination, filtrage, permissions. Très puissant, un peu lourd pour des API simples.
pip install djangorestframework, ajout aux INSTALLED_APPS, définition de viewsets et routes. Vous obtenez rapidement une API complète.
FastAPI : le framework moderne
FastAPI, créé par Sebastián Ramírez, est plus récent et cible spécifiquement les API modernes. Ses atouts : performance excellente (comparable à Node.js et Go grâce à Starlette), typage Python fort (utilisant Pydantic), documentation OpenAPI générée automatiquement, syntaxe élégante, support natif de l’asynchrone.
Premier projet FastAPI
pip install fastapi uvicorn. Créez main.py :
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI()
class Article(BaseModel):
titre: str
contenu: str
@app.post("/articles")
def creer_article(article: Article):
return {"id": 1, **article.dict()}
uvicorn main:app –reload lance le serveur. La documentation interactive est disponible sur /docs.
Les apports de FastAPI
La validation des entrées est automatique grâce à Pydantic : si un champ requis manque, l’API retourne une erreur 422 avec le détail. La documentation Swagger est générée sans effort. La complétion dans l’IDE est excellente grâce au typage.
L’asynchrone natif (async def) permet des performances élevées pour les cas IO-bound. Parfait pour des API qui orchestrent plusieurs appels externes.
FastAPI avec base de données
SQLAlchemy est l’ORM Python de référence. Avec Alembic pour les migrations, il fournit un stack robuste. Pour plus de simplicité, SQLModel (du même auteur que FastAPI) combine SQLAlchemy et Pydantic pour une expérience intégrée.
Choisir entre Django et FastAPI
Django convient pour : applications web avec beaucoup de pages HTML rendues côté serveur, admin riche, besoins métier divers (auth, CMS, CRM), équipes qui apprécient l’exhaustivité et les conventions. FastAPI convient pour : API pures (pas de rendu HTML), priorité à la performance, architecture microservices, développement piloté par la spécification.
Pour un projet avec à la fois une API et une application web : combiner Django (pour le back-office) et FastAPI (pour l’API publique) est parfaitement possible. Ou utiliser Django + DRF si on préfère une seule base.
Le déploiement Python
Gunicorn ou Uvicorn servent l’application en production. Nginx comme reverse proxy, HTTPS via Let’s Encrypt. Pour Django : collectstatic pour les fichiers statiques, migrations à appliquer, settings séparés par environnement.
Les plateformes comme Railway, Render, Heroku, Fly.io simplifient le déploiement. Pour plus de contrôle, un VPS avec une stack classique (Nginx + Gunicorn + PostgreSQL) reste efficace et économique.
Les bonnes pratiques
Environnements virtuels toujours. Dépendances listées dans requirements.txt ou pyproject.toml. Variables d’environnement pour les secrets (python-decouple, python-dotenv). Tests avec pytest. Formattage avec black, vérification avec ruff. Pré-commit hooks pour automatiser.
L’écosystème data
Un avantage de Python : la connexion naturelle avec l’écosystème data (pandas, scikit-learn, PyTorch, LangChain). Pour des applications intégrant machine learning ou analyses avancées, Python évite les allers-retours entre langages.
Conclusion : deux choix robustes
Python offre des options matures pour le développement web. Django, par son exhaustivité et sa stabilité, reste un guide général. FastAPI, par sa modernité et ses performances, s’impose pour les nouvelles API. Pour une PME, le choix dépend du contexte et des compétences disponibles. Les deux frameworks disposent de documentation excellente et de communautés actives. Expérimentez sur un projet concret pour vous forger votre opinion.