Environnements virtuels Python : guide complet de venv, virtualenv et Conda

Name

Soren Atelier

Updated on 11/02/2026

Les développeurs Python font face à un défi courant : les conflits de dépendances entre projets. Lorsque plusieurs applications exigent des versions différentes d’une même bibliothèque, les installations globales au niveau système créent des incompatibilités qui finissent par casser le code. Un projet de data science peut nécessiter pandas 1.3.5 tandis qu’une application web requiert pandas 2.0.0, rendant impossible l’exécution des deux sur la même installation Python.

Ce problème s’amplifie en équipe, quand les développeurs travaillent avec des versions de packages différentes, ou lors du déploiement d’applications sur des serveurs de production. Sans isolation correcte, installer une nouvelle dépendance pour un projet peut en casser un autre, menant au fameux scénario « ça marche sur ma machine » qui fait perdre des heures en débogage.

Les environnements virtuels Python résolvent cela en créant des espaces isolés où chaque projet conserve ses propres dépendances, indépendamment. Ce guide couvre tout : de l’usage de base de venv à la gestion avancée d’environnements avec conda, afin de vous aider à choisir le bon outil et à appliquer les meilleures pratiques pour un développement Python professionnel.

Pourquoi les environnements virtuels sont importants

Les environnements virtuels répondent à trois problèmes critiques en développement Python :

Isolation des dépendances : chaque projet obtient ses propres installations de packages sans affecter le Python système ni les autres projets. Installer Django 4.2 dans un environnement n’impacte pas un projet legacy qui exécute Django 2.2 dans un autre environnement.

Gestion des versions : des projets différents peuvent utiliser des versions différentes de Python. Un projet de machine learning peut utiliser Python 3.11 pour les performances, tandis qu’un codebase legacy requiert Python 3.8 pour rester compatible avec d’anciennes bibliothèques.

Reproductibilité : les environnements virtuels permettent de recréer à l’identique des setups de développement sur différentes machines. En exportant la liste des dépendances, les membres d’une équipe peuvent reproduire le même environnement, éliminant les bugs liés aux décalages de versions.

Sans environnements virtuels, les développeurs risquent de casser leur installation Python système, dont les systèmes d’exploitation dépendent souvent pour des fonctionnalités essentielles. Installer globalement des packages incompatibles peut rendre des outils système inutilisables, nécessitant des corrections complexes, voire une réinstallation complète de l’OS dans les cas extrêmes.

Module Python venv : la solution intégrée

Python 3.3 a introduit venv comme module intégré pour créer des environnements virtuels légers. Il ne nécessite aucune installation supplémentaire et offre des fonctionnalités suffisantes pour la plupart des projets.

Créer un environnement virtuel avec venv

Placez-vous dans le répertoire de votre projet et créez un environnement virtuel :

python -m venv myenv

Cette commande crée un répertoire myenv contenant :

• Une copie de l’interpréteur Python
• La bibliothèque standard
• Le gestionnaire de packages pip
• Des scripts pour activer l’environnement

Pour cibler une version spécifique de Python quand plusieurs installations existent :

python3.11 -m venv myenv

Activer des environnements virtuels

L’activation diffère selon le système d’exploitation :

Linux et macOS :

source myenv/bin/activate

Windows Command Prompt :

myenv\Scripts\activate.bat

Windows PowerShell :

myenv\Scripts\Activate.ps1

Après activation, l’invite du terminal affiche le nom de l’environnement entre parenthèses :

(myenv) user@machine:~/project$

Toutes les installations via pip ciblent désormais l’environnement virtuel plutôt que le Python système.

Installer des packages dans venv

Avec l’environnement activé, installez les packages normalement :

pip install pandas numpy matplotlib

Ces packages s’installent uniquement dans l’environnement virtuel. Pour vérifier :

pip list

Cela affiche les packages spécifiques à l’environnement actif, et non les installations au niveau système.

Désactiver des environnements virtuels

Revenir au Python système :

deactivate

Le nom de l’environnement disparaît de l’invite, et les commandes pip affectent à nouveau le Python système.

virtualenv : l’alternative enrichie

