Premier projet Django sous Windows

(Crédit image : Technologie vecteur créé par vectorjuice – fr.freepik.com)

Introduction

Dans cet article, nous allons voir comment installer Django et créer un premier projet web avec ce Framework.

Tout d’abord, commençons par voir la configuration de base de tout projet Django.

Nous devons installer dans l’ordre ces trois composants :

Python,
un environnement virtuel,
Django.

Après l’installation de notre environnement de développement, nous pourrons alors créer notre première application Django et la lancer sur un serveur de développement en local.

Avant-Propos

Les environnement virtuels

La création d’un environnement virtuel est optionnelle mais fortement recommandée pour acquérir les bonnes pratiques de programmation et assurer une meilleure gestion des projets. En effet, vous aurez l’occasion de développer plusieurs projets, qui pourront nécessiter l’installation de différentes versions de Python ou Django, ainsi que différentes dépendances (packages ou bibliothèques) pour chacun de vos projets. En utilisant les environnement virtuels, chaque projet Python a son environnement propre et est isolé des autres. C’est ainsi que vous pourrez éviter tout conflit entre les dépendances des projets.

Django Apps

Après avoir installé les composants de base d’un projet Django, nous pourrons alors créer ledit “projet”. Avant d’aller plus loin, j’aimerais éclaircir les notions de “projet” et “application” dans le contexte du développement web avec le Framework Django.

Dans Django, il y’a cette notion de “Apps” qui se réfère aux “applications web” dans un projet Django. Pour ceux qui ont déjà programmé dans d’autre langages, disons que lorsqu’on parle de “projet Django” on parle de l’application toute entière, qui est souvent décomposée en modules. Ces modules dans Django sont appelés “Apps”.

Donc pour faire simple, un projet Django correspond à notre application web, qui est composée d’une ou de plusieurs “parties” (ou “modules”) et que nous appellerons “applications” ou “apps”.

Passons maintenant à la pratique ! Vous verrez que c’est assez simple et rapide.

Installation et configuration de base

Installer Python

Nous avons vu comment installer Python dans cet article. Si ce n’est pas encore fait, il vous suffit de suivre les étapes édictées.

Créer le répertoire du projet

Après avoir installé Python, il faut créer le répertoire dans lequel se trouvera le projet Django. Pour cela, ouvrez l’invite de commande, positionnez-vous sur le disque ou le répertoire de votre choix et utilisez la commande mkdir [nom_du_répertoire].

D:\>mkdir monprojet

Créer un environnement virtuel

Pour encapsuler le projet et l’isoler des éventuels autres projets que vous créerez dans le futur, nous devons créer un environnement virtuel.

Pour cela, on se positionne à la racine du projet :

D:\>cd monprojet

Puis, on crée l’environnement virtuel à l’aide de la commande qui suit :

D:\monprojet>python -m venv venv

Activer l’environnement virtuel

On doit ensuite activer l’environnement virtuel fraichement créé à l’aide d’un script, comme ceci :

D:\monprojet>venv\Scripts\activate

Une fois activé, vous verrez le nom de votre environnement sur la gauche de votre ligne de commande :

(venv) D:\monprojet>

Installer Django

On peut maintenant installer Django dans notre environnement virtuel à l’aide de la commande Pip. Avant cela, il est possible de mettre à niveau la commande Pip comme ceci :

(venv) D:\monprojet>python -m pip install --upgrade pip

Installons maintenant Django :

(venv) D:\monprojet>pip install django

Et voila ! Nous avons mis en place notre configuration de base.

Création du projet Django

Créer un nouveau projet Django

Créons maintenant notre premier projet Django avec la commande django-admin startproject [nom_du_projet] :

(venv) D:\monprojet>django-admin startproject monprojet

La structure de notre projet devrait ressembler à ceci :

monprojet/         
├── monprojet/          <─── répertoire du projet Django
│   ├── monprojet/
│   │   ├── __init__.py <─── indique que le projet est un package Python
│   │   ├── asgi.py     <─── utilisé pour le déploiement
│   │   ├── settings.py <─── fichier de configuration du projet
│   │   ├── urls.py     <─── fichier de configuration URL du projet
│   │   └── wsgi.py     <─── utilisé pour le déploiement
│   └── manage.py       <─── utilisé pour lancer les commandes de gestion du projet
└── venv/               <─── répertoire de l'environnement virtuel

On verra ce que fait chaque composant plus en détails dans un prochain article.

Lancer le serveur

Après avoir créé le projet, on se positionne à la racine de ce dernier :

(venv) D:\monprojet>cd monprojet

Afin de vous simplifier la vie, un serveur de développement est inclus dans l’installation de Django. Ce serveur vous permet de vous concentrer sur le développement de votre projet et de tester votre travail sans que vous n’ayez à vous soucier de la configuration d’un serveur web de production.

On lance le serveur de développement Django comme ceci :

(venv) D:\monprojet\monprojet>python manage.py runserver

On lance ensuite notre navigateur web et on tape dans la barre URL http://127.0.0.1:8000 et on peut alors voir que notre serveur est bel et bien lancé.

Si vous êtes arrivés jusqu’ici, félicitations ! Vous avez démarré votre premier projet Django avec succès.

Pour arrêter le serveur, tapez Ctrl+C dans l’invite de commande.

Première application Django

