- À propos des environnements virtuels Python
- Pourquoi créer un environnement virtuel ?
- Créer un environnement virtuel avec python -m venv
- Choisir le dossier de l'environnement virtuel
- Comprendre la structure d'un environnement virtuel
- Activer l'environnement virtuel
- Vérifier que l'environnement virtuel est actif
- Installer un premier package dans l'environnement
- Désactiver et réutiliser l'environnement virtuel
- À retenir !
1. À propos des environnements virtuels Python
Un environnement virtuel Python est un espace isolé dans lequel un projet peut disposer de ses propres packages et dépendances. Python fournit pour cela le module standard venv, qui permet de créer facilement un environnement virtuel sans installer de bibliothèque supplémentaire.
Un environnement virtuel possède notamment son propre interpréteur Python et son propre emplacement destiné aux packages installés avec pip. Il permet ainsi de séparer les dépendances d'un projet de celles des autres projets Python présents sur l'ordinateur.
Avant de créer un environnement virtuel, le programme suivant permet de connaître la version de Python actuellement utilisée.
1 2 3 | import sys print(sys.version) |
Sortie possible :
1 | 3.14.0 (main, Oct 7 2025, 10:00:00) [MSC v.1944 64 bit (AMD64)] |
La sortie exacte dépend de la version de Python, du système d'exploitation et de l'installation présente sur l'ordinateur.
2. Pourquoi créer un environnement virtuel ?
Lorsque plusieurs projets Python sont développés sur le même ordinateur, ils peuvent nécessiter des versions différentes d'une même bibliothèque. Sans environnement virtuel, ces dépendances peuvent entrer en conflit.
Supposons par exemple qu'un premier projet nécessite une version particulière d'une bibliothèque alors qu'un second projet utilise une autre version. Avec venv, chaque projet peut conserver ses propres dépendances indépendamment des autres.
Le programme suivant affiche l'emplacement de l'interpréteur Python utilisé par le programme. Cette information nous permettra ensuite de constater que l'interpréteur change après l'activation d'un environnement virtuel.
1 2 3 | import sys print(sys.executable) |
Sortie possible :
1 | C:\Python314\python.exe |
Le chemin dépend de l'installation de Python. Une fois l'environnement virtuel activé, sys.executable pointera normalement vers l'interpréteur associé à cet environnement.
3. Créer un environnement virtuel avec python -m venv
La commande fondamentale permettant de créer un environnement virtuel est python -m venv. L'option -m demande à Python d'exécuter le module venv, tandis que le dernier argument indique le nom ou le chemin du dossier à créer.
Dans un terminal placé dans le dossier du projet, la commande suivante crée un environnement virtuel appelé venv.
1 | python -m venv venv |
Sortie :
1 | Aucune sortie si la création réussit. |
Après l'exécution de cette commande, un nouveau dossier nommé venv apparaît dans le répertoire courant. Il contient les fichiers nécessaires au fonctionnement de l'environnement virtuel.
Sur certains systèmes où la commande python3 est utilisée pour lancer Python 3, la commande peut être écrite de la manière suivante.
1 | python3 -m venv venv |
Sortie :
1 | Aucune sortie si la création réussit. |
Les deux commandes reposent sur le même principe : exécuter le module venv avec l'interpréteur Python choisi.
4. Choisir le dossier de l'environnement virtuel
Le nom venv n'est pas obligatoire. Nous pouvons choisir librement le nom du dossier qui contiendra l'environnement virtuel. Les noms venv, .venv, env ou .env sont fréquemment rencontrés, même si .venv permet souvent de distinguer clairement l'environnement virtuel des fichiers du projet.
La commande suivante crée par exemple l'environnement dans un dossier nommé .venv.
1 | python -m venv .venv |
Sortie :
1 | Aucune sortie si la création réussit. |
Il est également possible d'indiquer un chemin. La commande suivante crée par exemple un environnement nommé mon_env dans un sous-dossier environnements.
1 | python -m venv environnements/mon_env |
Sortie :
1 | Aucune sortie si la création réussit. |
Dans la pratique, placer l'environnement directement dans le dossier du projet sous le nom .venv constitue une organisation simple, notamment lorsque le projet est ouvert avec un éditeur de code.
5. Comprendre la structure d'un environnement virtuel
La commande python -m venv .venv ne crée pas simplement un dossier vide. Python y installe une structure permettant d'utiliser un interpréteur et des packages propres à l'environnement.
Structure sous Windows
Sous Windows, un environnement virtuel contient généralement des dossiers tels que Include, Lib et Scripts, ainsi qu'un fichier pyvenv.cfg. La commande suivante permet d'afficher le contenu du dossier depuis l'invite de commandes Windows.
1 | dir .venv |
Sortie possible :
1 2 3 4 | Include Lib Scripts pyvenv.cfg |
Le dossier Scripts est particulièrement important sous Windows : il contient notamment les exécutables utilisés pour Python, pip et l'activation de l'environnement.
Structure sous Linux et macOS
Sous Linux et macOS, l'organisation est légèrement différente. Le dossier des exécutables porte notamment le nom bin. La commande suivante affiche le contenu de l'environnement.
1 | ls .venv |
Sortie possible :
1 2 3 4 | bin include lib pyvenv.cfg |
La structure exacte peut légèrement varier selon le système d'exploitation et la version de Python utilisée.
6. Activer l'environnement virtuel
Après sa création, l'environnement doit généralement être activé dans le terminal afin que les commandes python et pip utilisent facilement l'environnement concerné. La commande d'activation dépend du système et du terminal utilisés.
Activation avec l'invite de commandes Windows
Dans l'Invite de commandes Windows, si l'environnement s'appelle .venv, utilisez la commande suivante.
1 | .venv\Scripts\activate.bat |
Sortie possible :
1 | (.venv) C:\mon_projet> |
Le préfixe (.venv) indique généralement que l'environnement virtuel est actif.
Activation avec PowerShell
Dans PowerShell, le script d'activation est Activate.ps1. La commande suivante active l'environnement.
1 | .venv\Scripts\Activate.ps1 |
Sortie possible :
1 | (.venv) PS C:\mon_projet> |
Selon la politique d'exécution configurée dans PowerShell, l'exécution des scripts peut être restreinte. Dans ce cas, PowerShell affiche un message d'erreur relatif à sa politique d'exécution.
Activation sous Linux ou macOS
Sous Linux et macOS, l'environnement peut être activé avec la commande suivante.
1 | source .venv/bin/activate |
Sortie possible :
1 | (.venv) utilisateur@ordinateur:~/mon_projet$ |
Dans les trois cas, l'activation modifie l'environnement du terminal courant afin que l'interpréteur et les commandes associées au venv soient utilisés en priorité.
7. Vérifier que l'environnement virtuel est actif
L'apparition de (.venv) devant l'invite de commande est pratique, mais nous pouvons vérifier plus précisément quel interpréteur Python est réellement utilisé. Pour cela, sys.executable affiche le chemin de l'exécutable Python courant.
Après avoir activé l'environnement, exécutez le programme suivant.
1 2 3 | import sys print(sys.executable) |
Sortie possible sous Windows :
1 | C:\mon_projet\.venv\Scripts\python.exe |
Le chemin contient maintenant le dossier .venv. Cela montre que le programme est exécuté avec l'interpréteur associé à l'environnement virtuel.
Nous pouvons également utiliser sys.prefix pour connaître le préfixe de l'environnement Python actuellement utilisé.
1 2 3 | import sys print(sys.prefix) |
Sortie possible :
1 | C:\mon_projet\.venv |
Lorsque l'environnement est actif et que Python provient de celui-ci, sys.prefix correspond au dossier de l'environnement virtuel.
8. Installer un premier package dans l'environnement
L'un des principaux intérêts d'un environnement virtuel est de pouvoir y installer des packages sans les mélanger avec ceux des autres projets. Une fois l'environnement activé, nous pouvons utiliser pip.
La commande suivante affiche la version de pip associée à l'interpréteur Python utilisé. L'écriture python -m pip permet de demander explicitement au Python courant d'exécuter pip.
1 | python -m pip --version |
Sortie possible :
1 | pip 25.2 from C:\mon_projet\.venv\Lib\site-packages\pip (python 3.14) |
Le chemin affiché contient .venv, ce qui confirme que pip travaille dans l'environnement virtuel.
À titre de premier exemple, nous pouvons installer le package requests uniquement dans cet environnement.
1 | python -m pip install requests |
Sortie possible :
1 | Successfully installed certifi charset_normalizer idna requests urllib3 |
Les numéros de version et les dépendances installées peuvent varier. Le package requests est maintenant disponible dans cet environnement sans devoir être installé globalement pour tous les projets.
Le programme suivant permet ensuite de vérifier que requests peut être importé et d'afficher sa version.
1 2 3 | import requests print(requests.__version__) |
Sortie possible :
1 | 2.32.5 |
La version affichée dépend de celle installée au moment de l'exécution de la commande.
9. Désactiver et réutiliser l'environnement virtuel
Lorsque nous avons terminé de travailler dans l'environnement virtuel, la commande deactivate permet de quitter l'environnement actif et de revenir au contexte Python habituel du terminal.
La commande est la même après activation sous Windows, Linux ou macOS.
1 | deactivate |
Sortie possible :
1 | C:\mon_projet> |
Le préfixe (.venv) disparaît généralement de l'invite de commande. L'environnement n'est pas supprimé : seul son état d'activation dans le terminal prend fin.
Pour travailler de nouveau sur le projet sous Windows avec l'invite de commandes, il suffit de revenir dans son dossier et de réactiver l'environnement existant.
1 2 | cd C:\mon_projet .venv\Scripts\activate.bat |
Sortie possible :
1 | (.venv) C:\mon_projet> |
Il n'est donc pas nécessaire d'exécuter de nouveau python -m venv .venv chaque fois que nous ouvrons le projet. La création est effectuée une fois ; lors des utilisations suivantes, nous réactivons simplement l'environnement.
10. À retenir !
Le module venv fournit une méthode simple pour créer des environnements virtuels Python. Chaque projet peut ainsi disposer de son propre environnement et de ses propres dépendances, ce qui limite les conflits entre les packages utilisés par différents projets.
- venv fait partie de la bibliothèque standard de Python.
- python -m venv .venv crée un environnement virtuel dans le dossier .venv.
- Le nom .venv est un choix pratique mais n'est pas obligatoire.
- Sous Windows, les exécutables de l'environnement se trouvent notamment dans le dossier Scripts.
- Sous Linux et macOS, ils se trouvent notamment dans le dossier bin.
- L'environnement peut être activé avec un script différent selon le système et le terminal utilisés.
- sys.executable permet de vérifier quel interpréteur Python exécute le programme.
- python -m pip permet d'utiliser pip avec l'interpréteur Python courant.
- deactivate quitte l'environnement sans supprimer son dossier.
- Un environnement déjà créé doit simplement être réactivé lors d'une nouvelle session de travail.
Voici finalement un exemple des principales commandes utilisées sous Windows avec l'invite de commandes pour créer un projet, créer son environnement virtuel, l'activer, installer un package puis le désactiver.
1 2 3 4 5 6 7 | mkdir mon_projet cd mon_projet python -m venv .venv .venv\Scripts\activate.bat python -m pip install requests python -m pip --version deactivate |
Sortie possible :
1 2 3 4 | (.venv) C:\mon_projet> Successfully installed requests ... pip ... from C:\mon_projet\.venv\Lib\site-packages\pip ... C:\mon_projet> |
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/