virtualenv a précédé venv et offre des fonctionnalités supplémentaires, bien qu’il nécessite une installation séparée. Il prend en charge d’anciennes versions de Python (2.7+) et permet une création d’environnement plus rapide grâce à des optimisations.

Installer virtualenv

pip install virtualenv

Créer et utiliser des environnements virtualenv

virtualenv myenv

L’activation fonctionne exactement comme avec venv. virtualenv ajoute des options utiles :

Spécifier la version de Python :

virtualenv -p python3.10 myenv

Créer sans pip (à installer séparément plus tard) :

virtualenv --no-pip myenv

Copier les site-packages système (accéder aux packages installés globalement) :

virtualenv --system-site-packages myenv

venv vs virtualenv

Pour les nouveaux projets Python 3, venv suffit. Utilisez virtualenv si vous travaillez avec Python 2, si vous avez besoin d’une création d’environnements plus rapide, ou si vous avez besoin d’options de configuration avancées.

Environnements Conda : le standard du calcul scientifique

Conda gère à la fois les packages et les environnements, et est particulièrement populaire en data science pour gérer des dépendances complexes, comme des bibliothèques numériques avec des composants C/C++.

Installer Conda

Téléchargez au choix :

• Anaconda : distribution complète avec plus de 1 500 packages préinstallés (3 Go+)
• Miniconda : installateur minimal avec conda, Python et quelques packages essentiels (400 Mo)

Miniconda convient à la plupart des développeurs, car il installe les packages à la demande.

Créer des environnements Conda

conda create -n myenv python=3.11

Créer avec des packages spécifiques :

conda create -n datascience python=3.11 pandas numpy scikit-learn jupyter

Activer et désactiver des environnements Conda

conda activate myenv

conda deactivate

Gérer les packages Conda

Installer depuis les dépôts conda :

conda install tensorflow

Conda gère automatiquement les dépendances complexes, en compilant les packages avec des bibliothèques optimisées pour de meilleures performances que les équivalents pip dans de nombreux cas.

Lister les packages installés :

conda list

Exporter et cloner des environnements Conda

Exporter la spécification de l’environnement :

conda env export > environment.yml

Recréer l’environnement sur une autre machine :

conda env create -f environment.yml

Cloner un environnement existant :

conda create --name newenv --clone myenv

Conda vs pip

Les environnements conda peuvent utiliser conda et pip, mais les mélanger demande de la prudence :

conda install pandas
pip install custom-package

Installez d’abord les packages conda, puis les packages pip pour éviter des conflits de résolution de dépendances.

Comparaison complète : outils modernes d’environnements Python

Choisissez venv pour des projets Python 3 simples sans exigences complexes.

Choisissez conda pour la data science, le machine learning, ou des projets avec des dépendances binaires nécessitant des bibliothèques compilées.

Choisissez poetry lorsque vous publiez des packages sur PyPI ou que vous avez besoin d’une gestion stricte des dépendances.

Choisissez pipenv pour des applications web nécessitant des environnements reproductibles avec une gestion automatique des environnements virtuels.

Gérer les dépendances avec requirements.txt

Les fichiers requirements.txt spécifient des versions exactes de packages pour reproduire un environnement.

Créer requirements.txt

Geler les packages de l’environnement actuel :

pip freeze > requirements.txt

Cela génère :

pandas==2.1.4
numpy==1.26.2
matplotlib==3.8.2

Installer depuis requirements.txt

Créer un environnement vierge :

python -m venv newenv
source newenv/bin/activate  # or appropriate activation for your OS
pip install -r requirements.txt

Cela installe les versions exactes spécifiées, garantissant la cohérence entre environnements.

Bonnes pratiques pour requirements.txt

Épingler les versions pour la production :

Django==4.2.7
psycopg2-binary==2.9.9

Utiliser des plages de versions pour plus de flexibilité en développement :

Django>=4.2,<5.0
pytest>=7.0

Séparer les dépendances de développement et de production :

requirements.txt (production) :

Django==4.2.7
gunicorn==21.2.0

requirements-dev.txt (développement) :

-r requirements.txt
pytest==7.4.3
black==23.12.0

Installer les requirements de développement :

