Maîtriser Django : comprendre l'architecture MVT, les fichiers clés et l'organisation d'un projet

1. Le patron MVT : le cœur de Django

Django repose sur le patron d'architecture MVT : Model, View, Template. C'est une variante du célèbre MVC (Model-View-Controller), adaptée au développement web. Chaque composant a une responsabilité précise et unique :

Le fichier urls.py agit comme un aiguilleur : il intercepte chaque URL entrante et la dirige vers la bonne View.

2. Décryptage de chaque fichier

Voici l'arborescence d'une application Django typique (ici une app blog) et le rôle précis de chaque fichier :

3. Le cycle complet d'une requête HTTP

Comprendre l'ordre dans lequel Django traite une requête est fondamental. Voici ce qui se passe lorsqu'un utilisateur visite une URL de votre site :

Chaque flèche représente une étape. Django commence toujours par le routage des URLs, puis délègue à la View qui ira chercher des données dans les Models, avant de rendre un Template et de retourner la réponse au navigateur.

4. models.py : définir la structure de vos données

Le fichier models.py est l'endroit où vous décrivez vos entités de données. Chaque classe Python héritant de models.Model correspond à une table dans votre base de données. Pas besoin d'écrire du SQL : Django's ORM s'en charge.

Exemple : modèle Article pour un blog

Copierfrom django.db import models
from django.utils import timezone

class Article(models.Model):
    titre = models.CharField(max_length=200)
    contenu = models.TextField()
    date_publication = models.DateTimeField(default=timezone.now)
    publie = models.BooleanField(default=False)

    class Meta:
        ordering = ['-date_publication']  # du plus récent au plus ancien

    def __str__(self):
        return self.titre

Les types de champs les plus utilisés

Appliquer les modifications à la base de données

Après toute modification du fichier models.py, vous devez toujours exécuter les deux commandes suivantes :

Copierpython manage.py makemigrations   # génère les fichiers de migration
python manage.py migrate          # applique les migrations à la BDD

5. urls.py : le routeur de votre application

Le routage dans Django fonctionne à deux niveaux (le fichier urls.py du projet principal inclut les URLs des apps). Chaque app possède son propre urls.py pour rester modulaire.

urls.py du projet principal (monprojet/urls.py)

Copierfrom django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('blog/', include('blog.urls')),  # délègue à l'app blog
]

urls.py de l'app blog (blog/urls.py) : à créer manuellement

Copierfrom django.urls import path
from . import views

app_name = 'blog'  # namespace pour éviter les conflits de noms

urlpatterns = [
    path('', views.liste_articles, name='liste'),
    path('/', views.detail_article, name='detail'),
]

Le paramètre name est crucial : il vous permet d'utiliser {% url 'blog:liste' %} dans vos templates sans coder l'URL en dur : vos liens restent valides même si vous changez la structure des URLs.

6. views.py : la logique applicative

Le fichier views.py contient des fonctions (ou des classes) qui reçoivent une requête HTTP et retournent une réponse HTTP. C'est ici que vit la logique de votre application : récupération des données, vérification des permissions, traitement des formulaires.

Vues basées sur des fonctions (FBV)

Copierfrom django.shortcuts import render, get_object_or_404
from .models import Article

def liste_articles(request):
    articles = Article.objects.filter(publie=True)
    return render(request, 'blog/liste.html', {'articles': articles})

def detail_article(request, pk):
    article = get_object_or_404(Article, pk=pk, publie=True)
    return render(request, 'blog/detail.html', {'article': article})

Vues basées sur des classes (CBV) : version avancée

Pour les opérations CRUD classiques, Django propose des vues génériques qui réduisent considérablement la quantité de code à écrire :

Copierfrom django.views.generic import ListView, DetailView
from .models import Article

class ListeArticles(ListView):
    model = Article
    template_name = 'blog/liste.html'
    context_object_name = 'articles'
    queryset = Article.objects.filter(publie=True)

class DetailArticle(DetailView):
    model = Article
    template_name = 'blog/detail.html'

7. Les templates : l'affichage HTML

Les templates sont des fichiers HTML enrichis d'un langage de gabarit (DTL : Django Template Language). Ils se trouvent dans le dossier templates/ de votre app, lui-même dans un sous-dossier portant le nom de l'app (convention recommandée).

Template de liste d'articles (blog/templates/blog/liste.html)

Copier<!-- Héritage de template -->
{% extends "base.html" %}


  <h1>Tous les articles</h1>

  
    <p>Aucun article publié pour l'instant.</p>
  

Les balises et filtres essentiels du DTL

8. admin.py : l'interface d'administration

L'un des atouts majeurs de Django est son interface d'administration générée automatiquement. Pour rendre un modèle accessible depuis /admin, déclarez-le dans admin.py :

Copierfrom django.contrib import admin
from .models import Article

@admin.register(Article)
class ArticleAdmin(admin.ModelAdmin):
    list_display = ['titre', 'date_publication', 'publie']
    list_filter = ['publie', 'date_publication']
    search_fields = ['titre', 'contenu']
    list_editable = ['publie']
    prepopulated_fields = {'slug': ('titre',)}  # si vous avez un champ slug

La classe ModelAdmin accepte de nombreuses options de personnalisation. Avec seulement quelques lignes, vous obtenez une interface de gestion complète avec recherche, filtres et édition en ligne.

9. forms.py : gérer les formulaires

Django propose un système de formulaires puissant qui gère automatiquement la validation des données, la protection CSRF et la liaison avec les modèles. Le fichier forms.py n'est pas créé automatiquement : vous devez le créer quand votre app nécessite des formulaires.

Copierfrom django import forms
from .models import Article

class ArticleForm(forms.ModelForm):
    class Meta:
        model = Article
        fields = ['titre', 'contenu', 'publie']
        widgets = {
            'contenu': forms.Textarea(attrs={'rows': 10}),
        }
        labels = {
            'titre': 'Titre de l\'article',
            'publie': 'Publier immédiatement',
        }

Un ModelForm est lié directement à un modèle : il génère les champs du formulaire à partir du modèle et peut sauvegarder directement l'objet avec form.save().

10. Quand créer de nouveaux fichiers et dossiers ?

Au fil du développement, votre projet va grandir et certains fichiers deviendront trop volumineux. Voici les règles pratiques pour savoir quand et quoi créer :

11. Organisation recommandée pour un projet réel

Voici la structure cible d'un projet Django bien organisé, avec plusieurs apps et tous les fichiers essentiels :