- À propos de sys.executable
- Afficher le chemin de l'interpréteur Python
- Comprendre le chemin retourné par sys.executable
- Récupérer le nom et le dossier de l'interpréteur
- Identifier l'interpréteur dans un environnement virtuel
- Comparer sys.executable avec la commande python
- Utiliser sys.executable pour installer un package avec pip
- Utiliser sys.executable pour lancer un autre script Python
- Afficher les principales informations sur l'interpréteur
- À retenir
1. À propos de sys.executable
Le module sys fournit plusieurs informations concernant l'environnement dans lequel un programme Python est exécuté. Parmi celles-ci, sys.executable permet d'obtenir le chemin de l'exécutable Python utilisé pour exécuter le programme courant.
Cette information est particulièrement utile lorsqu'un ordinateur possède plusieurs installations de Python, plusieurs versions de Python ou différents environnements virtuels.
Le programme suivant affiche simplement la valeur de sys.executable.
1 2 3 | import sys print(sys.executable) |
Sortie possible sous Windows :
1 | C:\Users\dell\AppData\Local\Programs\Python\Python314\python.exe |
Le résultat dépend de l'installation de Python utilisée sur l'ordinateur. Sous Linux ou macOS, le chemin sera naturellement différent.
2. Afficher le chemin de l'interpréteur Python
sys.executable contient généralement le chemin absolu de l'exécutable Python qui exécute actuellement le programme. Nous pouvons l'afficher avec la fonction print().
Le programme suivant ajoute un message afin de rendre le résultat plus explicite.
1 2 3 | import sys print("Interpréteur Python :", sys.executable) |
Sortie possible sous Windows :
1 | Interpréteur Python : C:\Users\dell\AppData\Local\Programs\Python\Python314\python.exe |
Sous Linux, nous pourrions par exemple obtenir un chemin de la forme suivante.
1 2 3 | import sys print("Interpréteur Python :", sys.executable) |
Sortie possible sous Linux :
1 | Interpréteur Python : /usr/bin/python3 |
Le chemin obtenu correspond à l'interpréteur associé au processus Python courant.
3. Comprendre le chemin retourné par sys.executable
La valeur retournée par sys.executable peut être utilisée comme un chemin classique. Nous pouvons notamment la convertir en objet Path afin de profiter des outils du module pathlib.
Le programme suivant transforme le chemin de l'interpréteur en objet Path puis l'affiche.
1 2 3 4 5 6 | import sys from pathlib import Path interpreteur = Path(sys.executable) print(interpreteur) |
Sortie possible :
1 | C:\Users\dell\AppData\Local\Programs\Python\Python314\python.exe |
Nous pouvons également vérifier si le chemin retourné correspond effectivement à un fichier avec la méthode is_file().
1 2 3 4 5 6 | import sys from pathlib import Path interpreteur = Path(sys.executable) print("Le fichier existe :", interpreteur.is_file()) |
Sortie possible :
1 | Le fichier existe : True |
4. Récupérer le nom et le dossier de l'interpréteur
En combinant sys.executable avec pathlib, nous pouvons facilement récupérer le nom de l'exécutable et le dossier dans lequel il se trouve.
Le programme suivant utilise les propriétés name et parent d'un objet Path.
1 2 3 4 5 6 7 | import sys from pathlib import Path interpreteur = Path(sys.executable) print("Nom :", interpreteur.name) print("Dossier :", interpreteur.parent) |
Sortie possible sous Windows :
1 2 | Nom : python.exe Dossier : C:\Users\dell\AppData\Local\Programs\Python\Python314 |
Nous pouvons également récupérer uniquement le nom sans son extension grâce à la propriété stem.
1 2 3 4 5 6 7 | import sys from pathlib import Path interpreteur = Path(sys.executable) print("Nom complet :", interpreteur.name) print("Nom sans extension :", interpreteur.stem) |
Sortie possible :
1 2 | Nom complet : python.exe Nom sans extension : python |
5. Identifier l'interpréteur dans un environnement virtuel
L'une des utilisations les plus intéressantes de sys.executable consiste à vérifier quel interpréteur est utilisé après l'activation d'un environnement virtuel. Dans ce cas, le chemin pointe normalement vers l'interpréteur associé à cet environnement.
Supposons qu'un environnement virtuel nommé venv ait été créé et activé sous Windows. Le programme suivant permet de connaître l'interpréteur réellement utilisé.
1 2 3 | import sys print(sys.executable) |
Sortie possible sous Windows :
1 | C:\Users\dell\Desktop\projet\venv\Scripts\python.exe |
Nous pouvons comparer ce résultat avec la valeur de sys.prefix, qui indique le préfixe de l'environnement Python courant.
1 2 3 4 5 | import sys print("Interpréteur :", sys.executable) print("Environnement courant :", sys.prefix) print("Installation principale :", sys.base_prefix) |
Sortie possible dans un environnement virtuel :
1 2 3 | Interpréteur : C:\Users\dell\Desktop\projet\venv\Scripts\python.exe Environnement courant : C:\Users\dell\Desktop\projet\venv Installation principale : C:\Users\dell\AppData\Local\Programs\Python\Python314 |
Dans un environnement virtuel classique, sys.prefix et sys.base_prefix sont généralement différents. Cela permet également de détecter si le programme s'exécute dans un environnement virtuel.
6. Comparer sys.executable avec la commande python
La commande python saisie dans un terminal dépend notamment de la configuration du PATH, d'un environnement virtuel actif et du système utilisé. En revanche, sys.executable indique directement quel exécutable a lancé le processus Python courant.
Le programme suivant permet donc de vérifier rapidement quel Python est réellement utilisé par un script.
1 2 3 4 | import sys print("Python utilisé :", sys.executable) print("Version :", sys.version_info.major, sys.version_info.minor) |
Sortie possible :
1 2 | Python utilisé : C:\Users\dell\AppData\Local\Programs\Python\Python314\python.exe Version : 3 14 |
Sous Windows, la commande where python permet de rechercher les exécutables nommés python accessibles via le PATH. Elle peut afficher plusieurs chemins, alors que sys.executable indique celui du processus Python en cours.
1 | where python |
Sortie possible :
1 2 | C:\Users\dell\AppData\Local\Programs\Python\Python314\python.exe C:\Users\dell\AppData\Local\Microsoft\WindowsApps\python.exe |
Cette comparaison peut être utile lorsque VS Code, un terminal ou un environnement virtuel semble utiliser une installation de Python différente de celle attendue.
7. Utiliser sys.executable pour installer un package avec pip
sys.executable peut être utilisé pour lancer pip avec exactement le même interpréteur Python que celui qui exécute le programme. Cette technique évite certaines ambiguïtés lorsqu'un ordinateur contient plusieurs installations de Python.
Le programme suivant affiche d'abord la commande qui pourrait être utilisée pour exécuter pip avec l'interpréteur courant.
1 2 3 4 | import sys commande = f'"{sys.executable}" -m pip --version' print(commande) |
Sortie possible :
1 | "C:\Users\dell\AppData\Local\Programs\Python\Python314\python.exe" -m pip --version |
Pour exécuter réellement une commande avec l'interpréteur courant depuis un programme Python, il est préférable d'utiliser le module subprocess et de transmettre les arguments sous forme de liste.
1 2 3 4 | import sys import subprocess subprocess.run([sys.executable, "-m", "pip", "--version"]) |
Sortie possible :
1 | pip 25.2 from C:\Users\dell\AppData\Local\Programs\Python\Python314\Lib\site-packages\pip (python 3.14) |
Cette méthode permet de s'assurer que pip est lancé avec l'interpréteur représenté par sys.executable.
8. Utiliser sys.executable pour lancer un autre script Python
Une autre utilisation de sys.executable consiste à lancer un autre script avec le même interpréteur Python que le programme courant. Nous pouvons pour cela utiliser subprocess.run().
Supposons que le fichier test.py contienne simplement une instruction affichant un message. Le programme principal peut le lancer avec l'interpréteur courant.
1 2 3 4 | import sys import subprocess subprocess.run([sys.executable, "test.py"]) |
Si test.py affiche le message « Script secondaire exécuté », nous obtenons :
1 | Script secondaire exécuté |
Nous pouvons également transmettre des arguments au script secondaire en les ajoutant à la liste.
1 2 3 4 | import sys import subprocess subprocess.run([sys.executable, "test.py", "Python", "25"]) |
Si le script test.py affiche les arguments reçus, la sortie peut être :
1 2 | Python 25 |
Cette technique évite d'écrire directement "python" dans le programme et permet de réutiliser explicitement l'interpréteur du processus courant.
9. Afficher les principales informations sur l'interpréteur
Nous pouvons combiner sys.executable avec d'autres informations du module sys pour obtenir une petite fiche descriptive de l'environnement Python courant.
Le programme suivant affiche le chemin de l'interpréteur, sa version, le préfixe courant et le préfixe de l'installation principale.
1 2 3 4 5 6 | import sys print("Interpréteur :", sys.executable) print("Version :", sys.version.split()[0]) print("Préfixe courant :", sys.prefix) print("Préfixe principal :", sys.base_prefix) |
Sortie possible :
1 2 3 4 | Interpréteur : C:\Users\dell\AppData\Local\Programs\Python\Python314\python.exe Version : 3.14.2 Préfixe courant : C:\Users\dell\AppData\Local\Programs\Python\Python314 Préfixe principal : C:\Users\dell\AppData\Local\Programs\Python\Python314 |
Nous pouvons compléter ces informations avec sys.platform afin de connaître l'identifiant de la plateforme sur laquelle Python fonctionne.
1 2 3 4 5 | import sys print("Interpréteur :", sys.executable) print("Version :", sys.version_info.major, sys.version_info.minor) print("Plateforme :", sys.platform) |
Sortie possible sous Windows :
1 2 3 | Interpréteur : C:\Users\dell\AppData\Local\Programs\Python\Python314\python.exe Version : 3 14 Plateforme : win32 |
10. À retenir
La variable sys.executable du module sys permet d'identifier l'interpréteur Python utilisé par le processus courant. Elle est particulièrement utile lorsqu'un ordinateur possède plusieurs installations ou plusieurs environnements Python.
- sys.executable fournit le chemin de l'exécutable Python courant lorsqu'il peut être déterminé.
- Sous Windows, le chemin se termine généralement par python.exe.
- Sous Linux ou macOS, le chemin de l'interpréteur possède une forme différente.
- Path(sys.executable) permet de manipuler facilement ce chemin avec pathlib.
- Path(sys.executable).name permet d'obtenir le nom de l'exécutable.
- Path(sys.executable).parent permet d'obtenir son dossier.
- Dans un environnement virtuel, sys.executable pointe normalement vers l'interpréteur associé à cet environnement.
- sys.prefix et sys.base_prefix peuvent aider à identifier un environnement virtuel.
- sys.executable -m pip permet de cibler le pip associé au même interpréteur.
- subprocess.run([sys.executable, ...]) permet de lancer un autre script avec le même interpréteur.
Le programme suivant rassemble les principales informations permettant d'identifier rapidement l'interpréteur Python utilisé.
1 2 3 4 5 6 7 8 9 10 11 | import sys from pathlib import Path interpreteur = Path(sys.executable) print("Interpréteur :", interpreteur) print("Nom :", interpreteur.name) print("Dossier :", interpreteur.parent) print("Version :", sys.version.split()[0]) print("Environnement :", sys.prefix) print("Installation principale :", sys.base_prefix) |
Sortie possible :
1 2 3 4 5 6 | Interpréteur : C:\Users\dell\AppData\Local\Programs\Python\Python314\python.exe Nom : python.exe Dossier : C:\Users\dell\AppData\Local\Programs\Python\Python314 Version : 3.14.2 Environnement : C:\Users\dell\AppData\Local\Programs\Python\Python314 Installation principale : C:\Users\dell\AppData\Local\Programs\Python\Python314 |
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/