pip install -r requirements-dev.txt

Ajouter des commentaires pour plus de clarté :

# Web framework
Django==4.2.7

# Database adapter
psycopg2-binary==2.9.9

# Development tools
pytest==7.4.3  # Testing framework

Packaging Python moderne avec pyproject.toml

PEP 518 a introduit pyproject.toml comme fichier de configuration standardisé, remplaçant setup.py et d’autres fichiers de configuration.

Structure de base de pyproject.toml

[build-system]
requires = ["setuptools>=61.0"]
build-backend = "setuptools.build_meta"
 
[project]
name = "myproject"
version = "1.0.0"
description = "A sample Python project"
readme = "README.md"
requires-python = ">=3.8"
dependencies = [
    "pandas>=2.0.0",
    "numpy>=1.24.0",
]
 
[project.optional-dependencies]
dev = [
    "pytest>=7.0",
    "black>=23.0",
]

Utiliser pyproject.toml avec pip

Installer les dépendances du projet :

pip install -e .

Installer avec les dépendances de développement :

pip install -e ".[dev]"

Workflow Poetry

Poetry utilise pyproject.toml pour une gestion complète des dépendances :

poetry new myproject
cd myproject
poetry add pandas numpy
poetry add --group dev pytest black

Poetry crée et gère automatiquement les environnements virtuels :

poetry install  # Creates venv and installs dependencies
poetry shell    # Activates environment

Environnements virtuels dans les IDE

Configuration VS Code

VS Code détecte automatiquement les environnements virtuels dans les emplacements standards (.venv, venv, env).

Sélectionner l’interpréteur Python :

1. Appuyez sur Ctrl+Shift+P (Windows/Linux) ou Cmd+Shift+P (macOS)
2. Tapez « Python: Select Interpreter »
3. Choisissez votre environnement virtuel

Activation automatique : VS Code active l’environnement sélectionné lors de l’ouverture de terminaux intégrés.

Configurer dans .vscode/settings.json :

{
    "python.defaultInterpreterPath": "${workspaceFolder}/.venv/bin/python",
    "python.terminal.activateEnvironment": true
}

Configuration PyCharm

PyCharm offre une intégration complète des environnements virtuels :

Créer un environnement virtuel :

1. File → Settings → Project → Python Interpreter
2. Cliquez sur l’icône d’engrenage → Add
3. Sélectionnez « Virtualenv Environment »
4. Choisissez un environnement nouveau ou existant

Auto-activation : PyCharm active automatiquement l’interpréteur du projet pour les terminaux et les configurations d’exécution.

Jupyter Notebooks et environnements virtuels

Installez ipykernel dans votre environnement virtuel :

source myenv/bin/activate
pip install ipykernel
python -m ipykernel install --user --name=myenv

Cela rend l’environnement disponible comme kernel dans Jupyter :

jupyter notebook

Sélectionnez « myenv » dans le menu des kernels.

Pour les data scientists qui travaillent intensivement dans Jupyter, RunCell (opens in a new tab) fournit un environnement Jupyter alimenté par l’IA qui gère automatiquement les environnements virtuels et les dépendances, simplifiant le workflow sans configuration manuelle des environnements.

Problèmes courants avec les environnements virtuels

Mauvaise version de Python

Problème : l’environnement virtuel utilise une version de Python incorrecte.

Solution : spécifiez explicitement l’interpréteur Python :

python3.11 -m venv myenv

Ou avec virtualenv :

virtualenv -p /usr/bin/python3.11 myenv

Script d’activation introuvable

Problème : « activate: No such file or directory »

Solution : vérifiez que la création de l’environnement s’est terminée correctement. Recréez si nécessaire :

rm -rf myenv
python -m venv myenv

Erreur de stratégie d’exécution PowerShell

Problème : Windows PowerShell bloque les scripts d’activation.

Solution : autorisez l’exécution de scripts pour l’utilisateur courant :

Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser

Environnement non reconnu dans le PATH

Problème : l’environnement activé utilise toujours le Python système.

Solution : vérifiez l’activation en contrôlant l’emplacement de Python :

which python  # Linux/macOS
where python  # Windows

