Pourquoi Django ?
Django est une plateforme web open-source qui permet aux développeurs de créer des applications web rapidement et efficacement. Son architecture MVC (Model-View-Controller) et son système d'objets relationnels (ORM) simplifient la gestion de la base de données et le développement logiciel en séparant les responsabilités.
Un cas concret est l'évolution d'un site e-commerce. Avec Django, un développeur peut rapidement mettre en place une structure robuste pour gérer les produits, les utilisateurs, les commandes et le paiement sans se préoccuper des détails techniques de la construction du site.
Prerequis
- Connaissance de base en Python (version 3.6 ou supérieure recommandée)
- Connaissance de base en HTML, CSS et JavaScript pour l'interface utilisateur frontale
- Installation d'un environnement de développement : Python, pip, et un éditeur de texte/code
- Optionnellement : Connaissance en SQL pour la compréhension du système d'objets relationnels Django
Concepts fondamentaux
1. Projets (Projects)
Un projet est une collection de configurations et de paramètres qui définit comment une application Django s'exécute.
## Dans le terminal, créez un nouveau projet Django nommé 'mon_projet'
django-admin startproject mon_projet
## Structure du projet généré :
## mon_projet/
## manage.py # Point d'entrée pour les commandes Django
## mon_projet/ # Le répertoire de base de votre projet
## __init__.py # Marque ce répertoire comme un package Python
## settings.py # Configuration de l'application
## urls.py # Gestionnaire des URL
## asgi.py # Point d'entrée pour les environnements ASGI (pour déploiement avec Django Channels)
## wsgi.py # Point d'entrée pour les environnements WSGI
2. Applications (Apps)
Une application est une partie de votre site web qui a une fonction spécifique, comme l'affichage du blog ou la gestion des utilisateurs.
## Dans le terminal, créez une nouvelle application Django nommée 'mon_app'
python manage.py startapp mon_app
## Structure de l'application généré :
## mon_app/
## migrations/ # Répertoire pour les fichiers de migration
## __init__.py # Marque ce répertoire comme un package Python
## 0001_initial.py # Fichier initial de migration
## admin.py # Configuration des modèles dans l'administration Django
## apps.py # Configuration de l'application
## models.py # Définition des modèles de données
## tests.py # Tests unitaires
## views.py # Fonctions et vues pour les requêtes HTTP
3. Modèles (Models)
Les modèles définissent la structure de vos données. Django utilise un ORM pour mapper ces modèles en tables SQL.
from django.db import models
class Article(models.Model):
titre = models.CharField(max_length=200)
contenu = models.TextField()
date_publication = models.DateTimeField(auto_now_add=True)
## Pour créer les tables dans la base de données, exécutez :
## python manage.py makemigrations
## python manage.py migrate
4. Vues (Views)
Les vues gèrent la logique métier et génèrent des réponses HTTP.
from django.shortcuts import render
from .models import Article
def accueil(request):
articles = Article.objects.all().order_by('-date_publication')
return render(request, 'accueil.html', {'articles': articles})
5. URL (URLconf)
Les URLconf est le système de gestion des URL pour votre application Django.
from django.urls import path
from . import views
urlpatterns = [
path('', views.accueil, name='accueil'),
]
6. Templates (Templates)
Les templates définissent la structure HTML et les données à afficher.
<!-- mon_app/templates/accueil.html -->
<!DOCTYPE html>
<html lang="fr">
<head>
<meta charset="UTF-8">
<title>Accueil</title>
</head>
<body>
<h1>Derniers articles</h1>
{% for article in articles %}
<article>
<h2>article.titre</h2>
<p>article.contenu|truncatewords:30</p>
<time>Publié le article.date_publication</time>
</article>
{% endfor %}
</body>
</html>
Mise en pratique : projet fil rouge
Nous allons créer une application simple pour un gestionnaire de tâches. L'application permettra d'afficher, ajouter, modifier et supprimer des tâches.
Étape 1 : Créer le projet et l'application
## Créez un nouveau projet Django nommé 'gestion_taches'
django-admin startproject gestion_taches
cd gestion_taches
## Créez une nouvelle application Django nommée 'tache'
python manage.py startapp tache
Étape 2 : Définir le modèle de données
## Dans mon_projet/tache/models.py
from django.db import models
class Tache(models.Model):
titre = models.CharField(max_length=200)
description = models.TextField()
completed = models.BooleanField(default=False)
## Créez les tables dans la base de données :
python manage.py makemigrations
python manage.py migrate
Étape 3 : Créer les vues
## Dans mon_projet/tache/views.py
from django.shortcuts import render, get_object_or_404, redirect
from .models import Tache
def taches_list(request):
taches = Tache.objects.all()
return render(request, 'taches_list.html', {'taches': taches})
def tache_detail(request, pk):
tache = get_object_or_404(Tache, pk=pk)
return render(request, 'tache_detail.html', {'tache': tache})
def tache_nouvelle(request):
if request.method == "POST":
titre = request.POST['titre']
description = request.POST['description']
Tache.objects.create(titre=titre, description=description)
return redirect('taches_list')
else:
return render(request, 'tache_form.html')
def tache_modifier(request, pk):
tache = get_object_or_404(Tache, pk=pk)
if request.method == "POST":
tache.titre = request.POST['titre']
tache.description = request.POST['description']
tache.completed = 'completed' in request.POST
tache.save()
return redirect('tache_detail', pk=tache.pk)
else:
return render(request, 'tache_form.html', {'tache': tache})
def tache_supprimer(request, pk):
tache = get_object_or_404(Tache, pk=pk)
if request.method == "POST":
tache.delete()
return redirect('taches_list')
else:
return render(request, 'tache_confirm_delete.html', {'tache': tache})
Étape 4 : Configurer les URL
## Dans mon_projet/tache/urls.py
from django.urls import path
from . import views
urlpatterns = [
path('', views.taches_list, name='taches_list'),
path('tache/<int:pk>/', views.tache_detail, name='tache_detail'),
path('tache/nouvelle/', views.tache_nouvelle, name='tache_nouvelle'),
path('tache/<int:pk>/modifier/', views.tache_modifier, name='tache_modifier'),
path('tache/<int:pk>/supprimer/', views.tache_supprimer, name='tache_supprimer'),
]
Ajoutez les URL de l'application au projet :
## Dans mon_projet/urls.py
from django.contrib import admin
from django.urls import include, path
urlpatterns = [
path('admin/', admin.site.urls),
path('', include('tache.urls')),
]
Étape 5 : Créer les templates
Créez un répertoire templates/tache et ajoutez les fichiers suivants :
<!-- mon_projet/templates/tache/taches_list.html -->
<!DOCTYPE html>
<html lang="fr">
<head>
<meta charset="UTF-8">
<title>Gestion des tâches</title>
</head>
<body>
<h1>Liste des tâches</h1>
<ul>
{% for tache in taches %}
<li>
tache.titre
<a href="{% url 'tache_detail' tache.pk %}">Détails</a> |
<a href="{% url 'tache_modifier' tache.pk %}">Modifier</a> |
<a href="{% url 'tache_supprimer' tache.pk %}">Supprimer</a>
</li>
{% empty %}
<li>Aucune tâche n'est enregistrée.</li>
{% endfor %}
</ul>
<a href="{% url 'tache_nouvelle' %}">Nouvelle tâche</a>
</body>
</html>
<!-- mon_projet/templates/tache/tache_detail.html -->
<!DOCTYPE html>
<html lang="fr">
<head>
<meta charset="UTF-8">
<title>tache.titre</title>
</head>
<body>
<h1>tache.titre</h1>
<p>tache.description</p>
<time>Publié le tache.date_publication</time>
<a href="{% url 'taches_list' %}">Retour à la liste</a>
</body>
</html>
<!-- mon_projet/templates/tache/tache_form.html -->
<!DOCTYPE html>
<html lang="fr">
<head>
<meta charset="UTF-8">
<title>tache.titre|default:"Nouvelle tâche"</title>
</head>
<body>
<h1>tache.titre|default:"Nouvelle tâche"</h1>
<form method="post">
{% csrf_token %}
<label for="titre">Titre:</label>
<input type="text" id="titre" name="titre" value="tache.titre">
<br><br>
<label for="description">Description:</label>
<textarea id="description" name="description">tache.description</textarea>
<br><br>
{% if tache.pk %}
<input type="submit" value="Modifier">
{% else %}
<input type="submit" value="Ajouter">
{% endif %}
</form>
</body>
</html>
<!-- mon_projet/templates/tache/tache_confirm_delete.html -->
<!DOCTYPE html>
<html lang="fr">
<head>
<meta charset="UTF-8">
<title>Supprimer tache.titre</title>
</head>
<body>
<h1>Êtes-vous sûr de vouloir supprimer "tache.titre"?</h1>
<form method="post">
{% csrf_token %}
<input type="submit" value="Supprimer">
</form>
<a href="{% url 'taches_list' %}">Annuler</a>
</body>
</html>
Étape 6 : Exécuter le serveur
python manage.py runserver
Ouvrez votre navigateur et accédez à http://127.0.0.1:8000/ pour voir l'application en action.
Erreurs frequentes et debugging
1. L'erreur "NoReverseMatch"
## Code incorrect qui cause l'erreur
<a href="{% url 'tache_detail' tache.pk %}">Détails</a>
## Correction
<a href="{% url 'tache_detail' tache.pk %}">Détails</a>
2. L'erreur "TemplateDoesNotExist"
## Code incorrect qui cause l'erreur
{% extends "base.html" %}
{% block content %}
<h1>tache.titre</h1>
{% endblock %}
## Correction
{% extends "base_generic.html" %}
{% block content %}
<h1>tache.titre</h1>
{% endblock %}
3. L'erreur "AttributeError: 'NoneType' object has no attribute"
## Code incorrect qui cause l'erreur
tache = Tache.objects.get(pk=pk)
## Correction
tache = get_object_or_404(Tache, pk=pk)
Pour aller plus loin
Apprendre les formulaires Django : Les formulaires sont essentiels pour la gestion des entrées utilisateur.
Intégrer l'authentification Django : Gérer les utilisateurs et leurs droits d'accès.
Utiliser les modèles de médias : Permettre le téléchargement et la gestion des fichiers.
Défi pratique
Développez une application simple pour un blog. L'application devrait permettre d'afficher, ajouter, modifier et supprimer des articles. Chaque article doit avoir un titre, un contenu et une date de publication.
Ce tutoriel vous a permis de commencer avec Django en créant une application complète pour un gestionnaire de tâches. En suivant les étapes, vous avez appris comment structurer un projet, définir des modèles, créer des vues et gérer les URL. Vous êtes maintenant prêt à approfondir vos connaissances en Django et à construire des applications web plus complexes.