Django
1. Qu’est ce que Django
Django est un outil qui facilite la création de meilleures applications Web plus
rapidement et avec moins de code.
(Lien documentation: [Link] )
2. Pourquoi Django
Avec Django, vous pouvez faire passer les applications Web du concept au
lancement en quelques heures. Django prend en charge une grande partie des
tracas du développement Web, vous pouvez donc vous concentrer sur l'écriture
de votre application sans avoir à réinventer la roue. C'est gratuit et open source.
(Lien documentation: [Link] )
3. Comment installer Django
(Lien documentation : [Link] )
3-1. Python
Python est un langage de programmation puissant et facile à apprendre. Il
dispose de structures de données de haut niveau et permet une approche simple
mais efficace de la programmation orientée objet. Parce que sa syntaxe est
élégante, que son typage est dynamique et qu'il est interprété, Python est un
langage idéal pour l'écriture de scripts et le développement rapide
d'applications dans de nombreux domaines et sur la plupart des plateformes.
(Lien documentation: [Link] ,
[Link] , [Link] )
3-1-1. Télécharger python
(Lien Téléchargement: [Link] )
3-2. Installer Django
3-2-1. Environnement virtuels
Un environnement virtuel est un dossier qui contient une installation de Python
pour une version particulière de Python ainsi que des paquets additionnels.
( Lien documentation : [Link] )
3-2-2. Installation de virtualenv
pip install virtualenv
3-2-3. Création d’un environnement virtuel
py -m venv nom_environnement_virtuel # (sur windows)
ou
python -m venv nom_environnement_virtuel # (sur macos)
Exemple :
py -m venv test_venv
3-2-3. Activation d’un environnement virtuel
cd test_venv # (On se déplace dans le dossier test_venv)
cd Scripts # (On se déplace dans le dossier Scripts)
activate # (Activation de l’environnement virtuel)
cd .. # (Retour dans le dossier précédent)
cd .. # (Retour dans le dossier précédent)
ou avec le raccourci
test_venv\Scripts\activate
3-3. Installer django (Installe la dernière version de django)
pip install django
ou en spécifiant la version de django à installer(4.1.3 par exemple)
pip install Django==4.1.3
Note : Comment mettre à jour pip
[Link] -m pip install --upgrade pip
3-4. Créer un nouveau projet
django-admin startproject nom_du_projet
Note : Liste des commandes disponible pour django-admin
django-admin help
Déplacement dans le dossier du projet
cd nom_du_projet
Lancer le server local
py [Link] runserver
Interrompre le server local
ctrl + c
3-5. Créer une application
py [Link] startapp website
ou
django-admin startapp website
Quelle est la différence entre un projet et une application ?
Une application est une application Web qui fait quelque chose – par exemple un
système de blog, une base de données publique ou une petite application de
sondage. Un projet est un ensemble de réglages et d’applications pour un site
Web particulier. Un projet peut contenir plusieurs applications. Une application
peut apparaître dans plusieurs projets.
Pour plus d’information :
[Link]
4. Créer du projet Checknote
4-1. Activation de l’environnement virtuel
test_venv\Scripts\activate
4-1. Création du projet
django-admin startproject checknote
4-2. Création de l’application
On se place dans le dossier du projet créé
cd checknote
création de l’application noteapp
django-admin startapp noteapp
4-3. Ajout de l’application noteapp comme application dans notre projet dans le fichier
[Link]. (emplacement : checknote\[Link])
INSTALLED_APPS = [
'[Link]',
'[Link]',
'[Link]',
'[Link]',
'[Link]',
'[Link]',
'noteapp',
]
4-4. Accès au site d’administration de django
Les Migrations:
Les migrations sont la manière par laquelle Django propage des modifications que vous
apportez à des modèles (ajout d’un champ, suppression d’un modèle, etc.) dans un
schéma de base de données.
● migrate, qui est responsable de l’exécution et de l’annulation des migrations.
● makemigrations, qui est responsable de la création de nouvelles migrations en
fonction des modifications que vous avez apportées aux modèles.
● sqlmigrate, qui affiche les instructions SQL correspondant à une migration.
● showmigrations, qui affiche la liste des migrations d’un projet ainsi que leur
état.
Vous devez imaginer les migrations comme un système de contrôle de versions pour un
schéma de base de données. makemigrations se charge de regrouper vos changements
de modèle dans des fichiers de migration individuels - comme des commits et migrate
est chargé d’appliquer les changements à la base de données.
Les fichiers de migration pour chaque application sont stockés dans un répertoire «
migrations » à l’intérieur de l’application, et sont conçus pour faire partie du code
source et de la distribution de cette application. Les migrations sont créées une fois
sur votre machine de développement, puis exécutées telles quelles sur les machines de
vos collègues, les machines de tests, et finalement sur les machines de production.
4-4-1. Migration initiale(Création des schémas par défaut dont la table des utilisateurs)
py [Link] migrate
4-4-2. Création du super utilisateur
py [Link] createsuperuser
Note : Les informations à fournir
● Nom d’utilisateur
● Email (facultatif)
● Mot de passe
● Confirmation mot de passe (Les 2 mot de passes doivent être identiques)
4-4-3. Lancement du server de développement interne de django
py [Link] runserver
Dans un navigateur : [Link] ou [Link] pour
accéder au site d’administration et on utilise les identifiants du super utilisateur pour
s’y connecter.
5. Configuration du site d’administration
5-1. Création de models
Modèle :
Un modèle est la source d’information unique et définitive à propos de vos données. Il
contient les champs et le comportement essentiels des données que vous stockez.
Généralement, chaque modèle correspond à une seule table de base de données.
Les bases :
● Chaque modèle est une classe Python qui hérite de [Link].
● Chaque attribut du modèle représente un champ de base de données.
● Avec tout ça, Django vous offre une API d’accès à la base de données générée
automatiquement ;
Model Étudiant
class Etudiant([Link]):
matricule = [Link](unique=True,max_length=50)
nom = [Link](max_length=50)
prenom = [Link](max_length=50)
date_nais = [Link]()
telephone = [Link](unique=True, max_length=20)
classe = [Link](max_length=50)
def __str__(self):
return [Link] + " " + [Link]
Model Notes
class Note([Link]):
etudiant = [Link](Etudiant, on_delete=[Link])
evaluation = [Link](max_length=50)
. . .
class Meta:
verbose_name = "NOTE"
verbose_name_plural = "NOTES"
def __str__(self):
# return str([Link])
return [Link]
Création des fichier de migration
py [Link] makemigrations
Application des migrations sur la base de données
py [Link] migrate
Ajout des models sur le site d’administration (emplacement : noteapp\[Link])
from [Link] import admin
from .models import Etudiant, Notes
[Link](Etudiant)
[Link](Notes)
Création des class admin
class EtudiantAdmin([Link]):
list_display = ['matricule','nom', 'prenom', 'genre', 'classe', ]
list_filter = ('nom', 'genre')
search_fields = ('nom', 'prenom',)
class NoteAdmin([Link]):
list_display = ['python', 'base_donne', 'ccna', 'calculeMoyenne' ]
list_filter = ('etudiant',)
search_fields = ('etudiant__nom', 'etudiant__prenom',)
def calculeMoyenne(self, obj):
moyenne = ([Link] + obj.base_donne + [Link]) / 3
return moyenne
[Link](Etudiant, EtudiantAdmin)
[Link](Notes, NoteAdmin)
6- Création du site web
Les vues(views)
Une fonction de vue, ou vue pour faire simple, est une fonction Python acceptant une
requête web et renvoyant une réponse web. Cette réponse peut contenir le contenu
HTML d’une page web, une redirection, une erreur 404, un document XML, une image…
ou vraiment n’importe quoi d’autre. La vue elle-même contient la logique nécessaire pour
renvoyer une réponse. Ce code peut se trouver à l’emplacement de votre choix, pour
autant qu’il soit dans le chemin Python. Il n’y a pas d’autres exigences, pas de « magie »
comme on dit. Mais comme il faut bien mettre ce code quelque part, la convention est de
placer les vues dans un fichier nommé [Link] se trouvant dans un projet ou un
répertoire d’application.
(Pour plus d’information : [Link]
Ecriture de nos vues (Emplacement : noteapp\[Link])
from [Link] import render
from [Link] import HttpResponse
from .models import *
# Create your views here.
def index(request):
return render(request, 'noteapp/[Link]')
def notes(request):
note_list = [Link](etudiant__matricule=[Link]['matricule'])
context = {'note_list': note_list}
return render(request, 'noteapp/[Link]', context)
Les Templates(Gabarits) :
Par sa nature liée au Web, Django a besoin d’un procédé agile de génération dynamique
de HTML. L’approche la plus couramment utilisée est de se baser sur des [Link]
gabarit contient la partie statique du résultat HTML souhaité ainsi qu’une certaine
syntaxe particulière définissant comment insérer le contenu dynamique.
Pour plus d’informations : [Link]
Gabarits
Un gabarit est un fichier texte. Il peut générer tout format basé sur du texte (HTML,
XML, CSV, etc.).
Un gabarit contient des variables qui sont remplacées par des valeurs lorsque le gabarit
est évalué, ainsi que des balises qui contrôlent la logique du gabarit.
Voici un gabarit minimal illustrant quelques principes de base. Chaque élément sera
ensuite expliqué plus loin dans ce document.
Variables
Une variable affiche une valeur à partir du contexte, qui est un objet de type
dictionnaire faisant correspondre des clés à des valeurs.
Les variables sont entourées par {{ et }} comme ceci :
Mon nom est : {{ nom }} et prénom : {{ prenom}}.
Et dans [Link] on aura :
def notes(request):
variableNom = "Touré"
variablePrenom = "Oumar"
context = {'nom': nom, 'prenom': variablePrenom}
return render(request, 'testapp/[Link]', context)
Resultat dans la page html :
Mon nom est : Touré et prénom Oumar
Balises
Les balises permettent d’appliquer une logique arbitraire dans le processus de rendu.
Cette définition est volontairement vague. Par exemple, une balise peut produire du
contenu, servir de structure de contrôle telle qu’une instruction « if » ou une boucle «
for », extraire du contenu d’une base de données ou même de donner accès à d’autres
balises de gabarit.
Les balises sont entourées par {% et %}, comme ceci (quelques balises) :
{% csrf_token %}
Balise pour les urls
{% url 'nom url' %}
Balise pour faire une condition
{% if condition %} Bonjour, {{ [Link] }}.{% endif %}
Balise pour parcourir un ensemble d'élément (Liste d’objet par exemple)
{% for elt in list%}
Le nom est : {{ [Link] }}.
{% endif %}
Pour faire des commentaires
{% comment %} Ceci est un commentaire {% endcomment %}
Pour permettre le chargement de fichiers static(js, css) dans le fichier html
{% load static %}
Pour hériter d’un template
{% extends 'nom_application/nom_fichier.html' %}
Redéfinir le contenu d’un template (héritage)
{% block content %} Le contenu ici {% endblock %}
Et etc… Pour plus d’information :
[Link]
Création de nos templates :
Note :
Tout d’abord, créez un répertoire nommé templates dans votre répertoire noteapp.
C’est là que Django recherche les gabarits(pour l’application noteapp).
Puis créez un répertoire nommé noteapp (exactement le nom de l’application)
Arborescence du Dossier : noteapp/templates/noteapp
Puis créez les fichier suivants : [Link], [Link] et [Link]
Le template principale : [Link] (chemin : noteapp/templates/noteapp/[Link])
{% load static %}
<!DOCTYPE html>
<html lang="en">
<head>
. . .
{% comment %} Intégration du fichier static css{% endcomment %}
<link rel="stylesheet" href="{% static 'noteapp/css/[Link]'
%}">
</head>
<body>
{% comment %} Partie Logo {% endcomment %}
<div class="vr"></div>
<div class="container text-center">
<img src="{% static 'noteapp/images/logo_isc.png' %}"alt="Logo isc">
<h3>ISC BUSSINESS SCHOOL</h3>
</div>
<div class="vr"></div>
{% comment %} Le contenue des autres pages {% endcomment %}
{% block content %}
{% comment %} Le contenu pages seront ici {% endcomment %}
{% endblock content %}
{% comment %}Intégration du fichier static js {% endcomment %}
<script src="{% static 'noteapp/js/[Link]' %}"></script>
</body>
</html>
La page d’accueil : [Link] (chemin : noteapp/templates/noteapp/[Link])
{% extends 'noteapp/[Link]' %}
{% load static %}
{% block content %}
<div class="card">
<div class="card-header">
<h1>Formulaire de Recherche</h1>
</div>
<div class="card-body">
<div >
<form action="{% url 'notes' %}" method="post">
{% csrf_token %}
<fieldset>
<div class="row">
<label for="matricule" class="">Numéro matricule</label>
<input type="text" class="form-control" name="matricule"
placeholder="Entrez votre numero matricule ici">
</div>
</fieldset>
<input type="submit" class="btn btn-primary" value="Chercher">
</form>
</div>
</div>
</div>
{% endblock content %}
La page notes: [Link] (chemin : noteapp/templates/noteapp/[Link])
{% extends 'noteapp/[Link]' %}
{% load static %}
{% block content %}
<div class="container">
<h2>Les Notes : </h2>
<table class="table table-striped table-bordered ">
<thead>
<tr>
<td>ETUDIANT</td>
<td>SEMESTRE</td>
<td>PYTHON</td>
<td>BASE DE DONNEES</td>
<td>CCNA</td>
</tr>
</thead>
<tbody>
{% for note in note_list %}
<tr>
<td>{{ [Link] }}</td>
<td>{{ [Link] }}</td>
<td>{{ [Link] }}</td>
<td>{{ note.base_donne }}</td>
<td>{{ [Link] }}</td>
</tr>
{% endfor %}
</tbody>
</table>
</div>
{% endblock content %}
Gestion des URL
Fichier d’url principale : [Link] (chemin : checknote/[Link])
from [Link] import admin
from [Link] import path
from [Link] import include
urlpatterns = [
path('admin/', [Link]),
path('', include('[Link]'))
]
Créez un fichier nommé [Link] dans le dossier noteapp (noteapp/[Link])
from [Link] import path
from . import views
urlpatterns = [
path('', [Link], name="index"),
path('notes', [Link], name="notes"),
]