« Je pense que ce n’est pas dans ton PATH. » Si tu as déjà cherché la solution à une erreur sur Stack Overflow, tu as sûrement croisé cette réponse. Elle revient pour pip, jupyter, python, conda ou git : à chaque fois que le terminal ne trouve pas une commande.
Dans cet article, je t’explique ce qu’est la variable PATH, comment l’afficher, comment y ajouter un dossier sous Windows, macOS et Linux, et comment corriger les erreurs que les débutants en data science rencontrent le plus souvent.
Article mis à jour en novembre 2026 : j’ai testé toutes les commandes Linux dans un vrai terminal et les sorties sont affichées telles quelles. J’ai ajouté l’ordre des dossiers avec un exemple concret, les erreurs fréquentes en Python (pip --user, environnements virtuels), la modification du PATH dans un notebook, et j’ai corrigé le conseil sur setx sous Windows, qui est risqué.
En bref : le PATH est une liste de dossiers dans lesquels ton terminal cherche les programmes quand tu tapes une commande. Si une commande est introuvable, c’est que son dossier n’est pas dans cette liste. Pour l’ajouter, utilise export PATH="$PATH:/mon/dossier" sous Linux et macOS (à mettre dans ~/.bashrc ou ~/.zshrc pour le rendre permanent), ou la fenêtre « Variables d’environnement » sous Windows. L’ordre compte : le premier dossier qui contient la commande gagne.
Tu peux exécuter les commandes Linux et les exemples Python de cet article dans ce notebook Google Colab (les résultats peuvent différer légèrement de ceux affichés ici).
Note sur mes tests : j’ai exécuté les commandes sous Linux avec le shell Bash, dans un environnement où j’ai volontairement réduit le PATH à deux dossiers pour que les sorties restent lisibles. Sous macOS, le fonctionnement est le même (avec Zsh comme shell par défaut). Les étapes Windows n’ont pas pu être testées ici : je me suis appuyé sur la documentation de Microsoft.
Qu’est-ce que la variable PATH ?
Où se trouve réellement une commande comme git ?
Quelle commande de terminal utilises-tu le plus ? Pour moi, c’est git. La plupart des commandes sont en réalité des fichiers exécutables, rangés dans un dossier du système. La commande which (where sous Windows) affiche leur emplacement :
which git/usr/bin/gitC’est un chemin absolu vers un fichier exécutable. Sous Windows, ce serait un fichier .exe. Ce fichier contient les instructions qui s’exécutent quand tu tapes git. Tu peux donc lancer la commande avec son chemin complet, et obtenir exactement le même résultat :
/usr/bin/git --version
git --versiongit version 2.43.0
git version 2.43.0Voici la question intéressante : comment le mot git peut-il remplacer le chemin /usr/bin/git ? Ton ordinateur ne devine pas, il consulte une liste.
Comment le terminal trouve-t-il la commande que tu tapes ?
Cette liste, c’est la variable d’environnement PATH. Elle contient les dossiers où se trouvent les exécutables des commandes. Quand tu tapes une commande, le système parcourt ces dossiers, dans l’ordre, et lance le premier exécutable portant ce nom.

