- À propos des environnements virtuels pour un projet Django
- Créer le dossier du projet Django
- Créer et activer l'environnement virtuel Python
- Installer Django dans l'environnement virtuel
- Créer un nouveau projet Django
- Vérifier et configurer le projet Django
- Créer une première application Django
- Créer et utiliser requirements.txt
- Désactiver et réutiliser l'environnement virtuel Django
- À retenir !
1. À propos des environnements virtuels pour un projet Django
Django est un framework Web Python permettant de développer des sites et des applications Web. Un projet Django utilise généralement plusieurs packages Python dont les versions peuvent varier d'un projet à un autre. Il est donc recommandé d'utiliser un environnement virtuel Python pour chaque projet Django.
Un environnement virtuel permet d'isoler l'installation de Django et des autres dépendances du projet. Un premier projet peut ainsi utiliser une version de Django tandis qu'un second projet peut utiliser une autre version sans créer de conflit entre les deux.
Le programme Python suivant permet de vérifier si l'interpréteur utilisé appartient à un environnement virtuel.
1 2 3 4 5 6 | import sys print("Interpréteur :", sys.executable) print("Environnement :", sys.prefix) print("Python de base :", sys.base_prefix) print("Environnement virtuel :", sys.prefix != sys.base_prefix) |
Sortie possible :
1 2 3 4 | Interpréteur : C:\projets\monsite\.venv\Scripts\python.exe Environnement : C:\projets\monsite\.venv Python de base : C:\Python314 Environnement virtuel : True |
La valeur True indique ici que le programme utilise l'interpréteur d'un environnement virtuel et non directement l'installation Python de base.
2. Créer le dossier du projet Django
Avant de créer l'environnement virtuel, nous pouvons préparer un dossier destiné à contenir le projet Django. Cette organisation permet de regrouper le code source, l'environnement virtuel et les fichiers de configuration du projet.
Sous Windows, Linux ou macOS, la commande suivante crée un dossier nommé monsite.
1 | mkdir monsite |
Sortie possible :
1 | Le dossier monsite est créé. |
Nous devons ensuite nous placer dans ce nouveau dossier avant de créer l'environnement virtuel.
1 | cd monsite |
Sortie possible :
1 | C:\projets\monsite> |
À la fin de la préparation, notre dossier de travail est encore très simple.
1 | monsite/ |
Sortie :
1 | Le dossier monsite servira de racine à notre projet Django. |
3. Créer et activer l'environnement virtuel Python
Depuis le dossier du projet, nous pouvons utiliser le module standard venv pour créer un environnement virtuel nommé .venv. Le point placé au début du nom permet notamment de reconnaître facilement ce dossier comme un élément technique du projet.
La commande suivante crée l'environnement virtuel .venv avec l'interpréteur Python utilisé pour exécuter la commande.
1 | python -m venv .venv |
Sortie :
1 2 | Aucun message n'est généralement affiché. Le dossier .venv est créé dans le projet. |
Activer l'environnement sous Windows avec CMD
Dans l'invite de commandes Windows, le script activate.bat permet d'activer l'environnement virtuel.
1 | .venv\Scripts\activate.bat |
Sortie possible :
1 | (.venv) C:\projets\monsite> |
Activer l'environnement sous Windows avec PowerShell
Dans PowerShell, l'environnement virtuel est activé avec le script Activate.ps1.
1 | .venv\Scripts\Activate.ps1 |
Sortie possible :
1 | (.venv) PS C:\projets\monsite> |
Activer l'environnement sous Linux et macOS
Sous Linux et macOS, le script activate se trouve dans le dossier bin de l'environnement virtuel.
1 | source .venv/bin/activate |
Sortie possible :
1 | (.venv) utilisateur@ordinateur:~/projets/monsite$ |
La présence de (.venv) devant l'invite du terminal indique généralement que l'environnement est actif dans cette session.
4. Installer Django dans l'environnement virtuel
Une fois l'environnement virtuel activé, nous pouvons installer Django avec pip. L'utilisation de python -m pip permet de lancer pip avec l'interpréteur Python actuellement utilisé.
La commande suivante installe Django et ses dépendances dans l'environnement .venv.
1 | python -m pip install django |
Sortie possible :
1 2 3 4 5 | Collecting django Collecting asgiref Collecting sqlparse ... Successfully installed asgiref-... django-... sqlparse-... |
Après l'installation, nous pouvons vérifier la version de Django disponible dans l'environnement avec l'option --version.
1 | python -m django --version |
Sortie possible :
1 | 6.0.1 |
Nous pouvons également demander à pip d'afficher les informations concernant le package Django installé.
1 | python -m pip show django |
Sortie possible :
1 2 3 4 | Name: Django Version: 6.0.1 Summary: A high-level Python web framework that encourages rapid development and clean, pragmatic design. ... |
Django est maintenant installé dans .venv et peut être utilisé pour créer le projet Web.
5. Créer un nouveau projet Django
Après l'installation de Django, nous pouvons créer la structure initiale du projet. Nous allons appeler le projet config. Le point placé à la fin de la commande demande à Django de créer les fichiers dans le dossier courant plutôt que de créer un niveau de dossier supplémentaire.
La commande suivante utilise Django depuis l'environnement virtuel pour générer le projet.
1 | python -m django startproject config . |
Sortie :
1 2 | Aucun message n'est généralement affiché. Les fichiers du projet Django sont créés. |
Après cette commande, la structure du projet ressemble à celle-ci.
1 2 3 4 5 6 7 8 9 | monsite/ ├── .venv/ ├── config/ │ ├── __init__.py │ ├── asgi.py │ ├── settings.py │ ├── urls.py │ └── wsgi.py └── manage.py |
Sortie :
1 | Le projet Django config a été créé dans le dossier monsite. |
Le fichier manage.py constitue l'un des principaux outils de commande du projet, tandis que settings.py contient sa configuration générale et urls.py définit notamment les routes principales.
6. Vérifier et configurer le projet Django
Avant de commencer le développement, Django fournit la commande check permettant de rechercher certains problèmes dans la configuration du projet.
La commande suivante effectue cette vérification.
1 | python manage.py check |
Sortie possible :
1 | System check identified no issues (0 silenced). |
Pour un nouveau projet utilisant la configuration par défaut, nous pouvons ensuite appliquer les migrations initiales nécessaires aux applications intégrées de Django.
1 | python manage.py migrate |
Sortie possible :
1 2 3 4 5 6 7 | Operations to perform: Apply all migrations: admin, auth, contenttypes, sessions Running migrations: Applying contenttypes.0001_initial... OK Applying auth.0001_initial... OK ... Applying sessions.0001_initial... OK |
Nous pouvons maintenant lancer le serveur de développement Django afin de vérifier le fonctionnement du projet.
1 | python manage.py runserver |
Sortie possible :
1 2 3 4 5 6 7 | Watching for file changes with StatReloader Performing system checks... System check identified no issues (0 silenced). ... Starting development server at http://127.0.0.1:8000/ Quit the server with CONTROL-C. |
Le projet peut alors être consulté depuis le navigateur à l'adresse locale indiquée par Django. Le serveur fourni par runserver est destiné au développement et non au déploiement en production.
7. Créer une première application Django
Un projet Django peut contenir une ou plusieurs applications. Une application représente généralement une partie fonctionnelle du site, par exemple un blog, une boutique, un forum ou un système de gestion des étudiants.
La commande suivante crée une application nommée blog dans notre projet.
1 | python manage.py startapp blog |
Sortie :
1 2 | Aucun message n'est généralement affiché. Le dossier blog est créé. |
Après la création de l'application, la structure du projet contient un nouveau dossier blog.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 | monsite/ ├── .venv/ ├── blog/ │ ├── migrations/ │ ├── __init__.py │ ├── admin.py │ ├── apps.py │ ├── models.py │ ├── tests.py │ └── views.py ├── config/ │ ├── __init__.py │ ├── asgi.py │ ├── settings.py │ ├── urls.py │ └── wsgi.py ├── db.sqlite3 └── manage.py |
Sortie :
1 | L'application blog fait maintenant partie des fichiers du projet. |
Pour utiliser cette application comme application installée du projet, nous devons ensuite l'ajouter à la liste INSTALLED_APPS du fichier config/settings.py.
1 2 3 4 5 6 7 8 9 | INSTALLED_APPS = [ "django.contrib.admin", "django.contrib.auth", "django.contrib.contenttypes", "django.contrib.sessions", "django.contrib.messages", "django.contrib.staticfiles", "blog", ] |
Sortie :
1 | L'application blog est déclarée dans INSTALLED_APPS. |
Après cette modification, nous pouvons relancer la vérification du projet.
1 | python manage.py check |
Sortie possible :
1 | System check identified no issues (0 silenced). |
8. Créer et utiliser requirements.txt
Un projet Django peut rapidement utiliser plusieurs dépendances. Il est donc recommandé de conserver leur liste dans un fichier requirements.txt. Ce fichier permet notamment de reconstruire l'environnement virtuel sur un autre ordinateur ou sur un serveur.
Avec l'environnement .venv actif, la commande suivante enregistre les distributions installées et leurs versions dans requirements.txt.
1 | python -m pip freeze > requirements.txt |
Sortie :
1 2 | Aucun message n'est normalement affiché. Le fichier requirements.txt est créé ou remplacé. |
Le fichier obtenu peut contenir Django ainsi que ses dépendances.
1 2 3 | asgiref==... Django==... sqlparse==... |
Sortie :
1 | Les dépendances du projet sont enregistrées dans requirements.txt. |
Si le projet est transféré vers un autre ordinateur, nous pouvons créer un nouvel environnement virtuel puis réinstaller les dépendances à partir de ce fichier.
1 | python -m pip install -r requirements.txt |
Sortie possible :
1 2 3 4 5 | Collecting asgiref==... Collecting Django==... Collecting sqlparse==... ... Successfully installed Django-... asgiref-... sqlparse-... |
Le fichier requirements.txt facilite donc le partage et la reproduction de l'environnement nécessaire au projet Django.
9. Désactiver et réutiliser l'environnement virtuel Django
Lorsque nous avons terminé de travailler sur le projet, la commande deactivate permet de quitter l'environnement virtuel actif. Cette commande fonctionne après activation de l'environnement sous Windows, Linux ou macOS.
1 | deactivate |
Sortie possible :
1 2 3 4 5 | Avant : (.venv) C:\projets\monsite> Après : C:\projets\monsite> |
La disparition de (.venv) indique que le terminal n'utilise plus l'environnement virtuel activé précédemment.
Lorsque nous souhaitons reprendre le développement sous Windows avec CMD, il suffit de retourner dans le dossier du projet puis de réactiver l'environnement existant.
1 2 | cd C:\projets\monsite .venv\Scripts\activate.bat |
Sortie possible :
1 | (.venv) C:\projets\monsite> |
Sous Linux ou macOS, nous pouvons réactiver l'environnement avec la commande suivante depuis le dossier du projet.
1 | source .venv/bin/activate |
Sortie possible :
1 | (.venv) utilisateur@ordinateur:~/projets/monsite$ |
Nous pouvons alors relancer immédiatement le serveur de développement Django.
1 | python manage.py runserver |
Sortie possible :
1 2 3 4 5 | Watching for file changes with StatReloader Performing system checks... System check identified no issues (0 silenced). ... Starting development server at http://127.0.0.1:8000/ |
Il n'est donc pas nécessaire de recréer l'environnement à chaque session : il suffit de réactiver l'environnement existant.
10. À retenir !
Créer un environnement virtuel pour un projet Django permet d'isoler Django et les autres dépendances utilisées par l'application. Cette organisation rend le projet plus facile à développer, à partager et à reproduire sur un autre ordinateur.
- python -m venv .venv crée un environnement virtuel nommé .venv.
- L'environnement doit être activé avant d'installer les dépendances du projet.
- python -m pip install django installe Django dans l'environnement utilisé.
- python -m django --version permet de vérifier la version de Django.
- python -m django startproject config . crée un projet Django dans le dossier courant.
- python manage.py check vérifie la configuration du projet.
- python manage.py migrate applique les migrations nécessaires à la base de données.
- python manage.py startapp permet de créer une application Django.
- python -m pip freeze > requirements.txt enregistre les dépendances de l'environnement.
- deactivate quitte l'environnement virtuel sans supprimer celui-ci.
Le processus suivant résume les principales commandes nécessaires pour créer sous Windows avec CMD un environnement virtuel et un nouveau projet Django.
1 2 3 4 5 6 7 8 9 | mkdir monsite cd monsite python -m venv .venv .venv\Scripts\activate.bat python -m pip install django python -m django startproject config . python manage.py migrate python manage.py check python manage.py runserver |
Sortie possible :
1 2 3 4 5 | Operations to perform: Apply all migrations: admin, auth, contenttypes, sessions ... System check identified no issues (0 silenced). Starting development server at http://127.0.0.1:8000/ |
Une fois le projet fonctionnel, nous pouvons enregistrer ses dépendances afin de pouvoir reconstruire ultérieurement son environnement.
1 2 | python -m pip freeze > requirements.txt python -m pip check |
Sortie possible :
1 | No broken requirements found. |
Auteur : Younes Derfoufi
Lieu de travail : CRMEF OUJDA
Site Web : www.tresfacile.net
Chaine YouTube : https://www.youtube.com/user/InformatiquesFacile
Me contacter : https://www.tresfacile.net/me-contacter/
