- À propos des environnements virtuels Python
- Vérifier l'installation de Python
- Créer un dossier pour le projet
- Créer un environnement virtuel
- Activer l'environnement virtuel sous Windows
- Activer l'environnement sous Linux et macOS
- Vérifier que l'environnement virtuel est actif
- Installer des packages dans l'environnement virtuel
- Afficher les packages installés sur l'environnement virtuel
- Créer le fichier requirements.txt
- Installer les packages depuis requirements.txt
- Désactiver l'environnement virtuel
- Utiliser un environnement virtuel dans VS Code
- Supprimer un environnement virtuel
- Exemple complet sous Windows
- Remarques Finales
1. À propos des environnements virtuels Python
Un environnement virtuel Python est un espace isolé dans lequel on peut installer des bibliothèques et des packages sans modifier l'installation principale de Python.
Chaque projet peut ainsi disposer de ses propres packages et de ses propres versions. Par exemple, un projet peut utiliser Django 5 tandis qu'un autre utilise une version différente de Django.
Python fournit directement le module venv permettant de créer facilement des environnements virtuels.
2. Vérifier l'installation de Python
Avant de créer un environnement virtuel, il faut vérifier que Python est correctement installé. La commande suivante affiche la version de Python disponible sur l'ordinateur.
1 | python --version |
Sortie possible :
1 | Python 3.13.7 |
Sous Windows, la commande py peut également être utilisée si la commande python n'est pas reconnue.
1 | py --version |
Sortie possible :
1 | Python 3.13.7 |
3. Créer un dossier pour le projet
Il est conseillé de créer un dossier contenant le projet avant de créer l'environnement virtuel. La commande mkdir permet de créer un nouveau dossier.
1 | mkdir monprojet |
Sortie :
1 | Aucun message n'est affiché si la création réussit. |
On entre ensuite dans le dossier avec la commande cd.
1 | cd monprojet |
Sortie possible sous Windows :
1 | C:\Users\dell\Desktop\monprojet> |
4. Créer un environnement virtuel
Le module venv permet de créer l'environnement virtuel. Dans la commande suivante, venv placé à la fin représente le nom du dossier qui contiendra l'environnement.
1 | python -m venv venv |
Sortie :
1 | Aucun message n'est généralement affiché. |
Après l'exécution, un nouveau dossier nommé venv apparaît dans le projet.
Si la commande python ne fonctionne pas sous Windows, on peut utiliser le lanceur Python py.
1 | py -m venv venv |
Sortie :
1 | Aucun message n'est généralement affiché. |
5. Activer l'environnement virtuel sous Windows
L'activation dépend du terminal utilisé. Dans VS Code sous Windows, le terminal est souvent PowerShell ou Invite de commandes.
5.1. Activation avec PowerShell
Dans un terminal PowerShell, l'environnement virtuel peut être activé avec la commande suivante.
1 | .\venv\Scripts\Activate.ps1 |
Sortie possible :
1 | (venv) PS C:\Users\dell\Desktop\monprojet> |
La présence de (venv) au début de la ligne indique que l'environnement virtuel est actif.
5.2. Problème des scripts désactivés dans PowerShell
PowerShell peut refuser l'exécution de Activate.ps1 et afficher un message indiquant que l'exécution des scripts est désactivée sur le système.
1 | .\venv\Scripts\Activate.ps1 |
Sortie possible :
1 | Activate.ps1 cannot be loaded because running scripts is disabled on this system. |
Une solution consiste à autoriser les scripts uniquement pour le terminal PowerShell actuellement ouvert. Cette modification est temporaire et disparaît lorsque le terminal est fermé.
1 | Set-ExecutionPolicy -Scope Process -ExecutionPolicy Bypass |
Sortie :
1 | Aucun message n'est généralement affiché. |
On peut ensuite relancer la commande d'activation.
1 | .\venv\Scripts\Activate.ps1 |
Sortie possible :
1 | (venv) PS C:\Users\dell\Desktop\monprojet> |
5.3. Activation avec l'Invite de commandes
Si on utilise cmd, c'est-à-dire l'Invite de commandes Windows, il n'est pas nécessaire de modifier la politique d'exécution de PowerShell.
1 | venv\Scripts\activate.bat |
Sortie possible :
1 | (venv) C:\Users\dell\Desktop\monprojet> |
6. Activer l'environnement sous Linux et macOS
Sous Linux ou macOS, la commande d'activation est différente de celle utilisée sous Windows.
1 | source venv/bin/activate |
Sortie possible :
1 | (venv) user@ordinateur:~/monprojet$ |
Le préfixe (venv) indique ici encore que l'environnement virtuel est actif.
7. Vérifier que l'environnement virtuel est actif
Une première vérification consiste simplement à observer le terminal. Lorsque l'environnement est actif, son nom apparaît généralement entre parenthèses devant l'invite de commande.
1 | (venv) PS C:\Users\dell\Desktop\monprojet> |
Sortie :
1 | Le préfixe (venv) confirme l'activation. |
On peut également afficher l'emplacement de l'interpréteur Python utilisé sous Windows.
1 | where python |
Sortie possible :
1 | C:\Users\dell\Desktop\monprojet\venv\Scripts\python.exe |
Python est donc exécuté depuis le dossier venv du projet.
8. Installer des packages dans l'environnement
Une fois l'environnement activé, on peut utiliser pip pour installer des packages. Ceux-ci seront installés dans l'environnement virtuel et non globalement dans Python.
1 | python -m pip install requests |
Sortie possible :
1 | Successfully installed requests |
Par exemple, pour un projet Web utilisant Django, on peut installer Django de la même manière.
1 | python -m pip install django |
Sortie possible :
1 | Successfully installed django |
9. Afficher les packages installés
La commande pip list permet d'afficher les packages actuellement installés dans l'environnement virtuel.
1 | python -m pip list |
Sortie possible :
1 2 3 4 | Package Version ---------- ------- pip 25.2 requests 2.32.5 |
Cette liste dépend naturellement des packages installés dans votre environnement.
10. Créer le fichier requirements.txt
Dans un projet Python, il est fréquent d'enregistrer la liste des dépendances dans un fichier nommé requirements.txt. La commande suivante crée ce fichier à partir des packages installés.
1 | python -m pip freeze > requirements.txt |
Sortie :
1 | Aucun message n'est généralement affiché. |
Le fichier requirements.txt contient alors les packages et leurs versions.
1 | requests==2.32.5 |
Sortie :
1 | Le contenu dépend des packages installés dans l'environnement. |
11. Installer les packages depuis requirements.txt
Lorsqu'on récupère un projet Python existant, on peut installer toutes ses dépendances à partir du fichier requirements.txt.
1 | python -m pip install -r requirements.txt |
Sortie possible :
1 | Successfully installed requests |
Cette méthode facilite le partage d'un projet entre plusieurs ordinateurs ou plusieurs développeurs.
12. Désactiver l'environnement virtuel
Lorsque le travail est terminé, la commande deactivate permet de quitter l'environnement virtuel. Cette commande doit être exécutée dans le terminal où l'environnement est actuellement actif.
1 | deactivate |
Sortie possible sous PowerShell :
1 | PS C:\Users\dell\Desktop\monprojet> |
Le préfixe (venv) disparaît. Cela indique que l'environnement virtuel n'est plus actif.
13. Utiliser un environnement virtuel dans VS Code
Dans Visual Studio Code, il est important de sélectionner l'interpréteur Python situé dans l'environnement virtuel du projet.
Après avoir ouvert le dossier du projet dans VS Code, utilisez la palette de commandes avec Ctrl + Shift + P, puis recherchez la commande Python: Select Interpreter.
Sélectionnez ensuite l'interpréteur correspondant au dossier venv.
1 | venv\Scripts\python.exe |
Sortie :
1 | VS Code utilise désormais l'interpréteur Python de l'environnement virtuel. |
Lorsqu'un nouveau terminal est ouvert dans VS Code, son dossier courant dépend du dossier ou espace de travail actuellement ouvert. Il ne s'ouvre donc pas obligatoirement toujours dans le même chemin.
14. Supprimer un environnement virtuel
Un environnement virtuel n'est qu'un dossier. Si on n'en a plus besoin, on peut le supprimer puis le recréer ultérieurement.
Sous Windows avec l'Invite de commandes, on peut supprimer le dossier venv avec la commande suivante.
1 | rmdir /s /q venv |
Sortie :
1 | Aucun message n'est généralement affiché. |
Il est recommandé de conserver le fichier requirements.txt afin de pouvoir réinstaller facilement les dépendances.
15. Exemple complet sous Windows
L'exemple suivant résume les principales étapes : création d'un projet, création de l'environnement virtuel, activation et installation d'un package.
1 2 3 4 5 | mkdir monprojet cd monprojet python -m venv venv .\venv\Scripts\Activate.ps1 python -m pip install requests |
Sortie possible :
1 | (venv) PS C:\Users\dell\Desktop\monprojet> |
Le projet possède maintenant son propre environnement virtuel Python dans lequel les packages peuvent être installés indépendamment du reste du système.
16. Remarques Finales
Un environnement virtuel permet d'isoler les dépendances d'un projet Python. Le module venv est fourni avec Python et constitue une solution simple pour créer ces environnements.
La commande python -m venv venv crée l'environnement. Il faut ensuite l'activer avec une commande adaptée au terminal utilisé. Une fois activé, pip installe les packages uniquement dans cet environnement.
Dans VS Code, il est également recommandé de sélectionner l'interpréteur Python du dossier venv afin que l'éditeur et le terminal utilisent le même environnement.
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/
