Introduction
Bienvenue dans ce laboratoire consacré aux environnements virtuels Python. L'utilisation d'un environnement virtuel permet de tester du code Python dans des espaces encapsulés et d'éviter de surcharger l'installation Python de base avec des bibliothèques qui ne seraient nécessaires que pour un seul projet. Cette pratique est essentielle pour maintenir des environnements de développement propres, reproductibles et sans conflits.
Dans ce laboratoire, vous allez acquérir une expérience pratique avec cinq outils populaires pour la gestion des environnements virtuels et des dépendances Python :
- virtualenv : L'outil fondamental pour créer des environnements Python isolés.
- Poetry : Un outil tout-en-un pour la gestion des dépendances, l'empaquetage et la publication.
- Pipenv : Un outil qui vise à combiner le meilleur des mondes de l'empaquetage pour Python.
- Anaconda : Une plateforme populaire pour la science des données qui inclut de puissantes capacités de gestion d'environnements.
- UV : Un installateur et résolveur de paquets Python de nouvelle génération, extrêmement rapide.
À la fin de ce laboratoire, vous serez en mesure de choisir et d'utiliser l'outil adapté aux besoins de votre projet.
virtualenv
Dans cette étape, vous apprendrez à utiliser virtualenv pour créer et gérer des environnements Python isolés. virtualenv est un outil permettant de créer des environnements Python isolés, vous permettant de tester du code dans des espaces encapsulés et d'éviter de polluer l'installation Python globale avec des bibliothèques spécifiques à un projet. L'outil est déjà préinstallé pour vous.
Tout d'abord, créons un répertoire pour stocker vos environnements virtuels, puis créons un nouvel environnement nommé HelloWorld. Ouvrez un terminal dans le WebIDE et exécutez les commandes suivantes :
mkdir -p ~/.virtualenvs
virtualenv ~/.virtualenvs/HelloWorld
Vous verrez quelques lignes s'afficher lors de la création de l'environnement. L'environnement virtuel sera créé dans le répertoire ~/.virtualenvs/HelloWorld.
created virtual environment CPython3.10.12.final.0-64 in 257ms
creator CPython3Posix(dest=/home/labex/.virtualenvs/HelloWorld, clear=False, no_vcs_ignore=False, global=False)
seeder FromAppData(download=False, pip=bundle, setuptools=bundle, wheel=bundle, via=copy, app_data_dir=/home/labex/.local/share/virtualenv)
added seed packages: pip==24.0, setuptools==69.5.1, wheel==0.43.0
activators BashActivator,CShellActivator,FishActivator,NushellActivator,PowerShellActivator,PythonActivator
Maintenant, activons l'environnement virtuel. Cela modifiera votre invite de commande pour inclure (HelloWorld), indiquant que l'environnement virtuel est actif. Tout ce que vous installerez via pip sera désormais spécifique à cet environnement et n'affectera pas votre installation Python globale.
source ~/.virtualenvs/HelloWorld/bin/activate
Après l'activation, votre invite de commande changera pour afficher (HelloWorld) :
(HelloWorld) labex:project/ $
Pour quitter l'environnement virtuel, utilisez simplement la commande deactivate :
deactivate
Remarquez comment le préfixe (HelloWorld) disparaît de votre invite de commande.
Pour réactiver l'environnement plus tard, vous pouvez utiliser à nouveau la commande source depuis n'importe quel emplacement :
source ~/.virtualenvs/HelloWorld/bin/activate
Votre invite de commande changera à nouveau, et vous serez de retour dans l'environnement HelloWorld, prêt à travailler sur votre projet.
Poetry
Dans cette étape, vous allez explorer Poetry, un outil moderne pour la gestion des dépendances et l'empaquetage en Python. Il vous permet de déclarer les bibliothèques dont votre projet dépend, et il se charge de les gérer (installation/mise à jour) pour vous. Poetry est déjà installé dans cet environnement.
Assurez-vous d'avoir désactivé votre environnement virtuel précédent.
deactivate
Commençons par créer un nouveau projet avec Poetry. Cette commande mettra en place une structure de répertoire standard pour votre projet.
poetry new my-poetry-project
Cette commande crée un nouveau répertoire nommé my-poetry-project avec la structure suivante :
my-poetry-project
├── pyproject.toml
├── README.md
├── my_poetry_project
│ └── __init__.py
└── tests
├── __init__.py
└── test_my_poetry_project.py
Le fichier le plus important ici est pyproject.toml, qui orchestre votre projet et ses dépendances. Affichons son contenu initial.
cat my-poetry-project/pyproject.toml
La sortie ressemblera à ceci :
[tool.poetry]
name = "my-poetry-project"
version = "0.1.0"
description = ""
authors = ["Your Name <you@example.com>"]
readme = "README.md"
[tool.poetry.dependencies]
python = "^3.10"
[build-system]
requires = ["poetry-core"]
build-backend = "poetry.core.masonry.api"
Maintenant, déplacez-vous dans le répertoire de votre nouveau projet :
cd my-poetry-project
Pour ajouter une nouvelle dépendance, utilisez la commande poetry add. Poetry trouvera automatiquement une version appropriée et l'ajoutera au fichier pyproject.toml. Ajoutons la bibliothèque pendulum.
poetry add pendulum
Pour installer toutes les dépendances listées dans pyproject.toml (par exemple, lors du clonage d'un projet), vous exécuteriez :
poetry install
Enfin, pour supprimer une dépendance, utilisez la commande poetry remove :
poetry remove pendulum
Cela supprime le paquet et met à jour le fichier pyproject.toml en conséquence.
Pipenv
Dans cette étape, vous apprendrez à utiliser Pipenv, un outil qui vise à apporter le meilleur des mondes de l'empaquetage à Python. Il crée et gère automatiquement un virtualenv pour vos projets, tout en ajoutant ou supprimant des paquets de votre Pipfile au fur et à mesure que vous installez ou désinstallez des paquets.
Tout d'abord, créez un répertoire pour votre nouveau projet et déplacez-vous dedans.
cd ~/project
mkdir my_pipenv_project
cd my_pipenv_project
Maintenant, installons un paquet. Pipenv créera automatiquement un nouvel environnement virtuel et un Pipfile pour suivre vos dépendances. Installons la bibliothèque requests.
pipenv install requests
Une fois la commande terminée, vous verrez deux nouveaux fichiers dans votre répertoire : Pipfile et Pipfile.lock. Le Pipfile est utilisé pour suivre les dépendances dont votre projet a besoin. Inspectons son contenu :
cat Pipfile
La sortie affichera le paquet requests listé sous [packages].
[[source]]
url = "https://pypi.org/simple"
verify_ssl = false
name = "pypi"
[packages]
requests = "*"
[dev-packages]
[requires]
python_version = "3.10"
Pour activer l'environnement virtuel associé à votre projet, exécutez :
pipenv shell
Votre invite de commande changera, indiquant que vous êtes maintenant à l'intérieur de l'environnement isolé du projet.
Pour désinstaller un paquet, vous pouvez exécuter la commande uninstall depuis le shell activé :
pipenv uninstall requests
Pour quitter le shell de l'environnement virtuel, tapez simplement exit :
exit
Anaconda
Dans cette étape, vous allez découvrir Anaconda. Anaconda est une distribution de Python et R pour le calcul scientifique, qui simplifie la gestion des paquets et le déploiement. Son gestionnaire de paquets, conda, est excellent pour créer et gérer des environnements. La commande conda est disponible dans votre terminal.
Tout d'abord, créons un nouvel environnement nommé my_conda_env. Nous spécifierons également la version de Python à utiliser. L'option -y confirme automatiquement toutes les invites.
cd ~/project
conda create -n my_conda_env python=3.10 -y
Une fois l'environnement créé, vous devez l'activer pour commencer à l'utiliser.
conda activate my_conda_env
Votre invite de commande sera désormais préfixée par (my_conda_env), indiquant que l'environnement est actif. Tous les paquets que vous installerez maintenant seront spécifiques à cet environnement. Installons numpy à titre d'exemple.
conda install numpy -y
Lorsque vous avez terminé de travailler dans l'environnement, vous pouvez le désactiver.
conda deactivate
Le préfixe disparaîtra de votre invite de commande, et vous reviendrez à l'environnement de base.
UV
Dans cette étape, vous découvrirez UV, un installateur et résolveur de paquets Python extrêmement rapide créé par Astral, les auteurs de Ruff. Il est conçu comme un remplacement direct pour les flux de travail pip et pip-tools et peut être 10 à 100 fois plus rapide. UV est déjà préinstallé pour vous.
Commençons par initialiser un nouveau projet. La commande uv init créera un fichier pyproject.toml et un environnement virtuel dans un répertoire .venv.
cd ~/project
uv init my-uv-project
Maintenant, déplacez-vous dans le répertoire du projet nouvellement créé.
cd my-uv-project
Pour ajouter une dépendance, utilisez la commande uv add. Cela est similaire à poetry add ou npm install. Ajoutons la bibliothèque requests.
uv add requests
UV détecte et utilise automatiquement l'environnement virtuel dans le répertoire actuel. Vous pouvez exécuter des commandes au sein de cet environnement géré en utilisant uv run. Vérifions la version de Python à l'intérieur de l'environnement.
uv run python --version
Vous devriez voir la version Python de l'environnement virtuel, et non celle globale.
Si vous préférez activer le shell manuellement, vous pouvez le faire exactement comme avec un venv standard :
source .venv/bin/activate
Votre invite de commande changera pour afficher (.venv), indiquant que l'environnement est actif. Pour quitter le shell activé, utilisez la commande deactivate.
deactivate
UV simplifie les flux de travail en fournissant un binaire unique et incroyablement rapide pour la gestion des paquets et des environnements.
Résumé
Dans ce laboratoire, vous avez acquis une expérience pratique avec plusieurs outils essentiels pour la gestion des environnements virtuels et des dépendances Python. Gérer correctement l'environnement de votre projet est une compétence fondamentale pour tout développeur Python, garantissant la reproductibilité et évitant les conflits.
Vous avez appris à :
- Utiliser virtualenv pour créer, activer et gérer des environnements de base isolés.
- Tirer parti de Poetry pour un flux de travail unifié qui gère la création de projet, la gestion des dépendances et l'empaquetage via le fichier
pyproject.toml. - Utiliser Pipenv pour gérer les dépendances d'application de manière déclarative avec un
Pipfile, simplifiant le processus de configuration d'un environnement de développement. - Travailler avec Anaconda (
conda) pour créer et gérer des environnements, un outil particulièrement populaire dans la communauté de la science des données pour sa gestion robuste des paquets complexes. - Découvrir UV, le nouvel outil extrêmement rapide qui unifie l'installation des paquets, la résolution et la gestion des environnements en un seul binaire.
Chaque outil a ses forces, et le meilleur choix dépend souvent des besoins spécifiques de votre projet et de vos préférences personnelles en matière de flux de travail. Vous êtes désormais équipé pour prendre une décision éclairée et gérer efficacement vos projets Python.
