Installer Python avec uv, VS Code et Jupyter : un poste prêt pour le machine learning
Installer Python ne suffit pas pour gérer efficacement un projet. Il faut aussi isoler ses bibliothèques dans un environnement virtuel, gérer leurs versions et pouvoir reconstituer cet environnement sur un autre ordinateur. Plusieurs outils répondent à ces besoins, avec des rôles différents : pip, venv, Conda, Poetry ou encore Pipenv.
uv, développé par Astral en Rust, réunit ces opérations dans un même outil : installer des versions de Python, initialiser un projet, créer son environnement virtuel et gérer ses dépendances. Cette approche permet de suivre un même flux de travail tout au long du tutoriel.
La figure 1 illustre aussi sa rapidité dans un cas précis : l’installation des dépendances de Trio, comparée à Poetry, PDM et pip-sync. Le test utilise un cache déjà rempli, c’est-à-dire des paquets conservés sur l’ordinateur après une installation précédente.
Dans ce tutoriel, nous utiliserons uv pour préparer le projet D:\ML-projects\projet-ia, installer ses bibliothèques et configurer VS Code et Jupyter. Vous créerez ensuite TesterProjet.ipynb pour vérifier le Python du noyau et les versions des bibliothèques. La lecture des données sera abordée dans la prochaine leçon.
Sommaire
1. Comprendre les outils et le choix de uv
Ces outils ont des rôles distincts. Python est le langage ; son interpréteur est le programme qui exécute le code. Une bibliothèque fournit du code réutilisable : pandas, par exemple, permet de lire et de manipuler des tableaux. Une bibliothèque nécessaire au projet devient une de ses dépendances.
VS Code est l’éditeur dans lequel vous organisez les fichiers et écrivez le code. Un notebook Jupyter est un document .ipynb composé de cellules de texte et de code, avec leurs sorties. Le noyau est le processus qui exécute ces cellules et conserve les variables en mémoire. L’extension Jupyter de VS Code fournit l’interface ; ipykernel, installé dans le Python choisi, permet l’exécution des cellules Python. Voir la documentation Microsoft sur les noyaux.
Pourquoi créer un environnement virtuel ?
Un environnement virtuel est un dossier qui contient un exécutable Python propre au projet et ses bibliothèques, isolées par défaut de celles des autres installations. Dans ce guide, ce dossier s’appelle .venv. La documentation Python sur les environnements virtuels explique cette isolation : plusieurs projets peuvent ainsi utiliser des versions différentes d’une même bibliothèque. Vous pouvez conserver Anaconda ou une autre installation de Python. Pour ce projet, le notebook doit utiliser le Python de sa .venv comme noyau.
.venv conserve le Python et ses bibliothèques sur le disque. Le noyau, actif en mémoire, utilise cet interpréteur pour exécuter les cellules et renvoyer leurs sorties. sys.executable permet de vérifier le chemin de l’exécutable.La figure 2 distingue deux niveaux. Sur le disque, .venv conserve l’exécutable et les paquets installés. Sous Windows, leurs chemins sont .venv\Scripts\python.exe et .venv\Lib\site-packages. Sur macOS ou Linux, l’exécutable est généralement .venv/bin/python. En mémoire, VS Code affiche le notebook et envoie son code au noyau ; celui-ci exécute les cellules, importe les bibliothèques de son environnement et renvoie les résultats.
Créer la .venv et y installer les bibliothèques ne suffit donc pas : il faut aussi démarrer le noyau avec son Python. Le dossier reste présent lorsque le noyau s’arrête, mais les variables du processus sont perdues. Le fichier .ipynb, lui, conserve les cellules et les sorties enregistrées ; rouvrir une ancienne sortie ne recrée pas les variables qui l’ont produite.
uv est un outil de gestion de Python et de projets Python développé par Astral. Nous l’utilisons pour installer Python, créer le projet, ajouter ses dépendances et lancer le code dans sa .venv. Ces fonctions sont décrites dans la documentation de uv.
Pour approfondir : comparer uv, pip, conda et Poetry
| Outil | Rôle et intérêt |
|---|---|
| pip | Installe des paquets Python dans un environnement. Le flux classique l’associe à venv et à des fichiers de dépendances. |
| conda | Gère des environnements et des paquets Python ou non Python, depuis des canaux de distribution. |
| Poetry | Gère les dépendances, les environnements, un fichier de verrouillage et la construction de paquets Python. |
| uv | Réunit la gestion de Python, des environnements, des dépendances et de l’exécution. Utilise un cache partagé et uv.lock. |
pip installe des paquets dans un Python identifié ; conda gère des environnements et des paquets Python ou non Python ; Poetry organise les dépendances et la distribution de projets Python. Le choix de uv permet ici de suivre un seul flux de travail. Retrouvez les usages de pip, la gestion des environnements conda et la prise en main de Poetry.
2. Installer Python avec uv sous Windows
Ouvrez PowerShell depuis le menu Démarrer. Un terminal est une interface dans laquelle vous saisissez des commandes ; PowerShell est le programme qui les interprète ici. Nous utiliserons ensuite le terminal PowerShell intégré à VS Code.
Vérifier ou installer uv
Commencez par vérifier s’il est déjà disponible :
# Vérifier la version de uv
PS C:\WINDOWS\system32> uv --version
uv 0.12.23Si un numéro de version s’affiche, passez à l’installation de Python ci-dessous. La sortie montrée est abrégée : uv peut aussi afficher des informations de compilation. Si Windows indique que uv n’est pas reconnu, utilisez la commande Windows de l’installateur officiel Astral :
# Installer uv avec le script officiel
PS C:\WINDOWS\system32> powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"Cette commande télécharge et exécute l’installateur depuis le domaine d’Astral. L’option ByPass permet l’exécution du script dans le processus PowerShell lancé par cette commande. Elle ne modifie pas durablement la stratégie d’exécution du système ; une stratégie de groupe peut toutefois rester prioritaire. Voir les stratégies d’exécution PowerShell.
Après l’installation, fermez puis rouvrez PowerShell et relancez uv --version, afin que le terminal retrouve le nouvel exécutable. Sur mon ordinateur, uv était déjà installé ; une réinstallation n’était pas nécessaire.
Installer la version de Python du projet
# Installer Python 3.14 avec uv
PS C:\WINDOWS\system32> uv python install 3.14
Python 3.14 is already installedNous utilisons la version 3.14 de Python, compatible avec les bibliothèques utilisées dans cette leçon. La sortie ci-dessus indique que cette version était déjà installée. Sur un nouveau poste, uv la téléchargera. uv sait installer et retrouver Python sans installation manuelle préalable depuis python.org.
Via uv, où Python est-il installé ?
La commande uv python install 3.14 installe par défaut CPython, l’implémentation de référence du langage Python, définie dans le glossaire Python. uv conserve cette installation dans son dossier des versions de Python, en dehors du projet. Avec uv 0.12.23 sur notre ordinateur, ce dossier est C:\Users\Nitro\AppData\Roaming\uv\python. Dans ce chemin, Nitro est le nom du compte Windows utilisé pour les captures. Pour connaître l’emplacement de CPython sur votre ordinateur, lancez :
# Afficher le dossier des installations Python gérées par uv
PS C:\WINDOWS\system32> uv python dir
C:\Users\Nitro\AppData\Roaming\uv\pythonCette installation de CPython peut servir de base à plusieurs projets. À l’étape suivante, nous créerons l’environnement virtuel propre à cette leçon dans D:\ML-projects\projet-ia\.venv. Les bibliothèques du projet seront installées dans cette .venv, dont le Python sera ensuite choisi comme noyau dans VS Code.
3. Créer le projet et sa .venv
Un projet regroupe le code, ses données et ses réglages. Dans l’Explorateur Windows, créez le dossier parent D:\ML-projects s’il n’existe pas, puis placez-vous dedans avec PowerShell. Ce chemin correspond à l’emplacement des captures : adaptez-le à votre ordinateur. Dans les blocs suivants, saisissez seulement les commandes.
# Se placer dans le dossier de projets
PS C:\WINDOWS\system32> Set-Location -LiteralPath "D:\ML-projects"Initialisez le projet depuis ce dossier parent :
# Créer le projet d’application Python
PS D:\ML-projects> uv init --app --no-package --vcs none projet-ia --python 3.14
Initialized project `projet-ia` at `D:\ML-projects\projet-ia`uv init crée les fichiers du projet. --app --no-package prépare une application simple sans structure de paquet à distribuer ; --vcs none évite de créer un dépôt Git à cette étape ; --python 3.14 choisit la version de Python. Entrez ensuite dans projet-ia, puis affichez son contenu avec ls, l’alias PowerShell de Get-ChildItem.
# Entrer dans le dossier du projet
PS D:\ML-projects> cd projet-ia# Lister le contenu du dossier
PS D:\ML-projects\projet-ia> ls
Répertoire : D:\ML-projects\projet-ia
Mode LastWriteTime Length Name
---- ------------- ------ ----
-a---- 10/10/2026 08:34 5 .python-version
-a---- 10/10/2026 08:34 87 main.py
-a---- 10/10/2026 08:34 155 pyproject.toml
-a---- 10/10/2026 08:34 0 README.mdCette sortie montre les quatre fichiers créés par uv init.
Créer l’environnement virtuel avec uv
Depuis projet-ia, créez explicitement la .venv avec le Python de la série 3.14 :
# Créer l’environnement .venv avec Python 3.14
PS D:\ML-projects\projet-ia> uv venv --python 3.14
Using CPython 3.14.8
Creating virtual environment at: .venv
Activate with: .venv\Scripts\activateDans la capture, uv utilise CPython 3.14.8 et crée D:\ML-projects\projet-ia\.venv. La ligne Activate with: indique une possibilité d’activation ; celle-ci n’est pas nécessaire pour les commandes de projet uv. Voir la documentation de uv venv. Lancez le script créé par l’initialisation :
# Exécuter main.py dans l’environnement du projet
PS D:\ML-projects\projet-ia> uv run main.py
Hello from projet-ia!Le message Hello from projet-ia! confirme que le programme s’exécute. uv run utilise le Python de la .venv sans activation manuelle. Toutes les commandes uv add, uv run et uv sync de la suite se lancent depuis projet-ia, là où se trouve pyproject.toml. Les sorties PowerShell reproduites dans ce guide correspondent aux captures de cette installation ; les temps de traitement varient selon le poste.
4. Ajouter les bibliothèques et comprendre les fichiers
Nous préparons pandas pour manipuler les tableaux et openpyxl pour lire les classeurs Excel .xlsx dans la prochaine leçon. ipykernel permettra dès maintenant d’exécuter les cellules Python du notebook.
Dans PowerShell, depuis projet-ia, lancez :
# Ajouter pandas et openpyxl pour travailler avec Excel
PS D:\ML-projects\projet-ia> uv add pandas openpyxl
Resolved 8 packages in 390ms
Installed 7 packages in 1.95s
+ et-xmlfile==2.0.0
+ numpy==2.5.3
+ openpyxl==3.1.5
+ pandas==3.0.6
+ python-dateutil==2.9.0.post0
+ six==1.17.0
+ tzdata==2026.5Ajoutez ensuite le noyau au groupe des outils de développement :
# Ajouter ipykernel aux dépendances de développement
PS D:\ML-projects\projet-ia> uv add --dev ipykernel
Resolved 39 packages in 730ms
Installed 26 packages in 7.30s
+ asttokens==3.0.2
+ colorama==0.4.6
+ comm==0.2.3
+ debugpy==1.8.22
+ executing==2.2.1
+ ipykernel==7.4.0
+ ipython==9.17.1
+ ipython-pygments-lexers==1.1.1
+ jedi==0.20.0
+ jupyter-client==8.10.0
+ jupyter-core==5.9.1
+ matplotlib-inline==0.2.2
+ nest-asyncio2==1.7.4
+ packaging==26.3
+ parso==0.8.7
+ platformdirs==4.12.4
+ prompt-toolkit==3.0.53
+ psutil==7.2.2
+ pure-eval==0.2.4
+ pygments==2.21.0
+ pyzmq==27.2.0
+ stack-data==0.6.3
+ tornado==6.5.10
+ traitlets==5.16.1
+ typing-extensions==4.16.0
+ wcwidth==0.9.2Les paquets supplémentaires sont des dépendances indirectes : les bibliothèques demandées en ont elles-mêmes besoin. Vous n’avez pas à saisir leurs noms. --dev place ipykernel dans le groupe dev, que uv synchronise par défaut. Pour un noyau Python local dans VS Code, l’extension Jupyter et ipykernel suffisent ; le paquet Python complet jupyter n’est pas requis. Cette configuration suit la procédure Astral pour VS Code. Les bibliothèques de graphiques et de machine learning seront ajoutées lorsqu’elles seront utiles.
pyproject.toml, uv.lock et .venv
Après uv add pandas openpyxl, les dépendances apparaissent dans deux fichiers et un dossier. Chacun a un rôle précis : déclarer les besoins du projet, conserver les versions choisies et installer les paquets. La figure 3 suit pandas dans ces trois étapes.
-
Déclarer
pyproject.tomlpandas>=3.0.6Le projet demande pandas 3.0.6 ou une version supérieure compatible. -
Verrouiller
uv.lockpandas : 3.0.6 uv enregistre la version exacte choisie et celles des dépendances indirectes. -
Installer
.venvPython + pandas 3.0.6 L’environnement virtuel contient Python et les paquets prêts à être utilisés sur ce poste.
Dans pyproject.toml, pandas>=3.0.6 est une contrainte de version : elle autorise pandas 3.0.6 ou une version supérieure, à condition que les autres exigences du projet soient respectées. Ce fichier exprime les besoins du projet.
uv effectue ensuite la résolution des dépendances : il choisit un ensemble de versions compatibles, en tenant compte aussi des bibliothèques nécessaires à pandas, comme NumPy. Le verrouillage enregistre ces choix exacts dans uv.lock. Dans ce projet, pandas est verrouillé à la version 3.0.6. Ces rôles sont détaillés dans la documentation sur la structure des projets uv.
Enfin, la synchronisation installe les paquets nécessaires dans .venv, l’environnement virtuel local du projet. Par défaut, uv add réalise les trois opérations : il ajoute les dépendances à pyproject.toml, met à jour uv.lock et synchronise .venv. Le fichier .python-version, distinct de ces trois éléments, indique la version de Python choisie.
Les commandes uv add ont rempli pyproject.toml. Voici son contenu dans la capture :
pandas et openpyxl sont des dépendances du projet ; ipykernel appartient au groupe dev.Dans la capture suivante de uv.lock, vous retrouvez la version exacte de pandas : 3.0.6. À l’étape 5, vous ouvrirez le dossier du projet pour retrouver ces fichiers dans l’Explorateur.
pandas enregistre la version 3.0.6, sa source et ses dépendances.Conservez et partagez pyproject.toml et uv.lock avec votre code. Le dossier .venv reste propre à votre poste : uv peut le recréer à partir de ces fichiers. Pour installer les dépendances verrouillées ou vérifier que l’environnement leur correspond, sans modifier le verrouillage, utilisez :
# Synchroniser l’environnement à partir de uv.lock
PS D:\ML-projects\projet-ia> uv sync --locked
Resolved 39 packages in 40ms
Checked 33 packages in 8msDans la capture, les paquets sont déjà installés : uv vérifie l’environnement. --locked provoque une erreur si le verrou doit être actualisé pour correspondre au projet. Le verrouillage facilite la reproduction des dépendances, sans garantir des résultats identiques sur tous les matériels et systèmes. Voir le verrouillage et la synchronisation.
5. Ouvrir le projet dans VS Code
Le projet et ses bibliothèques sont prêts. Nous allons maintenant ouvrir ce dossier dans VS Code pour créer le notebook et choisir son noyau. Si VS Code n’est pas encore installé, téléchargez l’installateur Windows depuis le site officiel, lancez-le, puis ouvrez l’application. La documentation Microsoft précise les options d’installation. Si VS Code est déjà installé, poursuivez directement en ouvrant le dossier.
Ouvrir le bon dossier
Dans PowerShell, depuis D:\ML-projects\projet-ia, lancez la commande montrée dans la capture :
# Ouvrir le dossier du projet dans VS Code
PS D:\ML-projects\projet-ia> code .Le point . désigne le dossier courant. Cette commande ouvre projet-ia dans VS Code. Si code n’est pas reconnu, ouvrez VS Code puis choisissez Fichier → Ouvrir le dossier et sélectionnez votre dossier projet-ia. L’Explorateur doit afficher .venv, pyproject.toml et uv.lock au premier niveau.
Installer les extensions Python et Jupyter
Ouvrez le panneau Extensions avec Ctrl+Maj+X. Recherchez ms-python.python, puis installez l’extension Python de Microsoft si elle manque. Elle apporte le support Python dans l’éditeur, notamment la sélection de l’interpréteur.
Recherchez ensuite ms-toolsai.jupyter et installez l’extension Jupyter de Microsoft. Elle permet d’ouvrir les fichiers .ipynb, de choisir un noyau et d’exécuter les cellules.
Le menu Terminal → Nouveau terminal ouvre un terminal intégré. Choisissez le profil PowerShell et vérifiez que son dossier courant est projet-ia.
6. Créer TesterProjet.ipynb et vérifier le noyau
Créer TesterProjet.ipynb dans le projet
Le projet est ouvert dans VS Code et les deux extensions sont installées. Créez maintenant votre notebook : ouvrez la palette avec Ctrl+Maj+P, lancez Create: New Jupyter Notebook (ou tout simplement créer un fichier avec l’extension .ipynb), puis enregistrez-le avec Ctrl+S sous le nom exact TesterProjet.ipynb, directement dans projet-ia, à côté de pyproject.toml.
Le bouton + Code ajoute une cellule exécutable ; + Markdown ajoute du texte. Dans la première cellule Code, saisissez :
Sélectionner la .venv du projet
- En haut à droite, cliquez sur Sélectionner le noyau.
- Si seuls des noyaux récents sont affichés, choisissez Sélectionner un autre noyau, puis Environnements Python / Python Environments.
- Choisissez l’environnement projet-ia associé à
.venv\Scripts\python.exe. Dans la capture, il apparaît comme projet-ia (3.14.x) (Python 3.14). - Vérifiez que ce chemin appartient à votre dossier de projet. Une installation Python globale ou l’environnement Conda
basene donne pas accès aux paquets de cette.venv.
projet-ia indique .venv\Scripts\python.exe : c’est l’environnement préparé avec uv.Le choix de l’interpréteur via Python: Select Interpreter sert aux fonctions Python de l’éditeur. Vérifiez aussi le noyau dans le notebook : il doit démarrer le Python de la .venv. Les libellés varient selon la langue et la version de VS Code ; le chemin de l’exécutable reste le repère décisif. Voir la gestion des noyaux dans VS Code.
Exécuter la cellule et contrôler le Python
Cliquez sur le triangle à gauche de la cellule, ou utilisez Ctrl+Entrée. La sortie apparaît sous la cellule. Un compteur comme [1] indique qu’elle a été exécutée. Dans la capture, la sortie indique Python 3.14.8 et le chemin du Python de la .venv :
.venv du projet.sys.version.split()[0] extrait le numéro de version de Python. sys.executable indique le chemin du Python réellement lancé par le noyau, comme le précise la documentation Python. Le chemin affiché sur mon ordinateur est .venv\Scripts\python.exe.
Vérifier les bibliothèques dans une deuxième cellule
Ajoutez une deuxième cellule Code avec + Code, puis saisissez et exécutez :
pandas, openpyxl et ipykernel.Ces versions ont été vérifiées avec le noyau Python de la .venv du projet. import charge les bibliothèques ; pd est le nom court donné à pandas ; l’attribut __version__ affiche leur version. Si les trois lignes apparaissent sans erreur, ces paquets sont accessibles au notebook. Les versions peuvent différer si vous avez installé les dépendances plus tard ; la commande uv sync --locked permet de retrouver celles enregistrées dans votre verrouillage.
7. Redémarrer le noyau et exécuter tout
Refaire les vérifications depuis un noyau neuf
Le noyau conserve les variables en mémoire entre les cellules. Cliquez sur Redémarrer le noyau, puis sur Exécuter tout. Les deux cellules de TesterProjet.ipynb doivent réussir dans l’ordre : la première identifie le Python, la seconde affiche les versions des bibliothèques. Le redémarrage efface les variables du processus, sans supprimer la .venv ni ses paquets. Enregistrez ensuite avec Ctrl+S.
Les sorties enregistrées dans un notebook peuvent rester visibles après sa réouverture. Relancer les cellules vérifie la configuration actuelle.
Retrouver les fichiers du projet
TesterProjet.ipynb est votre document de travail ; .venv fournit le Python qui exécute ses cellules. pyproject.toml déclare les besoins et uv.lock garde les versions résolues. Vous avez maintenant les outils nécessaires pour poursuivre le parcours.
pyproject.toml et de uv.lock ; la .venv contient l’environnement local.Pour vérifier que vous avez compris l’organisation, fermez puis rouvrez VS Code sur projet-ia. Ouvrez TesterProjet.ipynb, contrôlez son noyau et relancez les deux cellules. Vous devez pouvoir distinguer pyproject.toml, uv.lock, la .venv, le fichier .ipynb et le noyau actif.
Ressources pour poursuivre
Pour retrouver une commande, commencez par les projets uv et les notebooks dans VS Code. Pour comprendre les fichiers de configuration, consultez la structure des projets et les environnements Python dans VS Code.