Si aucun dossier du PATH ne contient la commande, le terminal affiche une erreur :
unknown_commandbash: line 1: unknown_command: command not foundLe message exact dépend du shell. Ici, « line 1 » apparaît parce que j’ai lancé la commande dans un script ; dans ton terminal Bash, tu verras bash: unknown_command: command not found, et sous Zsh (macOS) zsh: command not found: unknown_command. Sous Windows, le message est « n’est pas reconnu en tant que commande interne ou externe ».
Grâce au PATH, tu n’as pas à retenir le chemin de chaque programme installé sur ton ordinateur.
Comment afficher le contenu du PATH ?
Sous Linux et macOS, la commande echo $PATH affiche le PATH. Les dossiers sont séparés par deux-points (:) :
echo $PATH/usr/local/bin:/usr/binPlus lisible : remplace chaque deux-points par un retour à la ligne avec tr pour obtenir un dossier par ligne :
echo $PATH | tr ':' '\n'/usr/local/bin
/usr/binSous Windows, les dossiers sont séparés par un point-virgule (;). Dans l’Invite de commandes, tape echo %PATH%. Dans PowerShell, la syntaxe est différente :
$env:Path -split ';'Pour savoir quel fichier sera exécuté pour une commande donnée, utilise which (ou where sous Windows). Sous Bash, type -a liste toutes les correspondances, dans l’ordre de recherche :
type -a git
command -v gitgit is /usr/bin/git
/usr/bin/gitIl y a deux correspondances ici parce que, sur ce système, /bin est un lien vers /usr/bin : c’est le même fichier, trouvé deux fois.
Comment lire le PATH avec Python ?
Le module os donne accès aux variables d’environnement, et shutil.which() reproduit la recherche du terminal. Cela fonctionne pareil sous Windows, macOS et Linux grâce à os.pathsep, qui vaut : ou ; selon le système :
import os
import shutil
print(os.pathsep)
for dossier in os.environ["PATH"].split(os.pathsep):
print(dossier)
print(shutil.which("git"))
print(shutil.which("commande_inconnue"))Python:
/usr/local/bin
/usr/bin
/usr/bin/git
NoneLa fonction shutil.which() renvoie le chemin de la commande trouvée, ou None si elle est introuvable.
Quel dossier est prioritaire quand plusieurs contiennent la même commande ?
L’ordre des dossiers dans le PATH détermine la priorité : le système les parcourt de gauche à droite et utilise le premier exécutable trouvé. Voyons-le avec un exemple. Je crée deux dossiers qui contiennent chacun un petit programme nommé bonjour, puis je les place dans le PATH :
mkdir -p ~/outils-a ~/outils-b
printf '#!/bin/sh\necho "version A"\n' > ~/outils-a/bonjour
printf '#!/bin/sh\necho "version B"\n' > ~/outils-b/bonjour
chmod +x ~/outils-a/bonjour ~/outils-b/bonjour
export PATH="$HOME/outils-a:$HOME/outils-b:$PATH"
bonjour
type -a bonjourversion A
bonjour is /home/rod/outils-a/bonjour
bonjour is /home/rod/outils-b/bonjourC’est la version A qui s’exécute, parce que le dossier outils-a est placé avant outils-b. La commande type -a montre les deux, le premier étant celui utilisé. Si j’inverse l’ordre, le résultat change :
export PATH="$HOME/outils-b:$HOME/outils-a:$PATH"
bonjour
type -a bonjourversion B
bonjour is /home/rod/outils-b/bonjour
bonjour is /home/rod/outils-a/bonjourCet ordre est la raison pour laquelle, quand tu as plusieurs versions de Python (celle du système, celle d’Anaconda, celle d’un environnement virtuel), la commande python lance celle dont le dossier est le plus à gauche dans le PATH.
Comment ajouter un dossier au PATH sous Linux et macOS ?
Comment l’ajouter temporairement ?
Avec la commande export. Pour ajouter le dossier ~/articles au début du PATH, il passera avant les autres :
mkdir -p ~/articles
export PATH="$HOME/articles:$PATH"
echo $PATH/home/rod/articles:/usr/local/bin:/usr/binPour l’ajouter à la fin, place $PATH en premier. Les dossiers existants gardent alors leur priorité :
export PATH="$PATH:$HOME/articles"
echo $PATH/usr/local/bin:/usr/bin:/home/rod/articlesCette modification ne dure que le temps de la session de terminal. Si je ferme le terminal et que j’en ouvre un nouveau, le PATH est revenu à son état d’origine :
echo $PATH/usr/local/bin:/usr/binComment l’ajouter de façon permanente ?
Il faut écrire la commande export dans le fichier de configuration de ton shell, que le terminal lit à chaque ouverture. Le fichier dépend du shell :
- Bash :
~/.bashrc(parfois~/.bash_profileou~/.profile, selon le système) - Zsh (le shell par défaut de macOS) :
~/.zshrc - Fish :
~/.config/fish/config.fish, avec la syntaxefish_add_path /mon/dossierau lieu deexport
Pour savoir quel shell tu utilises, tape echo $SHELL. Avec Bash, j’ajoute la ligne à la fin du fichier, puis je vérifie :
echo 'export PATH="$PATH:$HOME/articles"' >> ~/.bashrc
tail -n 1 ~/.bashrcexport PATH="$PATH:$HOME/articles"Les guillemets simples sont importants : ils empêchent le shell de remplacer $PATH tout de suite, la variable est développée à chaque ouverture du terminal. Un nouveau terminal lit le fichier tout seul. Dans le terminal en cours, recharge-le avec source :
source ~/.bashrc
echo $PATH/usr/local/bin:/usr/bin:/home/rod/articlesDans le terminal en cours, la modification n’est pas visible tant que tu ne recharges pas le fichier, et lancer source ~/.bashrc plusieurs fois ajoutera le dossier plusieurs fois. Ce n’est pas grave, mais ton PATH devient inutilement long.
Quelle est l’erreur la plus fréquente avec export PATH ?
Oublier $PATH dans la nouvelle valeur. Tu remplaces alors tout le PATH par ton seul dossier, et le terminal ne retrouve plus aucune commande, pas même ls :
export PATH="/home/rod/articles"
lsbash: line 2: ls: command not foundPas de panique : cette modification ne vaut que pour la session en cours, il suffit de fermer et rouvrir le terminal. Si tu as écrit l’erreur dans ~/.bashrc, corrige la ligne avec un éditeur de texte, en passant par le chemin complet de l’éditeur (par exemple /usr/bin/nano ~/.bashrc) puisque le PATH est cassé.
Comment ajouter un dossier au PATH sous Windows ?
Je n’ai pas pu tester cette partie, car mon environnement tourne sous Linux. Les étapes suivent la documentation de Microsoft. La méthode la plus sûre passe par l’interface graphique :
- Clique sur le menu Démarrer et cherche « Modifier les variables d’environnement système » (« Edit the system environment variables » sur un Windows en anglais), puis ouvre le premier résultat.
- Dans la fenêtre « Propriétés système », clique sur « Variables d’environnement… ».
- Choisis où ajouter le chemin : dans « Variables utilisateur » (pour ton compte seulement) ou dans « Variables système » (pour tous les comptes, avec les droits d’administrateur).
- Sélectionne la variable « Path » puis clique sur « Modifier… ».
- Clique sur « Nouveau » et colle le dossier, par exemple
C:\Users\rod\Desktop\articles. - Valide avec OK dans les trois fenêtres, puis ouvre un nouveau terminal : les terminaux déjà ouverts ne voient pas le changement.
Dans cette fenêtre de modification, tu peux aussi supprimer un chemin ou changer l’ordre avec « Monter » et « Descendre », ce qui change la priorité (voir la section précédente sur l’ordre).
Pourquoi éviter setx pour modifier le PATH ?
Beaucoup de tutoriels proposent setx PATH "%PATH%;C:\mon\dossier". Je te le déconseille, pour deux raisons. D’abord, setx tronque la valeur à 1 024 caractères, comme l’indique la documentation de Microsoft : si ton PATH est long, tu perds des chemins sans avertissement. Ensuite, %PATH% contient la valeur combinée du PATH système et du PATH utilisateur, et setx enregistre le tout dans ton PATH utilisateur.
Si tu préfères la ligne de commande, PowerShell permet de modifier uniquement le PATH de ton compte :
$ancien = [Environment]::GetEnvironmentVariable("Path", "User")
[Environment]::SetEnvironmentVariable("Path", "$ancien;C:\Users\rod\Desktop\articles", "User")Ce code lit le PATH utilisateur, y ajoute le dossier et l’enregistre durablement (la documentation de PowerShell précise que les portées User et Machine persistent après la session). Là encore, ouvre un nouveau terminal pour voir la modification.
Pourquoi pip, jupyter ou python sont-ils introuvables en data science ?
Pour un débutant en data science, les erreurs de PATH viennent presque toujours de trois situations.
Pourquoi une commande installée avec pip –user est-elle introuvable ?
Quand tu installes un paquet avec pip install --user, ses commandes sont rangées dans ~/.local/bin (sous Linux et macOS), un dossier souvent absent du PATH. Voici ce que dit pip quand j’installe pyfiglet :
python3 -m pip install --user -q pyfiglet WARNING: The script pyfiglet is installed in '/home/rod/.local/bin' which is not on PATH.
Consider adding this directory to PATH or, if you prefer to suppress this warning, use --no-warn-script-location.Le message est clair : le dossier n’est pas dans le PATH. Et en effet, la commande est introuvable :
pyfiglet -f small PATHbash: line 1: pyfiglet: command not foundPourtant, elle est bien installée : avec son chemin complet, elle fonctionne.
~/.local/bin/pyfiglet -f small PATH ___ _ _____ _ _
| _ \/_\_ _| || |
| _/ _ \| | | __ |
|_|/_/ \_\_| |_||_|
La solution consiste à ajouter ce dossier au PATH, comme vu plus haut (et à mettre la ligne dans ton fichier de configuration pour la garder) :
export PATH="$HOME/.local/bin:$PATH"
pyfiglet -f small PATH
which pyfiglet ___ _ _____ _ _
| _ \/_\_ _| || |
| _/ _ \| | | __ |
|_|/_/ \_\_| |_||_|
/home/rod/.local/bin/pyfigletIl existe aussi un contournement qui ne dépend pas du PATH : lancer le module avec l’interpréteur Python (python3 -m nom_du_module). C’est pour cette raison qu’on recommande d’écrire python -m pip install ... plutôt que pip install ... : tu es sûr d’utiliser le pip du Python que tu as choisi.
python3 -m pyfiglet -f small PATH ___ _ _____ _ _
| _ \/_\_ _| || |
| _/ _ \| | | __ |
|_|/_/ \_\_| |_||_|
Que fait un environnement virtuel au PATH ?
Quand tu actives un environnement virtuel (venv, virtualenv), l’activation place son dossier en tête du PATH. C’est ce qui fait que python et pip pointent vers l’environnement. Je crée un environnement, puis je compare le PATH avant et après l’activation :
python3 -m venv ~/mon-env
echo $PATH
which python3/usr/local/bin:/usr/bin
/usr/bin/python3source ~/mon-env/bin/activate
echo $PATH | tr ':' '\n' | head -3
which python
deactivate
which python3/home/rod/mon-env/bin
/usr/local/bin
/usr/bin
/home/rod/mon-env/bin/python
/usr/bin/python3Une fois l’environnement activé, python vient de mon-env/bin, placé en premier dans le PATH. Après deactivate, on retrouve le Python du système. Si pip installe des paquets au mauvais endroit, vérifie avec which python que l’environnement est bien activé.
Et avec Anaconda, Miniconda ou l’installateur de Python ?
Ces outils modifient le PATH à ta place, mais pas de la même façon :
- Conda : la commande
conda initécrit un bloc dans ton fichier de configuration de shell (~/.bashrcou~/.zshrc), pour quecondasoit disponible à l’ouverture d’un terminal. Sous Windows, ouvre plutôt l’« Anaconda Prompt » depuis le menu Démarrer, qui configure le PATH pour toi. - L’installateur Python pour Windows propose une case « Add python.exe to PATH ». Si tu l’as oubliée, la commande
pythonsera introuvable : relance l’installateur et coche-la, ou ajoute le dossier à la main, comme vu plus haut. - Plusieurs versions de Python : relis la section sur l’ordre, c’est le dossier le plus à gauche qui gagne.
Comment modifier le PATH dans un notebook Jupyter ou Colab ?
Un notebook hérite du PATH du programme qui l’a lancé. Pour qu’un changement persiste, modifie le PATH avant de lancer Jupyter. Depuis le notebook, tu peux quand même modifier le PATH du noyau en cours avec os.environ : le changement vaut pour ce noyau et pour les commandes qu’il lance, pas pour ton terminal ni pour la prochaine session. Reprenons le programme bonjour :
import os
import shutil
import subprocess
print(shutil.which("bonjour"))
os.environ["PATH"] = os.path.expanduser("~/outils-a") + os.pathsep + os.environ["PATH"]
print(shutil.which("bonjour"))
subprocess.run(["bonjour"])PythonNone
/home/rod/outils-a/bonjour
version AAvant la modification, shutil.which() renvoie None : le programme est introuvable. Après avoir ajouté son dossier à os.environ["PATH"], il est trouvé, et subprocess.run() peut l’exécuter. Dans Colab ou Jupyter, une cellule qui commence par ! lance une commande dans un sous-shell : un export n’y persiste donc pas d’une cellule à l’autre, alors que os.environ si.
Questions fréquentes
Qu’est-ce que la variable PATH ?
Le PATH est une variable d’environnement qui contient la liste des dossiers où le système cherche les programmes quand tu tapes une commande. Les dossiers sont séparés par deux-points sous Linux et macOS, et par un point-virgule sous Windows. Sans elle, tu devrais taper le chemin complet de chaque exécutable.
Comment afficher le PATH sous Windows, macOS et Linux ?
Sous Linux et macOS, tape echo $PATH. Sous Windows, tape echo %PATH% dans l’Invite de commandes, ou $env:Path -split ‘;’ dans PowerShell. Avec Python, os.environ[“PATH”].split(os.pathsep) fonctionne sur les trois systèmes.
Comment ajouter un dossier au PATH de façon permanente ?
Sous Linux et macOS, ajoute la ligne export PATH=”$PATH:/mon/dossier” à ton fichier de configuration (~/.bashrc pour Bash, ~/.zshrc pour Zsh), puis ouvre un nouveau terminal. Sous Windows, passe par « Variables d’environnement », sélectionne Path, clique sur Modifier puis Nouveau. Les terminaux déjà ouverts ne voient pas le changement.
Pourquoi ai-je l’erreur « command not found » ou « n’est pas reconnu » ?
Le terminal n’a trouvé la commande dans aucun dossier du PATH. Vérifie d’abord l’orthographe, puis cherche où le programme est installé et ajoute ce dossier au PATH. Pour les commandes installées avec pip –user, il s’agit souvent du dossier ~/.local/bin.
Que se passe-t-il quand plusieurs dossiers du PATH contiennent la même commande ?
Le système parcourt les dossiers de gauche à droite et exécute le premier exécutable trouvé. Dans mon test, avec les dossiers outils-a puis outils-b, la commande bonjour lance la version A. En inversant l’ordre, la version B s’exécute. type -a (Bash) ou where (Windows) liste toutes les correspondances.
Pourquoi vaut-il mieux écrire python -m pip que pip ?
Parce que le pip lancé par la commande pip n’est pas forcément celui du Python que tu utilises, selon l’ordre de ton PATH. Avec python -m pip, tu utilises toujours le pip de l’interpréteur Python que tu as appelé, ce qui évite d’installer des paquets au mauvais endroit.
Conclusion : que retenir de la variable PATH ?
Le PATH est une simple liste de dossiers, parcourue de gauche à droite à chaque commande. Tu sais maintenant l’afficher, y ajouter un dossier (temporairement ou de façon permanente), comprendre pourquoi l’ordre compte et corriger les erreurs classiques de la data science : une commande installée avec pip --user, un environnement virtuel, plusieurs versions de Python. Prends l’habitude de lancer which (ou where) dès qu’une commande se comporte bizarrement.
Pour progresser en Python et en data science, le mieux est de pratiquer. Sur DataXp, tu apprends Python et la data science avec des exercices pratiques à faire directement en ligne.
Pour aller plus loin, voici d’autres articles qui pourraient te plaire :