Comme nous l’avons dit plus haut, pour réaliser un projet web, il est souvent préférable de le décomposer en plusieurs modules. Ici nous parlons d’une décompositions en applications ou “apps”. Selon la taille du projet et la logique de programmation, un projet peut contenir une ou plusieurs applications.

Pour ce premier tutoriel, notre projet sera assez basique et nous ne créerons alors qu’une seule “application”.

Donc pour commencer, l’application consistera en une simple page web qui nous dira bonjour avec un joli “Hello, World!”.

Créer l’application

Pour notre application, que nous nommerons “hello_world”, nous utiliserons la commande django-admin startapp [nom_de_l'application].

(venv) D:\monprojet\monprojet>django-admin startapp hello_world

Cela va créer un nouveau répertoire sous le nom de “hello_world”.

monprojet/
├── monprojet/
│   ├── hello_world/    <─ répertoire de l'application Django
│   │   ├── migrations/ <─ répertoire qui conserve les fichiers qui enregistrent les modifications dans "models.py"
│   │   │  └── __init__.py
│   │   ├── __init__.py <─ indique que l'application est un package Python
│   │   ├── admin.py   <─ fichier de configuration des pages d'administration Django
│   │   ├── apps.py    <─ fichier de configuration de l'application
│   │   ├── models.py  <─ dédié à la création des modèles définissant la base de données
│   │   ├── tests.py   <─ utilisé pour les tests unitaires
│   │   └── views.py   <─ contient les fonctions/classes qui gèrent les requêtes/réponses web
│   ├── monprojet/
│   │   ├── __init__.py
│   │   ├── asgi.py
│   │   ├── settings.py
│   │   ├── urls.py
│   │   └── wsgi.py
│   ├── db.sqlite3
│   └── manage.py
└── venv/

Installer l’application dans le projet

Maintenant, nous allons effectuer les configuration nécessaires au niveau de notre projet pour pouvoir utiliser l’application nouvellement créée. Pour ce faire, il faut ouvrir le fichier “settings.py” et ajouter l’application “hello_world” à la variable INSTALLED_APPS.

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'hello_world',
]

Vous remarquerez que certaines applications externes à ce projet sont préinstallées. Ces applications permettent de gérer les fonctionnalités communes aux applications web (authentification, gestion du style et des fichiers statiques, gestion des sessions, …etc.).

Comme nous l’avons vu dans l’article La philo derrière Django : Architecture du Framework, Django repose sur l’architecture MVT (Model, View, Template). Nous allons maintenant écrire notre première “vue” (“View” en anglais).

Première Vue

Pour ce tutoriel, on va commencer par écrire une simple page web.

Dans Django, les vues représentent l’ensembles des classes et des fonctions écrites dans le fichier “views.py”. Celles-ci permettent de gérer les réponses aux requêtes http.

Pour écrire notre première vue, il faut ouvrir le fichier “views.py”, qui se trouve dans le répertoire de l’application. On va y définir une fonction (une vue) que l’on appellera “home”. Cette fonction va appeler la fonction render(), qui prend comme paramètre une requête http (“request” en anglais) lors du chargement d’une page web et qui va nous retourner le fichier HTML “hello_world.html”, que nous créerons juste après.

On ajoute donc le code suivant à notre fichier “views.py” :

from django.shortcuts import render

def home(request):
    return render(request, 'hello_world.html', {})

Premier Template HTML

Définissons maintenant le fichier ou Template HTML “hello_world.html”, qui s’affichera à l’utilisateur. La fonction render() cherchera le Template HTML dans un répertoire dédié qu’on nommera “templates”.

Nous devons donc d’abord créer, au niveau du répertoire de l’application, le répertoire “templates” , dans lequel nous créerons le fichier “hello_world.html”.

On va ensuite ouvrir notre fichier HTML et y ajouter la ligne suivante :

<h1>Hello, World!</h1>

Configuration URL

En dernier lieu, nous devons définir les URL qui nous permettront d’accéder aux pages de l’application. Ici, nous avons seulement défini une seule vue. Pour définir l’URL de celle-ci, nous devons d’abord créer le fichier “urls.py” dans le répertoire de notre application “hello_world”.

Dans le fichier “urls.py”, on importe l’objet path pour définir les chemins vers nos vues, ainsi que les vues de notre application “hello_world”.

On crée une liste “URL patterns” pour définir les chemins des différentes vues. Nous allons créer une URL pour la fonction vue home que nous avons définie dans le fichier “views.py”.

from django.urls import path
from hello_world import views

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

Ensuite, dans le fichier “urls.py” qui se trouve au niveau du répertoire de notre projet, on doit inclure la configuration URL de notre application. On ajoute donc la ligne path('', include('hello_world.urls')) qui va inclure les URLs définies dans le module “hello_world.urls” (le fichier “urls.py”) que nous avons créé plus haut dans le répertoire de notre application “hello_word”.

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

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

Il suffit maintenant de lancer notre serveur de développement comme ceci :

(venv) D:\monproject\monproject>python manage.py runserver

Et sur votre navigateur, tapez l’URL http://127.0.0.1:8000 pour accéder au Template HTML de notre application :

Conclusion

Et voilà, félicitations ! Vous avez enfin terminé ! Dans ce tutoriel, vous avez appris à mettre en place l’environnement de développement d’un projet Django et vous avez réussi à créer votre première application. Nous avons vu comment créer une page web à l’aide des Vues, des Templates et de la configuration URL.