Django vs FastAPI : comparatif

## Tableau comparatif rapide
| Critere | Django | FastAPI |
|---|---|---|
| Performance | Moyenne à Haute | Haute |
| Curve d'apprentissage | Forte | Faible |
| Ecosysteme | Extensif | Relativement limité |
| Communauté | Large et active | En expansion rapide |
| Cas d'usage | Projets Web complexes | Applications API modernes |
| Typage | Pythonique (Dynamique) | Types explicites (Static) |
| Bundle size | Moins compact | Plus compact |

## Django — Points forts
- **Extensif** : Large écosystème avec de nombreuses extensions et librairies.
  ```python
  # Django
  from django.contrib.auth.models import User
  user = User.objects.create_user(username='john', email='jlennon@beatles.com', password='glass Onion')

• Communauté active : Support et ressources abondants en ligne.
• Cas d'usage : Projets Web complexes avec une grande variété de fonctionnalités.
• Typage dynamique : Flexibilité et rapidité dans le développement.
• Performance : Optimal pour des applications Web monolithiques.

FastAPI — Points forts

• Performance élevée : Optimisé pour les APIs modernes à haut débit.

  # FastAPI
  from fastapi import FastAPI
  app = FastAPI()
  
  @app.get("/")
  def read_root():
      return {"Hello": "World"}
  

• Curve d'apprentissage faible : Syntaxe simple et intuitive.
• Cas d'usage : Applications API modernes nécessitant une grande vitesse et efficacité.
• Typage statique : Protection contre les erreurs et meilleure lisibilité du code.
• Bundle size minimal : Fournit ce dont vous avez besoin sans surcharge.

Syntaxe cote à cote

Génération d'une route simple

// Django
from django.urls import path
from . import views

urlpatterns = [
    path('hello/', views.hello_world, name='hello'),
]

## views.py
def hello_world(request):
    return HttpResponse("Hello World!")

// FastAPI
from fastapi import FastAPI
app = FastAPI()

@app.get("/hello/")
async def read_hello():
    return {"message": "Hello World!"}

Gestion des modèles et de la base de données

// Django
from django.db import models

class Book(models.Model):
    title = models.CharField(max_length=100)
    author = models.CharField(max_length=100)

## Migrations
python manage.py makemigrations
python manage.py migrate

// FastAPI (Pydantic + SQLAlchemy)
from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker

Base = declarative_base()

class Book(Base):
    __tablename__ = "books"
    id = Column(Integer, primary_key=True, index=True)
    title = Column(String, index=True)
    author = Column(String, index=True)

engine = create_engine("sqlite:///./test.db")
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)

Authentification

// Django (Django.contrib.auth)
from django.contrib.auth.models import User

user = authenticate(request, username='john', password='password')
if user is not None:
    login(request, user)

// FastAPI (Pydantic + OAuth2)
from fastapi import Depends, HTTPException, status
from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm

oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")

async def get_current_user(token: str = Depends(oauth2_scheme)):
    credentials_exception = HTTPException(
        status_code=status.HTTP_401_UNAUTHORIZED,
        detail="Could not validate credentials",
        headers={"WWW-Authenticate": "Bearer"},
    )
    return fake_decode_token(token)

Gestion des erreurs

// Django (Views)
from django.http import HttpResponse

def my_view(request):
    try:
        # some code that might raise an exception
        pass
    except Exception as e:
        return HttpResponse(str(e), status=500)

// FastAPI (Exceptions)
from fastapi import HTTPException, status
from pydantic import BaseModel

class Item(BaseModel):
    name: str
    description: str = None
    price: float
    tax: float = None

@app.post("/items/")
async def create_item(item: Item):
    if item.price < 0:
        raise HTTPException(status_code=400, detail="Price must be non-negative")
    return item

Quand choisir Django vs FastAPI

• Django : Pour des projets Web complexes nécessitant une grande variété de fonctionnalités et une équipe expérimentée.
• FastAPI : Pour des applications API modernes nécessitant une grande vitesse et efficacité, avec une équipe plus jeune ou souhaitant développer plus rapidement.

Verdict

Django offre un écosystème complet pour les projets Web complexes, avec une grande communauté et une performance élevée. FastAPI, quant à lui, est idéal pour les applications API modernes nécessitant une vitesse optimale et une simplicité dans le développement. ```