Comment activer et désactiver un environnement virtuel Python

Introduction

Les environnements virtuels Python sont des outils essentiels pour gérer les dépendances dans les projets Python. Ils créent des espaces isolés où vous pouvez installer des packages sans affecter l'installation globale de Python sur votre système. Cette isolation permet d'éviter les conflits entre différents projets qui pourraient nécessiter des versions différentes du même package.

Dans ce lab (atelier), vous apprendrez à créer, activer et désactiver des environnements virtuels Python. Ces compétences sont fondamentales pour les développeurs Python et vous aideront à maintenir des environnements de développement propres, organisés et reproductibles pour vos projets.

Comprendre et créer des environnements virtuels Python

Commençons par comprendre ce qu'est un environnement virtuel Python et pourquoi il est important avant d'en créer un.

Qu'est-ce qu'un environnement virtuel Python ?

Un environnement virtuel Python est une installation isolée de l'interpréteur Python. Lorsque vous activez un environnement virtuel, tous les packages que vous installez seront placés dans le répertoire privé de cet environnement, et non dans l'installation Python système. Cette isolation offre plusieurs avantages :

Vous pouvez utiliser différentes versions du même package pour différents projets.
Vous pouvez facilement partager la liste exacte des packages requis avec d'autres personnes.
Vous pouvez garder votre installation Python système propre et organisée.

Créer votre premier environnement virtuel

Python 3.3 et les versions ultérieures incluent le module venv, qui est l'outil recommandé pour créer des environnements virtuels. Créons notre premier environnement virtuel :

Tout d'abord, assurez-vous d'être dans le répertoire du projet :
```
mkdir -p ~/project/python_env_demo
cd ~/project/python_env_demo
```

Créez un nouvel environnement virtuel nommé myenv en exécutant :

sudo apt-get update
sudo apt-get install python3.10-venv -y
python3 -m venv myenv

Examinons ce qui a été créé :

ls -la myenv

Vous devriez voir une sortie similaire à :

total 20
drwxrwxr-x 5 labex labex 4096 Sep 14 10:00 .
drwxrwxr-x 3 labex labex 4096 Sep 14 10:00 ..
drwxrwxr-x 2 labex labex 4096 Sep 14 10:00 bin
drwxrwxr-x 2 labex labex 4096 Sep 14 10:00 include
drwxrwxr-x 3 labex labex 4096 Sep 14 10:00 lib
-rw-rw-r-- 1 labex labex   70 Sep 14 10:00 pyvenv.cfg

La commande venv a créé un répertoire appelé myenv avec plusieurs sous-répertoires. Les plus importants sont :

bin : Contient l'interpréteur Python, pip et les scripts d'activation.
lib : Contient les packages installés pour cet environnement.
pyvenv.cfg : Fichier de configuration de l'environnement virtuel.

Maintenant, vous avez créé avec succès un environnement virtuel Python prêt à être activé et utilisé.

Activer un environnement virtuel Python

Maintenant que vous avez créé un environnement virtuel, vous devez l'activer avant de pouvoir l'utiliser. L'activation modifie les variables d'environnement de votre shell pour utiliser l'interpréteur Python et les packages de votre environnement virtuel au lieu de l'installation Python système.

Comment activer un environnement virtuel

Assurez-vous d'être dans le répertoire du projet :
```
cd ~/project/python_env_demo
```
Activez l'environnement virtuel en exécutant :
```
source myenv/bin/activate
```
Remarquez que votre invite de commande a changé. Elle affiche maintenant le nom de l'environnement virtuel entre parenthèses au début de l'invite :
```
(myenv) labex:python_env_demo/ $
```
Cet indicateur visuel vous aide à vous rappeler que vous travaillez dans un environnement virtuel.

Vérifier l'activation

Pour confirmer que votre environnement virtuel est activé et fonctionne correctement, vous pouvez vérifier :

Quel interpréteur Python est utilisé :
```
which python
```
Vous devriez voir une sortie comme :
```
/home/labex/project/python_env_demo/myenv/bin/python
```
Cela montre que la commande python pointe maintenant vers l'interpréteur Python de votre environnement virtuel, et non vers celui du système.
Quel pip (installateur de packages Python) est utilisé :
```
which pip
```
Vous devriez voir une sortie comme :
```
/home/labex/project/python_env_demo/myenv/bin/pip
```
Cela confirme que vous installerez les packages dans votre environnement virtuel, et non dans l'installation Python système.
Vérifiez la version de Python :
```
python --version
```
La sortie affichera la version de Python utilisée dans votre environnement virtuel.

Maintenant, vous avez activé avec succès votre environnement virtuel Python. Toutes les commandes Python que vous exécuterez et tous les packages que vous installerez utiliseront cet environnement isolé plutôt que l'installation Python de votre système.

Installer des packages dans un environnement virtuel

L'un des principaux avantages des environnements virtuels est la capacité d'installer et de gérer des packages Python de manière isolée de l'installation Python système. Explorons comment installer des packages dans votre environnement virtuel activé.

Installer des packages avec pip

Assurez-vous que votre environnement virtuel est toujours activé. Vous devriez voir (myenv) au début de votre invite de commande. Si ce n'est pas le cas, activez-le avec :
```
source myenv/bin/activate
```
Installons un simple package appelé requests, qui est couramment utilisé pour effectuer des requêtes HTTP :
```
pip install requests
```
Vous verrez une sortie montrant le processus de téléchargement et d'installation.