Cela doit pointer vers le répertoire de l’environnement virtuel. Sinon, désactivez et réactivez :

deactivate
source myenv/bin/activate

Échec d’installation de packages

Problème : erreurs pip install dans l’environnement virtuel.

Solution : mettez à niveau pip, setuptools et wheel :

pip install --upgrade pip setuptools wheel

Conflits d’environnements conda

Problème : mélanger conda et pip cause des problèmes de dépendances.

Solution : installez d’abord les packages conda, puis les packages pip :

conda install numpy pandas
pip install custom-library

Ou utilisez conda exclusivement lorsque c’est possible :

conda install -c conda-forge package-name

Bonnes pratiques pour les environnements virtuels

Conventions de nommage

Utilisez des noms descriptifs et cohérents :

• .venv — répertoire caché standard pour un environnement propre au projet
• venv — alternative courante
• myproject-env — descriptif si vous gérez plusieurs projets

Évitez des noms génériques comme « env » ou « python » qui créent de la confusion.

Configuration .gitignore

Excluez toujours les environnements virtuels du contrôle de version :

# Virtual environments
venv/
.venv/
env/
ENV/
myenv/

# Conda environments
conda-env/

# Virtual environment markers
pyvenv.cfg

Structure de projet

Organisez les projets avec une séparation claire de l’environnement :

myproject/
├── .venv/                 # Virtual environment (not in git)
├── src/
│   └── myproject/
│       └── __init__.py
├── tests/
│   └── test_main.py
├── requirements.txt       # Production dependencies
├── requirements-dev.txt   # Development dependencies
├── pyproject.toml         # Project configuration
├── README.md
└── .gitignore

Un environnement par projet

Créez un environnement virtuel dédié pour chaque projet plutôt que de partager des environnements. Cela évite les conflits de dépendances et simplifie le débogage.

Documenter la mise en place de l’environnement

Ajoutez des instructions d’installation dans README.md :

## Setup
 
1. Create virtual environment:

python -m venv .venv

2. Activate environment:
- Linux/macOS: `source .venv/bin/activate`
- Windows: `.venv\Scripts\activate`

3. Install dependencies:

pip install -r requirements.txt

Mises à jour régulières des dépendances

Mettez à jour les packages périodiquement en testant la compatibilité :

pip list --outdated
pip install --upgrade package-name
pip freeze > requirements.txt

Utilisez des outils comme pip-review pour des mises à jour en lot :

pip install pip-review
pip-review --local --interactive

Docker vs environnements virtuels

Les conteneurs Docker et les environnements virtuels répondent à des niveaux d’isolation différents :

Les environnements virtuels isolent les packages Python au sein d’un même système d’exploitation. Ils offrent :

• Une consommation de ressources légère
• Une création et une activation rapides
• Une isolation suffisante pour la plupart des développements
• Une intégration simple avec les outils locaux

Les conteneurs Docker isolent des stacks applicatives complètes, incluant l’OS, les bibliothèques système et les services. Ils offrent :

• Une reproductibilité complète de l’environnement
• Un comportement cohérent entre développement et production
• L’isolation des dépendances au niveau système
• Le support des applications multi-services

Quand utiliser chaque approche

Utilisez des environnements virtuels :

• Développement et tests en local
• Projets uniquement Python sans dépendances système
• Prototypage et expérimentation rapides
• Workflows individuels de développeurs

Utilisez Docker :

• Déploiements en production
• Applications avec dépendances au niveau système
• Architectures multi-services (app web + base de données + cache)
• Environnements standardisés à l’échelle d’une équipe
• Pipelines CI/CD

Combiner les deux

De nombreux projets utilisent des environnements virtuels pour le développement et Docker pour le déploiement :

Dockerfile:

FROM python:3.11-slim
 
WORKDIR /app
 
COPY requirements.txt .
RUN python -m venv /opt/venv
ENV PATH="/opt/venv/bin:$PATH"
 
RUN pip install -r requirements.txt
 
COPY . .
 
CMD ["python", "app.py"]

Cette approche exploite les environnements virtuels même dans des conteneurs, pour une gestion des dépendances plus propre.

Gérer plusieurs versions de Python avec pyenv

