- À propos de venv, Conda, Poetry et Pipenv
- Créer un environnement virtuel avec venv
- Créer et gérer un environnement avec Conda
- Créer et gérer un projet avec Poetry
- Créer et gérer un environnement avec Pipenv
- Comparer la gestion des dépendances
- Comparer venv, Conda, Poetry et Pipenv
- Choisir l'outil adapté à son projet Python
- Vérifier l'environnement Python réellement utilisé
- À retenir !
1. À propos de venv, Conda, Poetry et Pipenv
Lorsqu'un développeur travaille sur plusieurs projets Python, il est recommandé d'isoler leurs dépendances. Un projet peut nécessiter une version particulière d'une bibliothèque tandis qu'un autre projet utilise une version différente. Les environnements virtuels Python permettent de séparer ces installations et d'éviter de nombreux conflits.
Plusieurs outils peuvent être utilisés dans ce domaine. venv est le mécanisme d'environnement virtuel fourni avec Python. Conda est un gestionnaire d'environnements et de packages qui peut aussi gérer des dépendances qui ne sont pas exclusivement des packages Python. Poetry est principalement orienté vers la gestion moderne des projets, des dépendances et du packaging Python. Pipenv associe gestion d'environnement virtuel et gestion des dépendances autour des fichiers Pipfile et Pipfile.lock.
Avant d'étudier ces outils, le programme suivant permet de connaître l'interpréteur Python actuellement utilisé et de détecter un environnement virtuel Python classique.
1 2 3 4 5 6 | import sys print("Python :", sys.executable) print("Préfixe courant :", sys.prefix) print("Préfixe de base :", sys.base_prefix) print("Environnement virtuel :", sys.prefix != sys.base_prefix) |
Sortie possible :
1 2 3 4 | Python : C:\mon_projet\.venv\Scripts\python.exe Préfixe courant : C:\mon_projet\.venv Préfixe de base : C:\Python314 Environnement virtuel : True |
Ces quatre solutions poursuivent donc des objectifs qui se recoupent, mais leur périmètre n'est pas identique. Le choix dépend notamment de la simplicité recherchée, du type de dépendances, de la reproductibilité souhaitée et de la manière dont le projet doit être distribué.
2. Créer un environnement virtuel avec venv
venv est intégré à la bibliothèque standard de Python. Pour un projet Python classique, il constitue souvent la solution la plus simple lorsqu'on souhaite essentiellement isoler les packages installés avec pip.
Depuis le dossier du projet, 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éé. |
Sous Windows avec CMD, nous pouvons ensuite activer l'environnement grâce au script activate.bat.
1 | .venv\Scripts\activate.bat |
Sortie possible :
1 | (.venv) C:\mon_projet> |
Sous Windows PowerShell, le script Activate.ps1 est utilisé lorsque la stratégie d'exécution PowerShell autorise son lancement.
1 | .\.venv\Scripts\Activate.ps1 |
Sortie possible :
1 | (.venv) PS C:\mon_projet> |
Sous Linux et macOS, la commande d'activation utilise le script situé dans le dossier bin.
1 | source .venv/bin/activate |
Sortie possible :
1 | (.venv) utilisateur@ordinateur:~/mon_projet$ |
Une fois l'environnement actif, nous pouvons installer les dépendances avec python -m pip.
1 | python -m pip install requests |
Sortie possible :
1 2 3 | Collecting requests ... Successfully installed requests-... ... |
venv est donc particulièrement adapté lorsqu'on recherche une solution légère, standard et facile à comprendre.
3. Créer et gérer un environnement avec Conda
Conda fonctionne à la fois comme gestionnaire d'environnements et comme gestionnaire de packages. Il est particulièrement répandu dans les domaines scientifiques, l'analyse de données, le calcul numérique et le machine learning, où les projets peuvent dépendre de Python mais aussi de bibliothèques ou composants non Python.
Conda doit d'abord être disponible sur l'ordinateur, généralement à travers une distribution ou installation compatible telle que Miniconda. La commande suivante permet de vérifier son installation.
1 | conda --version |
Sortie possible :
1 | conda 25.x.x |
La commande suivante crée un environnement nommé monenv et demande une version donnée de Python, ici Python 3.13 à titre d'exemple.
1 | conda create --name monenv python=3.13 |
Sortie possible :
1 2 3 4 5 | Proceed ([y]/n)? y ... Preparing transaction: done Verifying transaction: done Executing transaction: done |
Après sa création, l'environnement Conda peut être activé avec la commande suivante.
1 | conda activate monenv |
Sortie possible :
1 | (monenv) C:\Users\Utilisateur> |
Nous pouvons ensuite installer un package avec le gestionnaire Conda lorsque celui-ci est disponible dans les canaux configurés.
1 | conda install numpy |
Sortie possible :
1 2 3 4 5 | The following packages will be installed: numpy ... Proceed ([y]/n)? y ... Executing transaction: done |
Conda permet ainsi de gérer dans un même écosystème l'environnement, la version de Python et de nombreuses dépendances du projet.
4. Créer et gérer un projet avec Poetry
Poetry va au-delà de la simple création d'un environnement virtuel. Il est conçu pour gérer les dépendances, les métadonnées du projet, les versions, les fichiers de verrouillage et le packaging d'un projet Python.
Une fois Poetry installé selon la méthode adaptée au système, nous pouvons vérifier qu'il est accessible avec la commande suivante.
1 | poetry --version |
Sortie possible :
1 | Poetry (version 2.x.x) |
Pour initialiser la configuration Poetry dans un dossier de projet existant, nous pouvons utiliser la commande suivante et répondre aux questions proposées.
1 | poetry init |
Sortie possible :
1 2 3 4 5 | This command will guide you through creating your pyproject.toml config. Package name [...] Version [0.1.0]: Description []: ... |
Poetry s'appuie notamment sur le fichier pyproject.toml pour décrire le projet et ses dépendances.
Pour ajouter la bibliothèque requests au projet, nous pouvons utiliser la commande suivante.
1 | poetry add requests |
Sortie possible :
1 2 3 4 5 | Using version ^... for requests Updating dependencies Resolving dependencies... ... Writing lock file |
Poetry gère alors la dépendance dans le projet et met à jour son fichier de verrouillage poetry.lock.
Pour exécuter un programme Python dans l'environnement géré par Poetry sans avoir à activer manuellement un shell particulier, nous pouvons utiliser poetry run.
1 | poetry run python -c "import requests; print(requests.__version__)" |
Sortie possible :
1 | 2.32.x |
Poetry est donc particulièrement intéressant pour les projets structurés qui ont besoin d'une gestion cohérente des dépendances et du packaging.
5. Créer et gérer un environnement avec Pipenv
Pipenv combine la création d'un environnement virtuel avec une gestion des dépendances basée principalement sur Pipfile et Pipfile.lock. Il fournit une interface permettant d'installer des packages, de verrouiller leurs versions et d'exécuter des commandes dans l'environnement du projet.
Si Pipenv n'est pas encore installé, il peut être installé dans un environnement Python approprié avec pip.
1 | python -m pip install pipenv |
Sortie possible :
1 2 3 | Collecting pipenv ... Successfully installed pipenv-... ... |
Nous pouvons ensuite vérifier la version installée.
1 | pipenv --version |
Sortie possible :
1 | pipenv, version 202x.x.x |
Depuis le dossier du projet, l'installation d'une dépendance avec Pipenv crée l'environnement si nécessaire et enregistre la dépendance dans le projet.
1 | pipenv install requests |
Sortie possible :
1 2 3 4 5 6 | Creating a virtualenv for this project... ... Installing requests... Installation Succeeded ... Updated Pipfile.lock (...) |
Pipenv permet ensuite d'exécuter directement une commande dans l'environnement du projet grâce à pipenv run.
1 | pipenv run python -c "import requests; print(requests.__version__)" |
Sortie possible :
1 | 2.32.x |
Nous pouvons également demander à Pipenv d'indiquer l'emplacement de l'environnement virtuel associé au projet.
1 | pipenv --venv |
Sortie possible :
1 | C:\Users\Utilisateur\.virtualenvs\mon_projet-xxxxxxxx |
6. Comparer la gestion des dépendances
La différence entre ces outils devient particulièrement visible lorsqu'il faut enregistrer et reproduire les dépendances d'un projet. Avec venv, la création de l'environnement et la gestion des dépendances sont généralement réalisées séparément avec venv et pip.
Dépendances avec venv et pip
Dans un environnement venv actif, nous pouvons enregistrer les distributions installées dans un fichier requirements.txt.
1 | python -m pip freeze > requirements.txt |
Sortie :
1 2 | Aucun message n'est normalement affiché. Le fichier requirements.txt est créé ou remplacé. |
Un nouvel environnement peut ensuite installer les dépendances enregistrées dans ce fichier.
1 | python -m pip install -r requirements.txt |
Sortie possible :
1 2 3 | Collecting ... ... Successfully installed ... |
Dépendances avec Conda
Conda permet d'exporter la définition d'un environnement dans un fichier YAML. Cette méthode peut enregistrer davantage d'informations qu'un simple requirements.txt.
1 | conda env export > environment.yml |
Sortie :
1 | Le fichier environment.yml est créé avec la définition de l'environnement. |
Un environnement Conda peut ensuite être recréé à partir de ce fichier.
1 | conda env create -f environment.yml |
Sortie possible :
1 2 3 4 | Collecting package metadata... Solving environment... ... Executing transaction: done |
Dépendances avec Poetry
Poetry utilise pyproject.toml pour déclarer les dépendances et poetry.lock pour verrouiller les versions résolues. Après récupération d'un projet existant, la commande suivante installe les dépendances prévues par le projet.
1 | poetry install |
Sortie possible :
1 2 3 | Installing dependencies from lock file Package operations: ... ... |
Dépendances avec Pipenv
Pipenv repose sur Pipfile et Pipfile.lock. Pour installer l'environnement à partir du fichier verrouillé en respectant les versions enregistrées, nous pouvons utiliser la commande suivante.
1 | pipenv sync |
Sortie possible :
1 2 | Installing dependencies from Pipfile.lock... All dependencies are now up-to-date! |
Le choix d'un outil ne concerne donc pas seulement la création de l'environnement : il détermine également la manière dont le projet décrit, verrouille et reproduit ses dépendances.
7. Comparer venv, Conda, Poetry et Pipenv
Les quatre outils répondent à des besoins qui se recoupent, mais ils ne doivent pas être considérés comme strictement équivalents. venv est avant tout un créateur d'environnements virtuels, tandis que Conda, Poetry et Pipenv prennent en charge des fonctions supplémentaires de gestion de projet ou de dépendances.
| Caractéristique | venv | Conda | Poetry | Pipenv |
|---|---|---|---|---|
| Intégré à Python | Oui | Non | Non | Non |
| Création d'environnements isolés | Oui | Oui | Oui, via sa gestion d'environnement | Oui |
| Gestion des packages | Avec pip | Oui | Oui | Oui |
| Fichier principal de dépendances | requirements.txt, par convention avec pip | environment.yml pour l'export d'environnement | pyproject.toml | Pipfile |
| Fichier de verrouillage dédié | Pas fourni directement par venv | Pas le même modèle que Poetry/Pipenv | poetry.lock | Pipfile.lock |
| Dépendances non Python | Non directement | Oui | Principalement écosystème Python | Principalement écosystème Python |
| Packaging du projet Python | Non | Pas son objectif principal | Oui | Pas son objectif principal |
| Simplicité pour débuter | Très bonne | Plus d'outils à apprendre | Gestion de projet plus complète | Gestion intégrée des dépendances |
Pour vérifier concrètement l'interpréteur obtenu, nous pouvons exécuter la même instruction Python dans chaque environnement.
1 2 3 4 | import sys print("Version :", sys.version.split()[0]) print("Interpréteur :", sys.executable) |
Sortie possible :
1 2 | Version : 3.14.1 Interpréteur : C:\mon_projet\.venv\Scripts\python.exe |
Le chemin exact dépend naturellement de l'outil, du système d'exploitation et de la configuration choisie.
8. Choisir l'outil adapté à son projet Python
Il n'existe pas un outil universellement supérieur aux autres. Le choix dépend principalement du type de projet Python et du niveau de gestion recherché.
Choisir venv pour la simplicité
Pour apprendre Python, développer un script, un projet Flask, Django ou une application Python classique avec des dépendances disponibles via pip, venv constitue souvent le choix le plus simple. La commande de création reste minimale.
1 | python -m venv .venv |
Sortie :
1 | Le dossier .venv est créé sans sortie particulière dans la plupart des cas. |
Choisir Conda pour certains environnements scientifiques
Conda devient particulièrement intéressant lorsque le projet doit gérer différentes versions de Python ainsi que des dépendances scientifiques ou des bibliothèques qui ne se limitent pas aux packages Python distribués sur PyPI.
1 | conda create --name data-science python=3.13 numpy pandas |
Sortie possible :
1 2 3 4 5 6 | The following NEW packages will be INSTALLED: python numpy pandas ... Proceed ([y]/n)? |
Choisir Poetry pour un projet Python structuré
Poetry est particulièrement adapté lorsque nous souhaitons gérer dans un même workflow les dépendances, leur verrouillage, les métadonnées du projet et éventuellement la construction et la publication d'un package Python.
1 | poetry new mon_projet |
Sortie possible :
1 | Created package mon_projet in mon_projet |
Choisir Pipenv pour le workflow Pipfile
Pipenv peut être choisi lorsqu'on souhaite travailler avec un workflow reposant sur Pipfile, Pipfile.lock et un environnement virtuel géré automatiquement pour le projet.
1 | pipenv install flask |
Sortie possible :
1 2 3 4 5 | Creating a virtualenv for this project... Installing flask... Installation Succeeded ... Updated Pipfile.lock (...) |
Pour un débutant qui souhaite simplement isoler les dépendances d'un projet Python moderne, commencer par venv permet généralement de comprendre clairement le fonctionnement d'un environnement virtuel avant de passer à des outils plus complets.
9. Vérifier l'environnement Python réellement utilisé
Quel que soit l'outil choisi, il est important de savoir quel interpréteur Python exécute réellement le programme. Le module sys permet d'obtenir cette information sans dépendre du gestionnaire d'environnement utilisé.
Le programme suivant affiche la version et le chemin de l'interpréteur courant.
1 2 3 4 5 6 | import sys print("Version Python :", sys.version.split()[0]) print("Interpréteur :", sys.executable) print("Préfixe :", sys.prefix) print("Préfixe de base :", sys.base_prefix) |
Sortie possible :
1 2 3 4 | Version Python : 3.14.1 Interpréteur : C:\mon_projet\.venv\Scripts\python.exe Préfixe : C:\mon_projet\.venv Préfixe de base : C:\Python314 |
Avec un environnement créé par venv, la comparaison entre sys.prefix et sys.base_prefix permet également de confirmer l'isolation de l'interpréteur.
1 2 3 | import sys print(sys.prefix != sys.base_prefix) |
Sortie possible :
1 | True |
Pour un projet utilisant pip, nous pouvons également vérifier quel pip est associé à l'interpréteur courant.
1 | python -m pip --version |
Sortie possible :
1 | pip 25.x from C:\mon_projet\.venv\Lib\site-packages\pip (python 3.14) |
Avec Conda, la commande suivante affiche les environnements connus et indique normalement l'environnement actif par un astérisque.
1 | conda env list |
Sortie possible :
1 2 3 4 | # conda environments: # base C:\Users\Utilisateur\miniconda3 monenv * C:\Users\Utilisateur\miniconda3\envs\monenv |
Avec Poetry, nous pouvons demander le chemin de l'environnement associé au projet.
1 | poetry env info --path |
Sortie possible :
1 | C:\Users\Utilisateur\AppData\Local\pypoetry\Cache\virtualenvs\mon-projet-... |
Avec Pipenv, la commande suivante fournit le chemin de son environnement virtuel.
1 | pipenv --venv |
Sortie possible :
1 | C:\Users\Utilisateur\.virtualenvs\mon_projet-xxxxxxxx |
10. À retenir !
venv, Conda, Poetry et Pipenv permettent tous de travailler avec des projets Python mieux isolés, mais ils n'ont pas exactement le même rôle ni le même périmètre fonctionnel.
- venv est intégré à Python et se concentre sur la création d'environnements virtuels.
- venv + pip constitue une combinaison simple et efficace pour de nombreux projets Python.
- Conda gère à la fois des environnements et des packages et peut prendre en charge des dépendances non Python.
- Conda est particulièrement répandu dans les environnements scientifiques et de data science.
- Poetry combine gestion des dépendances, verrouillage, métadonnées et fonctions de packaging Python.
- Poetry utilise principalement pyproject.toml et poetry.lock.
- Pipenv associe environnement virtuel et gestion des dépendances autour de Pipfile et Pipfile.lock.
- Le fichier requirements.txt reste couramment utilisé avec pip et venv.
- Il est préférable d'éviter de mélanger plusieurs gestionnaires pour le même rôle dans un projet sans raison précise.
- Le meilleur outil dépend du projet : venv pour la simplicité, Conda pour certains environnements scientifiques, Poetry pour une gestion de projet Python plus intégrée et Pipenv pour un workflow basé sur Pipfile.
Les commandes suivantes résument la création d'un environnement avec les quatre solutions étudiées. Elles doivent être exécutées séparément selon l'outil choisi et non successivement pour créer un seul projet.
1 2 3 4 5 6 7 | python -m venv .venv conda create --name monenv python=3.13 poetry init pipenv install |
Sortie possible :
1 2 3 4 | venv : création du dossier .venv Conda : création de l'environnement monenv Poetry : création ou configuration du projet avec pyproject.toml Pipenv : création de l'environnement et gestion du Pipfile |
Pour vérifier l'interpréteur réellement utilisé après avoir sélectionné ou activé l'environnement, nous pouvons toujours interroger Python directement.
1 2 3 4 5 6 | import sys print("Python :", sys.version.split()[0]) print("Interpréteur :", sys.executable) print("Préfixe :", sys.prefix) print("Préfixe de base :", sys.base_prefix) |
Sortie possible :
1 2 3 4 | Python : 3.14.1 Interpréteur : C:\mon_projet\.venv\Scripts\python.exe Préfixe : C:\mon_projet\.venv Préfixe de base : C:\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/