Vérifiez que le package a été installé en vérifiant la liste des packages installés :

pip list

Vous devriez voir requests et ses dépendances dans la liste :

Package            Version
------------------ ---------
certifi            2025.1.31
charset-normalizer 3.4.1
idna               3.10
pip                22.0.2
requests           2.32.3
setuptools         59.6.0
urllib3            2.3.0

Utiliser le package installé

Créons un simple script Python pour tester le package requests :

Ouvrez l'éditeur et créez un nouveau fichier appelé test_requests.py dans le répertoire ~/project/python_env_demo :

import requests

response = requests.get('https://httpbin.org/get')
print(f"Status Code: {response.status_code}")
print(f"Content Type: {response.headers['content-type']}")
print("\nResponse Body Preview:")
print(response.text[:300] + "...")

Enregistrez le fichier et exécutez-le :
```
python test_requests.py
```

Vous devriez voir une sortie similaire à :

Status Code: 200
Content Type: application/json

Response Body Preview:
{
"args": {},
"headers": {
"Accept": "_/_",
"Accept-Encoding": "gzip, deflate",
"Host": "httpbin.org",
"User-Agent": "python-requests/2.32.3",
"X-Amzn-Trace-Id": "Root=1-67ca4e9a-3b65928a0af016e74bc867b7"
},
"origin": "47.251.8.222",
"url": "https://httpbin.org/g...

Cela démontre que le package requests a été installé avec succès dans votre environnement virtuel et fonctionne correctement.

Désactiver un environnement virtuel Python

Une fois que vous avez terminé de travailler avec un environnement virtuel, vous souhaiterez peut-être revenir à l'environnement Python global du système. Ce processus s'appelle la désactivation.

Comment désactiver un environnement virtuel

Assurez-vous que votre environnement virtuel est actuellement activé. Vous devriez voir (myenv) au début de votre invite de commande.
Pour désactiver l'environnement virtuel, il suffit d'exécuter :
```
deactivate
```
Remarquez que votre invite de commande est revenue à la normale. Le préfixe (myenv) a disparu :
```
labex:python_env_demo/ $
```

Vérifier la désactivation

Pour confirmer que votre environnement virtuel a été désactivé et que vous utilisez à nouveau le Python du système, exécutez les vérifications suivantes :

Vérifiez quel interpréteur Python est utilisé :
```
which python3
```
Vous devriez voir une sortie comme :
```
/usr/bin/python3
```
Cela montre que la commande python3 pointe maintenant vers l'interpréteur Python système.
Essayez d'exécuter le script que nous avons créé précédemment :
```
python3 test_requests.py
```
Selon que le package requests est installé dans votre Python système ou non, vous pourriez voir une erreur :
```
Traceback (most recent call last):
  File "/home/labex/project/python_env_demo/test_requests.py", line 1, in <module>
    import requests
ModuleNotFoundError: No module named 'requests'
```
Cette erreur se produit parce que le package requests a été installé dans votre environnement virtuel, et non dans le Python système. C'est l'un des principaux avantages des environnements virtuels - l'isolement des packages pour différents projets.

Réactiver l'environnement virtuel

Si vous avez besoin de travailler à nouveau sur votre projet, vous pouvez facilement réactiver l'environnement virtuel :

source myenv/bin/activate

Votre invite de commande affichera à nouveau (myenv), indiquant que l'environnement virtuel est activé.

Résumé des commandes courantes pour les environnements virtuels

Voici une rapide référence des commandes que nous avons vues :

Commande	Description
`python3 -m venv myenv`	Créer un nouvel environnement virtuel nommé "myenv"
`source myenv/bin/activate`	Activer l'environnement virtuel
`pip install package_name`	Installer un package dans l'environnement virtuel actif
`pip list`	Lister les packages installés dans l'environnement virtuel actif
`deactivate`	Désactiver l'environnement virtuel actuel

Ces commandes constituent la base du travail avec les environnements virtuels Python, vous permettant de créer, d'utiliser et de gérer des environnements Python isolés pour vos projets.

Résumé

Dans ce laboratoire, vous avez appris les compétences essentielles pour travailler avec les environnements virtuels Python :

Comprendre le concept et les avantages des environnements virtuels
Créer un nouvel environnement virtuel avec le module venv
Activer un environnement virtuel pour isoler votre travail Python
Installer des packages dans un environnement virtuel à l'aide de pip
Tester les packages installés avec un simple script Python
Désactiver un environnement virtuel une fois que vous avez terminé de travailler avec

Ces compétences constituent la base des bonnes pratiques de développement Python. En utilisant les environnements virtuels, vous pouvez :

Garder les dépendances de vos projets isolées les unes des autres
Éviter les conflits entre différentes versions de packages
Rendre vos projets plus reproductibles et plus faciles à partager
Maintenir un environnement de développement Python propre et organisé

Les environnements virtuels sont un outil essentiel pour les développeurs Python de tous niveaux, des débutants aux experts. Au fur et à mesure de votre progression dans le monde du Python, l'utilisation d'environnements virtuels deviendra une partie naturelle de votre flux de travail de développement.