pyenv simplifie l’installation et le basculement entre versions de Python, en complément des outils d’environnements virtuels.

Installer pyenv

Linux/macOS :

curl https://pyenv.run | bash

Windows : utilisez pyenv-win :

Invoke-WebRequest -UseBasicParsing -Uri "https://raw.githubusercontent.com/pyenv-win/pyenv-win/master/pyenv-win/install-pyenv-win.ps1" -OutFile "./install-pyenv-win.ps1"; &"./install-pyenv-win.ps1"

Installer des versions de Python

Lister les versions disponibles :

pyenv install --list

Installer des versions spécifiques :

pyenv install 3.11.7
pyenv install 3.10.13

Définir les versions de Python

Global (au niveau système) :

pyenv global 3.11.7

Local (répertoire du projet) :

cd myproject
pyenv local 3.10.13

Cela crée un fichier .python-version qui spécifie la version pour ce répertoire.

Combiner pyenv avec des environnements virtuels

pyenv local 3.11.7
python -m venv .venv
source .venv/bin/activate

Ou utilisez le plugin pyenv-virtualenv :

pyenv virtualenv 3.11.7 myproject-env
pyenv activate myproject-env

Cela intègre la gestion des versions de Python et la création d’environnements virtuels dans un workflow unifié.

Techniques avancées d’environnements virtuels

Variables d’environnement dans les environnements virtuels

Stockez la configuration dans des fichiers spécifiques à l’environnement :

.env:

DATABASE_URL=postgresql://localhost/mydb
SECRET_KEY=development-secret-key
DEBUG=True

Charger avec python-dotenv :

pip install python-dotenv

from dotenv import load_dotenv
import os
 
load_load_dotenv()
database_url = os.getenv('DATABASE_URL')

Scripts de pré-activation et post-activation

Personnalisez le comportement d’activation en modifiant les scripts d’activation.

Linux/macOS — modifiez myenv/bin/activate :

Ajoutez avant la dernière ligne :

export DATABASE_URL="postgresql://localhost/mydb"
export FLASK_ENV="development"

Windows — créez myenv/Scripts/activate.bat :

Ajoutez :

set DATABASE_URL=postgresql://localhost/mydb
set FLASK_ENV=development

Partager des environnements virtuels entre projets

Même si c’est généralement déconseillé, les environnements partagés peuvent fonctionner pour des projets liés ayant des dépendances identiques :

python -m venv ~/shared-envs/data-science
source ~/shared-envs/data-science/bin/activate

Activez cet environnement dans plusieurs répertoires de projet. Cependant, cette approche risque de casser tous les projets si des dépendances entrent en conflit.

FAQ

Conclusion

Les environnements virtuels Python constituent la base d’un développement Python professionnel : ils évitent les conflits de dépendances et permettent des setups de projet reproductibles. Le module venv intégré couvre efficacement la plupart des cas d’usage, tandis que conda excelle pour les projets de data science avec des dépendances binaires complexes. Des outils modernes comme poetry et pipenv ajoutent une résolution avancée des dépendances pour les projets exigeant un contrôle strict des versions.

Une gestion réussie des environnements virtuels suit des schémas clairs : un environnement par projet, des règles .gitignore complètes, et des procédures de setup documentées. Combinés à pyenv pour la gestion des versions de Python et à l’intégration dans les IDE pour des workflows fluides, les environnements virtuels transforment une gestion chaotique des dépendances en processus systématiques et prévisibles.

Pour les data scientists travaillant dans des notebooks Jupyter, RunCell (opens in a new tab) fournit un environnement alimenté par l’IA qui gère automatiquement la complexité des environnements virtuels, permettant de se concentrer sur l’analyse plutôt que sur la configuration. Que vous utilisiez venv pour des projets simples ou conda pour le calcul scientifique, les environnements virtuels restent des outils essentiels que tout développeur Python doit maîtriser.

Commencez votre prochain projet avec un environnement virtuel propre et documentez le processus d’installation. Votre futur vous (et vos coéquipiers) apprécierez la reproductibilité et l’isolation qui évitent des heures à déboguer de mystérieux problèmes de dépendances.