- À propos de la vérification de Python et pip dans un environnement virtuel
- Vérifier la version de Python utilisée
- Localiser l'interpréteur Python utilisé
- Vérifier que Python appartient à l'environnement virtuel
- Vérifier quel pip est utilisé
- Comparer Python et pip dans le même environnement
- Utiliser python -m pip pour éviter les erreurs d'environnement
- Vérifier les packages installés dans l'environnement virtuel
- Diagnostiquer un mauvais Python ou un mauvais pip
- À retenir !
1. À propos de la vérification de Python et pip dans un environnement virtuel
Lorsqu'un ordinateur possède plusieurs installations de Python ou plusieurs environnements virtuels, il est important de savoir exactement quel interpréteur Python et quel pip sont utilisés. Cette vérification permet notamment d'éviter d'installer un package dans un environnement différent de celui qui exécute le programme.
Après l'activation d'un environnement virtuel, les commandes python et pip doivent normalement correspondre aux exécutables de cet environnement. Nous pouvons commencer par demander directement à Python quel exécutable est utilisé.
1 2 3 | import sys print("Interpréteur Python :", sys.executable) |
Sortie possible :
1 | Interpréteur Python : C:\mon_projet\.venv\Scripts\python.exe |
Le chemin contient ici le dossier .venv. Cela indique que le programme est exécuté par le Python de l'environnement virtuel et non directement par l'installation Python principale de l'ordinateur.
2. Vérifier la version de Python utilisée
La première vérification consiste à afficher la version de Python associée à la commande python. Cette information est particulièrement utile lorsqu'un ordinateur possède plusieurs versions de Python.
Dans le terminal où l'environnement virtuel est actif, utilisons la commande suivante.
1 | python --version |
Sortie possible :
1 | Python 3.14.1 |
La version peut également être obtenue directement depuis un programme Python grâce au module sys.
1 2 3 | import sys print(sys.version) |
Sortie possible :
1 | 3.14.1 (main, ...) |
Pour obtenir uniquement les principales composantes numériques de la version, nous pouvons utiliser sys.version_info.
1 2 3 4 5 | import sys print("Version majeure :", sys.version_info.major) print("Version mineure :", sys.version_info.minor) print("Version corrective :", sys.version_info.micro) |
Sortie possible :
1 2 3 | Version majeure : 3 Version mineure : 14 Version corrective : 1 |
Connaître la version ne suffit cependant pas à identifier l'environnement utilisé. Deux environnements virtuels différents peuvent utiliser la même version de Python. Il faut donc également examiner le chemin de l'interpréteur.
3. Localiser l'interpréteur Python utilisé
Sous Windows, la commande where permet d'afficher les exécutables correspondant à une commande présente dans le PATH. Lorsque l'environnement virtuel est actif, son interpréteur Python doit normalement apparaître en premier.
Dans CMD ou PowerShell, exécutons la commande suivante.
1 | where.exe python |
Sortie possible :
1 2 | C:\mon_projet\.venv\Scripts\python.exe C:\Python314\python.exe |
Le premier chemin correspond ici au Python de .venv, tandis que le second correspond à une installation Python extérieure à l'environnement.
Depuis Python lui-même, sys.executable fournit directement le chemin de l'interpréteur qui exécute le programme.
1 2 3 | import sys print(sys.executable) |
Sortie possible :
1 | C:\mon_projet\.venv\Scripts\python.exe |
Cette méthode est particulièrement fiable, car elle indique directement quel exécutable Python est utilisé par le programme en cours d'exécution.
Sous Linux et macOS, la commande which permet d'effectuer une vérification similaire depuis le terminal.
1 | which python |
Sortie possible :
1 | /home/utilisateur/mon_projet/.venv/bin/python |
4. Vérifier que Python appartient à l'environnement virtuel
Python fournit deux informations particulièrement utiles pour déterminer si l'interpréteur fonctionne dans un environnement virtuel : sys.prefix et sys.base_prefix.
Le programme suivant affiche les deux valeurs afin de les comparer.
1 2 3 4 | import sys print("sys.prefix :", sys.prefix) print("sys.base_prefix :", sys.base_prefix) |
Sortie possible :
1 2 | sys.prefix : C:\mon_projet\.venv sys.base_prefix : C:\Python314 |
Dans un environnement virtuel créé avec venv, sys.prefix correspond généralement à l'environnement actif tandis que sys.base_prefix désigne l'installation Python utilisée comme base.
Nous pouvons donc automatiser la vérification avec une simple comparaison.
1 2 3 4 5 6 | import sys if sys.prefix != sys.base_prefix: print("Un environnement virtuel est utilisé.") else: print("Python de base utilisé.") |
Sortie possible :
1 | Un environnement virtuel est utilisé. |
Une version plus compacte permet d'obtenir directement une valeur booléenne.
1 2 3 | import sys print(sys.prefix != sys.base_prefix) |
Sortie possible :
1 | True |
La valeur True confirme ici que l'interpréteur fonctionne dans un environnement virtuel.
5. Vérifier quel pip est utilisé
Il est tout aussi important de vérifier pip, car une erreur fréquente consiste à exécuter un programme avec le Python d'un environnement virtuel tout en installant les packages avec un pip provenant d'une autre installation Python.
La commande suivante affiche la version de pip ainsi que son emplacement.
1 | pip --version |
Sortie possible :
1 | pip 25.x from C:\mon_projet\.venv\Lib\site-packages\pip (python 3.14) |
Le chemin contient .venv, ce qui indique que ce pip appartient à notre environnement virtuel.
Sous Windows, nous pouvons également rechercher les exécutables pip accessibles depuis le terminal.
1 | where.exe pip |
Sortie possible :
1 2 | C:\mon_projet\.venv\Scripts\pip.exe C:\Python314\Scripts\pip.exe |
Lorsque l'environnement virtuel est correctement activé, son pip.exe doit normalement apparaître avant celui des autres installations dans la résolution du PATH.
Sous Linux et macOS, nous pouvons utiliser la commande suivante.
1 | which pip |
Sortie possible :
1 | /home/utilisateur/mon_projet/.venv/bin/pip |
6. Comparer Python et pip dans le même environnement
Pour éviter les problèmes de dépendances, Python et pip doivent correspondre au même environnement virtuel. Nous pouvons commencer par afficher le chemin de Python.
1 | python -c "import sys; print(sys.executable)" |
Sortie possible :
1 | C:\mon_projet\.venv\Scripts\python.exe |
Nous affichons ensuite l'emplacement de pip associé à la commande python utilisée.
1 | python -m pip --version |
Sortie possible :
1 | pip 25.x from C:\mon_projet\.venv\Lib\site-packages\pip (python 3.14) |
Les deux chemins contiennent C:\mon_projet\.venv. Nous pouvons donc confirmer que Python et le module pip exécuté par ce Python appartiennent au même environnement.
Une vérification supplémentaire consiste à afficher l'emplacement du module pip depuis Python.
1 2 3 4 5 | import pip import sys print("Python :", sys.executable) print("Module pip :", pip.__file__) |
Sortie possible :
1 2 | Python : C:\mon_projet\.venv\Scripts\python.exe Module pip : C:\mon_projet\.venv\Lib\site-packages\pip\__init__.py |
Cette comparaison permet de repérer rapidement un problème d'environnement lorsque les chemins observés ne correspondent pas au projet attendu.
7. Utiliser python -m pip pour éviter les erreurs d'environnement
Lorsque plusieurs installations Python sont présentes, la commande pip seule peut parfois créer une ambiguïté. L'utilisation de python -m pip est particulièrement utile, car elle demande explicitement à l'interpréteur désigné par python d'exécuter le module pip.
Avant d'installer un package, nous pouvons vérifier quel Python sera utilisé.
1 | python -c "import sys; print(sys.executable)" |
Sortie possible :
1 | C:\mon_projet\.venv\Scripts\python.exe |
Nous pouvons ensuite installer requests avec le pip de ce même interpréteur.
1 | python -m pip install requests |
Sortie possible :
1 2 3 | Collecting requests ... Successfully installed certifi-... charset-normalizer-... idna-... requests-2.32.5 urllib3-... |
Nous pouvons immédiatement vérifier l'emplacement du package installé.
1 | python -m pip show requests |
Sortie possible :
1 2 3 4 | Name: requests Version: 2.32.5 Location: C:\mon_projet\.venv\Lib\site-packages ... |
Le champ Location confirme ici que requests a été installé dans le dossier site-packages de l'environnement virtuel.
8. Vérifier les packages installés dans l'environnement virtuel
Une fois que nous avons confirmé quel Python et quel pip sont utilisés, nous pouvons afficher les packages visibles par l'environnement grâce à pip list.
La commande suivante utilise explicitement le pip associé au Python courant.
1 | python -m pip list |
Sortie possible :
1 2 3 4 5 6 7 8 | Package Version ------------------ ------- certifi ... charset-normalizer ... idna ... pip 25.x requests 2.32.5 urllib3 ... |
Pour obtenir une liste adaptée à la génération d'un fichier de dépendances, nous pouvons utiliser pip freeze.
1 | python -m pip freeze |
Sortie possible :
1 2 3 4 5 | certifi==... charset-normalizer==... idna==... requests==2.32.5 urllib3==... |
Nous pouvons également vérifier si les distributions installées présentent des dépendances déclarées comme incompatibles ou manquantes.
1 | python -m pip check |
Sortie possible :
1 | No broken requirements found. |
Ces commandes sont utiles lorsqu'un programme retourne une erreur ModuleNotFoundError alors que l'utilisateur pense avoir déjà installé le package concerné.
9. Diagnostiquer un mauvais Python ou un mauvais pip
Un problème classique apparaît lorsque le terminal utilise le Python global au lieu de celui de l'environnement virtuel. Sous Windows, nous pouvons commencer par rechercher les interpréteurs accessibles.
1 | where.exe python |
Sortie possible :
1 | C:\Python314\python.exe |
Si nous attendions le chemin C:\mon_projet\.venv\Scripts\python.exe, cette sortie indique que l'environnement virtuel n'est probablement pas actif dans ce terminal.
Nous pouvons vérifier la situation directement avec sys.prefix et sys.base_prefix.
1 | python -c "import sys; print(sys.prefix); print(sys.base_prefix); print(sys.prefix != sys.base_prefix)" |
Sortie possible :
1 2 3 | C:\Python314 C:\Python314 False |
La valeur False confirme ici que cet interpréteur n'est pas exécuté dans un environnement virtuel créé avec venv.
Sous PowerShell, nous pouvons réactiver l'environnement .venv avec son script Activate.ps1 lorsque la stratégie d'exécution l'autorise.
1 | .\.venv\Scripts\Activate.ps1 |
Sortie possible :
1 | (.venv) PS C:\mon_projet> |
Nous pouvons alors refaire immédiatement les deux vérifications principales.
1 2 | python -c "import sys; print(sys.executable)" python -m pip --version |
Sortie possible :
1 2 | C:\mon_projet\.venv\Scripts\python.exe pip 25.x from C:\mon_projet\.venv\Lib\site-packages\pip (python 3.14) |
Si nous ne souhaitons pas activer l'environnement, il est également possible d'appeler directement son interpréteur. Cette méthode évite toute ambiguïté concernant le Python utilisé.
1 | .\.venv\Scripts\python.exe -m pip --version |
Sortie possible :
1 | pip 25.x from C:\mon_projet\.venv\Lib\site-packages\pip (python 3.14) |
10. À retenir !
Vérifier quel Python et quel pip sont réellement utilisés est une étape essentielle lorsque nous travaillons avec plusieurs installations Python ou plusieurs environnements virtuels. Cette vérification permet d'éviter qu'un package soit installé dans un environnement tandis que le programme est exécuté dans un autre.
- python --version affiche la version de Python utilisée par la commande python.
- sys.executable fournit le chemin exact de l'interpréteur qui exécute le programme.
- where.exe python sous Windows affiche les exécutables Python trouvés dans le PATH.
- which python joue un rôle similaire sous Linux et macOS.
- sys.prefix != sys.base_prefix permet de détecter couramment l'utilisation d'un environnement venv.
- pip --version affiche la version et l'emplacement du pip appelé directement.
- where.exe pip permet de localiser les exécutables pip sous Windows.
- python -m pip utilise le module pip associé à l'interpréteur désigné par la commande python.
- python -m pip show permet notamment de connaître l'emplacement d'un package installé.
- python -m pip check vérifie la cohérence des dépendances déclarées par les distributions installées.
Sous Windows, les commandes suivantes constituent un diagnostic rapide permettant de vérifier Python et pip après l'activation de l'environnement virtuel.
1 2 3 4 5 | where.exe python python --version python -c "import sys; print(sys.executable)" python -c "import sys; print(sys.prefix != sys.base_prefix)" python -m pip --version |
Sortie possible :
1 2 3 4 5 6 | C:\mon_projet\.venv\Scripts\python.exe C:\Python314\python.exe Python 3.14.1 C:\mon_projet\.venv\Scripts\python.exe True pip 25.x from C:\mon_projet\.venv\Lib\site-packages\pip (python 3.14) |
Nous pouvons également réaliser un diagnostic directement depuis Python afin d'obtenir les informations principales sur l'environnement en cours d'utilisation.
1 2 3 4 5 6 7 8 9 | import sys import pip print("Version Python :", sys.version.split()[0]) print("Interpréteur :", sys.executable) print("Environnement :", sys.prefix) print("Python de base :", sys.base_prefix) print("Environnement virtuel :", sys.prefix != sys.base_prefix) print("Module pip :", pip.__file__) |
Sortie possible :
1 2 3 4 5 6 | Version Python : 3.14.1 Interpréteur : C:\mon_projet\.venv\Scripts\python.exe Environnement : C:\mon_projet\.venv Python de base : C:\Python314 Environnement virtuel : True Module pip : C:\mon_projet\.venv\Lib\site-packages\pip\__init__.py |
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/
