Voici un article complet sur Django avec le module typing, adapté aux développeurs qui souhaitent améliorer la lisibilité, la maintenabilité et la robustesse de leur code Django.

🔍 Introduction

Le framework Django est largement utilisé pour le développement d'applications web. Toutefois, comme Python est un langage dynamiquement typé, les erreurs de type ne sont détectées qu’à l’exécution, ce qui peut entraîner des bugs difficiles à tracer.

Avec le module typing, Python (à partir de la version 3.5+) permet d’ajouter des annotations de type statique. Ces annotations ne changent pas le comportement du programme, mais elles sont très utiles pour :

• la documentation du code,
• les vérifications statiques avec des outils comme mypy,
• les éditeurs intelligents (type hinting, auto-complétion),
• la collaboration entre développeurs.

Dans cet article, nous verrons comment appliquer le module typing dans un projet Django : dans les vues, les modèles, les serializers et les fonctions utilitaires.

🧩 1. Typage dans les fonctions utilitaires

Avant :

def calculate_discount(price, rate):
    return price - (price * rate)

Après (avec typing) :

from typing import Union

def calculate_discount(price: float, rate: float) -> float:
    return price - (price * rate)

Ici, on sait clairement que la fonction prend deux float et retourne un float.

📦 2. Typage dans les modèles Django

On peut utiliser le module typing pour améliorer la lisibilité dans les méthodes de modèles :

from typing import Optional
from django.db import models

class Product(models.Model):
    name = models.CharField(max_length=255)
    price = models.FloatField()

    def get_discounted_price(self, discount: float) -> float:
        return self.price * (1 - discount)

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

🌐 3. Typage dans les vues Django

Typage pour les vues basées sur fonctions (FBV) :

from typing import Any
from django.http import HttpRequest, HttpResponse

def home_view(request: HttpRequest) -> HttpResponse:
    return HttpResponse("Bienvenue sur notre site.")

Typage pour les vues basées sur classes (CBV) :

from typing import Any
from django.views import View
from django.http import HttpRequest, HttpResponse

class ContactView(View):
    def get(self, request: HttpRequest, *args: Any, **kwargs: Any) -> HttpResponse:
        return HttpResponse("Page de contact")

🛠️ 4. Typage avec les serializers Django REST Framework

from typing import Any
from rest_framework import serializers
from .models import Product

class ProductSerializer(serializers.ModelSerializer):
    class Meta:
        model = Product
        fields = ['id', 'name', 'price']

    def validate_price(self, value: Any) -> float:
        if value < 0:
            raise serializers.ValidationError("Le prix ne peut pas être négatif.")
        return value

🧪 5. Typage dans les tests

from typing import Any
from django.test import TestCase
from .models import Product

class ProductTestCase(TestCase):
    def test_discount(self) -> None:
        product = Product.objects.create(name="Chaussure", price=100)
        discounted = product.get_discounted_price(0.2)
        self.assertEqual(discounted, 80.0)

🧰 6. Outils recommandés

• mypy : outil pour vérifier les types statiques
  → pip install mypy

• pyright : excellent support intégré à VS Code

• ruff : combine linting et vérification de types

📚 Conclusion

Utiliser le module typing dans Django est une bonne pratique qui améliore la qualité du code sans modifier son comportement. Cela rend votre code plus maintenable, compréhensible, et facilite la collaboration entre développeurs. Même si Django ne l’impose pas, c’est un standard moderne que toute équipe devrait adopter.