- À propos des environnements virtuels Python avec VS Code
- Préparer VS Code pour travailler avec Python
- Créer un environnement virtuel depuis le terminal de VS Code
- Sélectionner l'interpréteur Python de l'environnement virtuel
- Activer l'environnement virtuel dans le terminal de VS Code
- Installer des packages dans l'environnement virtuel
- Exécuter un programme avec l'environnement virtuel
- Utiliser requirements.txt dans VS Code
- Vérifier et résoudre les problèmes courants
- À retenir !
1. À propos des environnements virtuels Python avec VS Code
Visual Studio Code, généralement appelé VS Code, est un éditeur très utilisé pour développer des applications Python. Lorsqu'un projet utilise des bibliothèques externes, il est recommandé de travailler dans un environnement virtuel Python afin d'isoler ses packages et leurs versions des autres projets présents sur l'ordinateur.
Un environnement virtuel créé avec venv possède son propre interpréteur Python et son propre emplacement pour les packages. VS Code peut détecter cet environnement et utiliser son interpréteur pour exécuter le programme, analyser le code et travailler dans le terminal intégré.
Le programme suivant permet de vérifier quel interpréteur exécute actuellement le code et si celui-ci appartient à un environnement virtuel.
1 2 3 4 | import sys print("Interpréteur :", sys.executable) print("Environnement virtuel :", sys.prefix != sys.base_prefix) |
Sortie possible :
1 2 | Interpréteur : C:\mon_projet\.venv\Scripts\python.exe Environnement virtuel : True |
Lorsque le chemin de sys.executable pointe vers le dossier .venv et que la seconde valeur est True, le programme est exécuté avec l'interpréteur de l'environnement virtuel.
2. Préparer VS Code pour travailler avec Python
Avant de créer l'environnement virtuel, il faut disposer d'une installation fonctionnelle de Python et de VS Code. L'extension Python de Microsoft pour VS Code permet notamment de sélectionner l'interpréteur, d'exécuter les programmes et d'intégrer les outils Python à l'éditeur.
Dans le terminal intégré de VS Code, la commande suivante permet de vérifier que Python est accessible et d'afficher sa version.
1 | python --version |
Sortie possible :
1 | Python 3.14.1 |
Sur certains systèmes Linux ou macOS, la commande utilisée peut être python3.
1 | python3 --version |
Sortie possible :
1 | Python 3.14.1 |
Nous pouvons également afficher le chemin de l'interpréteur actuellement utilisé. Cette information sera utile pour le comparer ensuite avec celui de l'environnement virtuel.
1 | python -c "import sys; print(sys.executable)" |
Sortie possible :
1 | C:\Python314\python.exe |
À ce stade, le chemin peut correspondre à l'installation Python principale de l'ordinateur puisque l'environnement virtuel n'a pas encore été créé ou sélectionné.
3. Créer un environnement virtuel depuis le terminal de VS Code
VS Code possède un terminal intégré accessible depuis le menu Terminal. Il peut être utilisé comme un terminal classique pour créer l'environnement virtuel directement dans le dossier du projet.
Après avoir ouvert le dossier du projet dans VS Code, la commande suivante crée un environnement nommé .venv.
1 | python -m venv .venv |
Sortie :
1 2 | Aucun message n'est généralement affiché. Le dossier .venv est créé dans le projet. |
Sous Linux ou macOS, lorsque l'interpréteur est accessible avec la commande python3, nous pouvons utiliser la commande suivante.
1 | python3 -m venv .venv |
Sortie :
1 2 | Aucun message n'est généralement affiché. Le dossier .venv est créé dans le projet. |
Le dossier .venv contient l'interpréteur et les fichiers nécessaires au fonctionnement de l'environnement. Il est généralement placé à la racine du projet afin que VS Code puisse facilement le détecter.
4. Sélectionner l'interpréteur Python de l'environnement virtuel
Créer un environnement virtuel ne signifie pas automatiquement que toutes les opérations de VS Code l'utiliseront. Il faut vérifier que l'interpréteur Python sélectionné par l'éditeur correspond bien à celui du dossier .venv.
Dans VS Code, ouvrez la palette de commandes avec Ctrl+Shift+P sous Windows et Linux, ou Cmd+Shift+P sous macOS, puis recherchez la commande Python: Select Interpreter. Sélectionnez ensuite l'interpréteur correspondant à .venv.
Sous Windows, l'interpréteur sélectionné correspond généralement à un chemin semblable au suivant.
1 | C:\mon_projet\.venv\Scripts\python.exe |
Sortie attendue :
1 | L'interpréteur du dossier .venv est sélectionné pour le projet. |
Sous Linux ou macOS, le chemin possède généralement la structure suivante.
1 | /home/utilisateur/mon_projet/.venv/bin/python |
Sortie attendue :
1 | L'interpréteur .venv/bin/python est sélectionné pour le projet. |
Une fois l'interpréteur sélectionné, VS Code peut utiliser cet environnement pour plusieurs fonctionnalités Python du projet. La sélection de l'interpréteur et l'activation d'un terminal sont deux notions liées mais distinctes.
5. Activer l'environnement virtuel dans le terminal de VS Code
Lorsque nous ouvrons un terminal pour saisir directement des commandes Python ou pip, l'activation de l'environnement virtuel permet de placer ses exécutables en priorité dans le terminal. VS Code peut automatiquement activer l'environnement sélectionné lorsqu'un nouveau terminal Python est ouvert, selon sa configuration.
Activation sous Windows avec CMD
Si le terminal intégré utilise l'invite de commandes Windows, le script suivant active l'environnement .venv.
1 | .venv\Scripts\activate.bat |
Sortie possible :
1 | (.venv) C:\mon_projet> |
Activation sous Windows avec PowerShell
Lorsque le terminal intégré de VS Code utilise PowerShell, nous pouvons exécuter le script Activate.ps1.
1 | .venv\Scripts\Activate.ps1 |
Sortie possible :
1 | (.venv) PS C:\mon_projet> |
Activation sous Linux et macOS
Sous Linux et macOS, l'environnement est activé avec le script situé dans le dossier bin.
1 | source .venv/bin/activate |
Sortie possible :
1 | (.venv) utilisateur@ordinateur:~/mon_projet$ |
La présence de (.venv) devant l'invite constitue une indication visuelle courante que l'environnement a été activé dans le terminal.
6. Installer des packages dans l'environnement virtuel
Après avoir sélectionné et activé le bon environnement, nous pouvons installer les packages nécessaires au projet. Il est recommandé d'utiliser python -m pip afin que pip soit exécuté avec l'interpréteur Python correspondant à la commande python utilisée.
La commande suivante installe la bibliothèque requests dans l'environnement actif.
1 | python -m pip install requests |
Sortie possible :
1 2 3 | Collecting requests ... Successfully installed certifi-2025.8.3 charset-normalizer-3.4.3 idna-3.10 requests-2.32.5 urllib3-2.5.0 |
Nous pouvons vérifier que requests est installé dans cet environnement avec pip show.
1 | python -m pip show requests |
Sortie possible :
1 2 3 4 | Name: requests Version: 2.32.5 Summary: Python HTTP for Humans. ... |
La commande pip list permet quant à elle d'afficher l'ensemble des packages disponibles dans l'environnement.
1 | python -m pip list |
Sortie possible :
1 2 3 4 5 6 7 8 | Package Version ------------------ ------- certifi 2025.8.3 charset-normalizer 3.4.3 idna 3.10 pip 25.2 requests 2.32.5 urllib3 2.5.0 |
Les packages installés dans .venv restent ainsi isolés des packages appartenant aux autres environnements virtuels du système.
7. Exécuter un programme avec l'environnement virtuel
Après avoir sélectionné l'interpréteur de .venv dans VS Code, nous pouvons créer un fichier Python et l'exécuter avec l'environnement du projet. Le programme suivant importe requests et affiche sa version ainsi que le chemin de l'interpréteur utilisé.
1 2 3 4 5 | import sys import requests print("Python :", sys.executable) print("Requests :", requests.__version__) |
Sortie possible :
1 2 | Python : C:\mon_projet\.venv\Scripts\python.exe Requests : 2.32.5 |
Nous pouvons également contrôler directement si le programme est exécuté dans un environnement virtuel en comparant sys.prefix et sys.base_prefix.
1 2 3 4 5 6 7 | import sys if sys.prefix != sys.base_prefix: print("Le programme utilise un environnement virtuel.") print("Environnement :", sys.prefix) else: print("Le programme n'utilise pas un environnement virtuel.") |
Sortie possible :
1 2 | Le programme utilise un environnement virtuel. Environnement : C:\mon_projet\.venv |
Cette vérification est particulièrement utile lorsqu'un package fonctionne dans un terminal mais semble introuvable lorsque le programme est exécuté depuis VS Code : il faut alors vérifier que les deux utilisent le même interpréteur Python.
8. Utiliser requirements.txt dans VS Code
Le fichier requirements.txt permet d'enregistrer les dépendances du projet afin de pouvoir les réinstaller dans un autre environnement. Depuis le terminal intégré de VS Code, nous pouvons générer ce fichier à partir de l'environnement actif avec pip freeze.
La commande suivante crée ou remplace requirements.txt avec la liste des distributions installées et leurs versions.
1 | python -m pip freeze > requirements.txt |
Sortie :
1 2 | Aucun texte n'est normalement affiché. Le fichier requirements.txt est créé ou remplacé. |
Le fichier peut ensuite contenir des lignes semblables aux suivantes.
1 2 3 4 5 | certifi==2025.8.3 charset-normalizer==3.4.3 idna==3.10 requests==2.32.5 urllib3==2.5.0 |
Sortie :
1 | Les dépendances et leurs versions sont enregistrées dans requirements.txt. |
Lorsque le projet est récupéré sur un autre ordinateur ou lorsqu'un nouvel environnement virtuel vient d'être créé, la commande suivante permet de réinstaller les dépendances déclarées dans le fichier.
1 | python -m pip install -r requirements.txt |
Sortie possible :
1 2 3 4 5 | Collecting certifi==2025.8.3 Collecting charset-normalizer==3.4.3 Collecting requests==2.32.5 ... Successfully installed certifi-2025.8.3 charset-normalizer-3.4.3 requests-2.32.5 ... |
L'association de VS Code, .venv et requirements.txt facilite ainsi la création d'un environnement de développement isolé et reproductible.
9. Vérifier et résoudre les problèmes courants
L'un des problèmes les plus fréquents dans VS Code apparaît lorsqu'un package est correctement installé mais que l'éditeur ou le programme indique qu'il est introuvable. La première vérification consiste à comparer le chemin de l'interpréteur sélectionné avec celui réellement utilisé dans le terminal.
La commande suivante affiche l'interpréteur associé à la commande python du terminal.
1 | python -c "import sys; print(sys.executable)" |
Sortie attendue sous Windows :
1 | C:\mon_projet\.venv\Scripts\python.exe |
Nous pouvons ensuite vérifier quel pip est associé à cet interpréteur.
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 indiqué doit correspondre au dossier .venv lorsque nous souhaitons installer les packages dans cet environnement.
Si l'environnement n'est pas sélectionné dans VS Code, nous pouvons ouvrir la palette de commandes, exécuter Python: Select Interpreter puis choisir l'interpréteur de .venv. Un nouveau terminal peut ensuite être ouvert pour que son environnement corresponde à la nouvelle sélection.
Enfin, la commande suivante permet de vérifier la cohérence des dépendances installées.
1 | python -m pip check |
Sortie possible :
1 | No broken requirements found. |
Lorsque le programme fonctionne dans le terminal mais pas avec le bouton d'exécution de VS Code, il faut en priorité contrôler l'interpréteur sélectionné, le chemin de sys.executable et l'emplacement dans lequel pip a installé les packages.
10. À retenir !
L'utilisation d'un environnement virtuel Python avec VS Code permet d'isoler les dépendances d'un projet et d'éviter les conflits entre plusieurs applications Python. VS Code peut détecter les environnements virtuels présents dans un projet et utiliser l'interpréteur sélectionné pour les fonctionnalités Python de l'éditeur.
- python -m venv .venv permet de créer un environnement virtuel dans le projet.
- Le dossier .venv est un nom couramment utilisé pour stocker l'environnement.
- Python: Select Interpreter permet de sélectionner l'interpréteur Python utilisé par VS Code pour le projet.
- Sous Windows CMD, .venv\Scripts\activate.bat active l'environnement dans le terminal.
- Sous PowerShell, .venv\Scripts\Activate.ps1 permet d'activer l'environnement.
- Sous Linux et macOS, source .venv/bin/activate active l'environnement.
- python -m pip install permet d'installer un package avec l'interpréteur Python concerné.
- sys.executable permet de vérifier précisément l'interpréteur qui exécute un programme.
- requirements.txt permet d'enregistrer et de réinstaller les dépendances du projet.
- En cas de package introuvable, il faut vérifier que VS Code et le terminal utilisent bien le même environnement Python.
Le processus suivant résume la création et l'utilisation d'un environnement virtuel dans le terminal intégré de VS Code sous Windows avec CMD.
1 2 3 4 5 6 | python -m venv .venv .venv\Scripts\activate.bat python -m pip install requests python -m pip freeze > requirements.txt python -c "import sys; print(sys.executable)" python -m pip check |
Sortie possible :
1 2 3 | Successfully installed requests-2.32.5 ... C:\mon_projet\.venv\Scripts\python.exe No broken requirements found. |
Pour vérifier définitivement l'environnement depuis un programme Python exécuté dans VS Code, nous pouvons afficher les informations essentielles avec le code suivant.
1 2 3 4 5 6 | import sys print("Version Python :", sys.version.split()[0]) print("Interpréteur :", sys.executable) print("Environnement :", sys.prefix) print("Environnement virtuel :", sys.prefix != sys.base_prefix) |
Sortie possible :
1 2 3 4 | Version Python : 3.14.1 Interpréteur : C:\mon_projet\.venv\Scripts\python.exe Environnement : C:\mon_projet\.venv Environnement virtuel : True |
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/
