Développement Web avec Django

Django est un framework web Python de haut niveau qui encourage un développement rapide et propre. Avec sa philosophie “batteries included”, Django fournit tout ce dont vous avez besoin pour construire des applications web robustes et maintenables.

Pourquoi choisir Django ?

Django offre de nombreux avantages pour le développement web :

• Rapide à développer : Django suit le principe DRY (Don’t Repeat Yourself) et automatise de nombreuses tâches
• Sécurisé par défaut : Protection contre les vulnérabilités web courantes (XSS, CSRF, injection SQL…)
• Scalable : Utilisé par des sites à fort trafic comme Instagram, Pinterest et Disqus
• Batteries included : ORM intégré, admin automatique, système de templates, authentification…
• Communauté active : Documentation excellente et nombreuses ressources disponibles

Installation et configuration

Pour commencer avec Django, installez-le via pip :

# Créer un environnement virtuel
python -m venv venv
source venv/bin/activate  # Sur Windows: venv\Scripts\activate

# Installer Django
pip install django

# Créer un nouveau projet
django-admin startproject monsite

# Naviguer vers le projet
cd monsite

# Créer une application
python manage.py startapp blog

Structure d’un projet Django

Un projet Django typique est organisé comme suit :

monsite/
    manage.py
    monsite/
        __init__.py
        settings.py
        urls.py
        asgi.py
        wsgi.py
    blog/
        __init__.py
        admin.py
        apps.py
        models.py
        tests.py
        views.py
        urls.py
        migrations/
        templates/
            blog/
                base.html
                index.html
                detail.html
        static/
            blog/
                css/
                js/
                images/

Modèles : définir vos données

Les modèles Django définissent la structure de vos données :

# blog/models.py
from django.db import models
from django.utils import timezone
from django.contrib.auth.models import User

class Category(models.Model):
    name = models.CharField(max_length=100)
    slug = models.SlugField(unique=True)
    
    def __str__(self):
        return self.name
    
    class Meta:
        verbose_name_plural = "categories"

class Post(models.Model):
    STATUS_CHOICES = (
        ('draft', 'Brouillon'),
        ('published', 'Publié'),
    )
    
    title = models.CharField(max_length=200)
    slug = models.SlugField(unique_for_date='publish')
    author = models.ForeignKey(User, on_delete=models.CASCADE, related_name='blog_posts')
    body = models.TextField()
    category = models.ForeignKey(Category, on_delete=models.CASCADE, related_name='posts')
    publish = models.DateTimeField(default=timezone.now)
    created = models.DateTimeField(auto_now_add=True)
    updated = models.DateTimeField(auto_now=True)
    status = models.CharField(max_length=10, choices=STATUS_CHOICES, default='draft')
    
    def __str__(self):
        return self.title
    
    class Meta:
        ordering = ('-publish',)

Après avoir défini vos modèles, créez et appliquez les migrations :

python manage.py makemigrations
python manage.py migrate

Vues : la logique de votre application

Les vues traitent les requêtes et renvoient des réponses :

# blog/views.py
from django.shortcuts import render, get_object_or_404
from django.core.paginator import Paginator
from .models import Post, Category

def post_list(request, category_slug=None):
    posts = Post.objects.filter(status='published')
    category = None
    
    if category_slug:
        category = get_object_or_404(Category, slug=category_slug)
        posts = posts.filter(category=category)
    
    paginator = Paginator(posts, 10)  # 10 posts par page
    page = request.GET.get('page')
    posts = paginator.get_page(page)
    
    return render(request, 'blog/post_list.html', {
        'posts': posts,
        'category': category
    })

def post_detail(request, year, month, day, post_slug):
    post = get_object_or_404(
        Post,
        slug=post_slug,
        status='published',
        publish__year=year,
        publish__month=month,
        publish__day=day
    )
    
    return render(request, 'blog/post_detail.html', {'post': post})

URLs : routage des requêtes

Configurez les URLs pour diriger les requêtes vers les vues appropriées :

# blog/urls.py
from django.urls import path
from . import views

app_name = 'blog'

