Django

Présentation de la bibliothèque Django

Django est un framework web Python de haut niveau gratuit et open source. Il permet de créer rapidement des applications web complexes, sécurisées, maintenables et évolutives avec mise à l'échelle.

Il utilise l'architecture MVT : Modèle-Vue-Template. Son ORM permet de gérer la base de données en back end côté serveur et le template permet d'afficher les données envoyées par la vue pour afficher la page HTML en front end côté client. Les modules urls et forms sont très utiles pour définir les urls et les formulaires. Enfin, l''interface d'aministration est aussi très pratique.

De célèbres applications utilisent Django parmis lesquelles on peut citer Instagram, Spotify, Youtube, Google Search, DropBox et Mozilla.

La première version est sortie en 2005 et la version 5 est sortie fin 2023.

Commencer

Création d'un projet, d'une application et lancement du serveur

Créer un projet

La fonction startproject

Pour créer le projet monprojet, rentrer la commande suivante dans le terminal.

Terminal powershell

```
> django-admin startproject monprojet
```

Créer une application

La fonction startapp

Pour créer l'application nomapp, se placer à la racine du projet dans le répertoire avec manage.py et rentrer la commande suivante dans le terminal.

Terminal powershell

```
> python manage.py startapp monapp
```

Configurer l'application

Dans le fichier settings

Dans le fichier settings.py, rubrique INSTALLED_APPS, ajouter monapp

Fichier settings.py

```
INSTALLED_APPS = [
    'monapp',
]
```

Lancer le serveur

La fonction runserver

Pour tester monprojet, démarrer le serveur avec la commande suivante puis coller l'URL http://127.0.0.1:8000 dans votre navigateur web. Si tout s'est bien passé, la fusée Django avec un message de félicitations devraient s'afficher.

Terminal powershell

```
> python manage.py runserver
```

Navigateur web

The install worked successfully! Congratulations!

Page web

Afficher le contenu du template HTML dans le navigateur web grâce à la vue appelée via l’URL

Fichier urls du projet

Ajoute une nouvelle règle

Dans le répertoire monprojet, compléter le fichier urls.py afin créer une nouvelle règle.
Rediriger les requêtes dont l’URL commence par monapp vers le fichiers urls de l'application.
Le namespace monapp évite les conflits d'urls avec d’autres apps.

Fichier urls.py dans mon monprojet


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


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

Fichier urls de l'application

Redirection vers la vue

Dans le répertoire monapp, créer le fichier urls.py.
La route '' désigne l'URL monapp qui appelle la fonction monapp dans le fichier views.py.
Le paramètre name='monapp' donne un nom à cette URL ce qui est pratique pour la référencer dans les templates ou dans le code (avec {% url 'monapp:monapp' %}).

Fichier urls.py dans mon monapp


from django.urls import path

from . import views

app_name = 'monapp'
urlpatterns = [
    path('', views.monapp, name='monapp'),
]

La vue

Génère le template

Dans le répertoire monapp, compléter le fichier views.py.
Dans la vue, la fonction monapp prend en entrée un objet request (la requête HTTP envoyée par l’utilisateur) et génére le template chat.html grâce à la fonction render.
Nous verrons le contexte par la suite.

Fichier views.py dans mon monapp


from django.shortcuts import render


def chat(request):
    context = {}

    return render(request, 'monapp/monapp.html', context)

Le template

Création du template

Dans le répertoire templates à la racine de monprojet, création du répertoire monapp et du template Django monapp.html.

Fichier template.html dans templates/monapp


<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>monapp</title>
</head>
<body>
    <div>
        <p>Hello monapp</p>
    </div>
</body>
</html>

Fichier settings

Répertoire des templates

Dans le répertoire monprojet, compléter le fichier settings.py afin cavec le répertoire des templates.

Fichier settings.py


import os


TEMPLATES = [
    {
        ...,
        'DIRS': [os.path.join(BASE_DIR, 'templates')],
        ...,
    },
]

L'affichage

Visualiser le template html dans le navigateur.

Dans le terminal powershell, relancer l'application

```
python manage.py runserver
```

Dans le navigateur web accéder à la page web de l'application monapp à l'url http://127.0.0.1:8000/monapp

```
Hello monapp
```

Parcours d’une requête HTTP Django

De l’URL à la page affichée

Requête HTTP (avec URL) → Analyse des URLs → Appel de la vue → Rendu du template → Génération de la réponse HTTP → Envoi au navigateur

ORM

L'ORM Django (Object-Relational Mapping) permet d'intéragir avec la base de données en manipulant des objets Python, les modèles, sans coder en SQL.

Base de données

Elle est définie dans le fichier settings.

Dans le fichier settings.py, rubrique DATABASES, la base de données sqlite3 nommée db est définie par défaut.
J'utilise DB Browser comme gestionnaire de base de données SQLite.
Pour des projets plus importants, j'utilise plutôt une base de données PostgreSQL.

Fichier settings.py


DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': BASE_DIR / 'db.sqlite3',
    }
}

Le modèle

Création d'un objet python qui servira de table SQL

Dans le répertoire monapp, compléter le fichier model.py avec la classe MonModele.
Le champ1 est de type texte avec une longueur max de 255 caractères.
Le champ 2 est de type date et se remplit autamatiquement.
Le champ 3 est de type décimal. Il peut par exemple servir pour un prix.
Les paramètres blank=True, null=True signifient que le champ peut-être vide.

Fichier model.py dans monapp


from django.db import models


class MonModele(models.Model):
    champ1 = models.CharField(max_length=255)
    champ2 = models.DateTimeField(auto_now_add=True, blank=True, null=True)
    champ3 = models.DecimalField(max_digits=7, decimal_places=2, blank=True, null=True)

    def __str__(self):
        return self.champ1

    class Meta:
        ordering = ['champ1']

L'interface admin

Pour gérer la base de données depuis le navigateur web

Dans le répertoire monapp, compléter le fichier admin.py.


from django.contrib import admin

from .models import MonModele


@admin.register(MonModele)
class MonModeleAdmin(admin.ModelAdmin):
    list_display = ('champ1', 'champ2', 'champ3')

Dans le terminal powershell, créer les tables de la base de donnéesdb.sqlite3 à la racine du projet.
Le suivi des migrations se fait dans monapp/migrations.


python manage.py makemigrations
python manage.py migrate

Dans le terminal powershell, créer le super-utilisateur nommé admin.

```
python manage.py createsuperuser
```

Dans le terminal powershell, relancer l'application

```
python manage.py runserver
```

Dans le navigateur web accéder à l'interface admin et créer une instance de MonModèle à l'url http://127.0.0.1:8000/admin/.

Les formulaires

Formulaire simple

Créer un formulaire

La classe Form de Django

Dans le répertoire monapp, créer le fichier forms.py
Créer la classe MonFormulaire héritée de la classe Form de Django et ajouter le champs de formulaire champs1 qui contient 255 caractères max.

Fichier forms.py


from django import forms

class MonFormulaire(forms.Form):
    champs1 = forms.CharField(label='Champs', max_length=255)