urlpatterns = [
    path('', views.post_list, name='post_list'),
    path('category/<slug:category_slug>/', views.post_list, name='post_list_by_category'),
    path('<int:year>/<int:month>/<int:day>/<slug:post_slug>/', views.post_detail, name='post_detail'),
]

# monsite/urls.py
from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('blog/', include('blog.urls', namespace='blog')),
]

Templates : l’interface utilisateur

Les templates définissent comment les données sont présentées :

<!-- blog/templates/blog/base.html -->
<!DOCTYPE html>
<html>
<head>
    <title>{% block title %}Mon Blog{% endblock %}</title>
    <link rel="stylesheet" href="{% static 'blog/css/style.css' %}">
</head>
<body>
    <header>
        <h1>Mon Blog</h1>
        <nav>
            <ul>
                <li><a href="{% url 'blog:post_list' %}">Accueil</a></li>
                {% for cat in categories %}
                <li><a href="{% url 'blog:post_list_by_category' cat.slug %}">{{ cat.name }}</a></li>
                {% endfor %}
            </ul>
        </nav>
    </header>
    
    <main>
        {% block content %}
        {% endblock %}
    </main>
    
    <footer>
        <p>&copy; {% now "Y" %} Mon Blog</p>
    </footer>
</body>
</html>

<!-- blog/templates/blog/post_list.html -->
{% extends "blog/base.html" %}

{% block title %}
    {% if category %}{{ category.name }}{% else %}Articles{% endif %}
{% endblock %}

{% block content %}
    <h2>
        {% if category %}
            Articles dans la catégorie "{{ category.name }}"
        {% else %}
            Tous les articles
        {% endif %}
    </h2>
    
    {% for post in posts %}
        <article>
            <h3><a href="{{ post.get_absolute_url }}">{{ post.title }}</a></h3>
            <p class="date">Publié le {{ post.publish }} par {{ post.author }}</p>
            <p>{{ post.body|truncatewords:30|linebreaks }}</p>
        </article>
    {% empty %}
        <p>Aucun article disponible.</p>
    {% endfor %}
    
    {% include "pagination.html" with page=posts %}
{% endblock %}

Administration Django

Django fournit une interface d’administration prête à l’emploi :

# blog/admin.py
from django.contrib import admin
from .models import Category, Post

@admin.register(Category)
class CategoryAdmin(admin.ModelAdmin):
    list_display = ('name', 'slug')
    prepopulated_fields = {'slug': ('name',)}

@admin.register(Post)
class PostAdmin(admin.ModelAdmin):
    list_display = ('title', 'slug', 'author', 'publish', 'status')
    list_filter = ('status', 'created', 'publish', 'author')
    search_fields = ('title', 'body')
    prepopulated_fields = {'slug': ('title',)}
    raw_id_fields = ('author',)
    date_hierarchy = 'publish'
    ordering = ('status', 'publish')

Lancer le serveur de développement

Pour tester votre application :

python manage.py runserver

Accédez à http://127.0.0.1:8000/ dans votre navigateur.

Fonctionnalités avancées

Django offre de nombreuses fonctionnalités avancées :

• Authentification : Système complet de gestion des utilisateurs
• Formulaires : Création, validation et traitement de formulaires
• Tests : Framework de test intégré
• Internationalisation : Support multilingue
• Cache : Plusieurs niveaux de mise en cache
• Sécurité : Protection contre les attaques courantes

Déploiement

Pour déployer une application Django en production :

1. Configurer les paramètres de production dans settings.py
2. Collecter les fichiers statiques : python manage.py collectstatic
3. Choisir un serveur WSGI comme Gunicorn ou uWSGI
4. Configurer un serveur web comme Nginx ou Apache
5. Utiliser une base de données robuste comme PostgreSQL

Conclusion

Django est un framework puissant qui vous permet de construire rapidement des applications web complexes et sécurisées. Sa philosophie “batteries included” et sa structure bien organisée en font un excellent choix pour les développeurs Python qui souhaitent créer des sites web robustes et maintenables.

Que vous construisiez un simple blog, un site e-commerce ou une application web complexe, Django vous fournit les outils nécessaires pour réussir votre projet.