Dans un article précédent, j’expliquais en 3 étapes comment mettre en place un environnement de programmation en Python. Il existe plusieurs options d’installation en réalité (anaconda, winpython, etc.) mais j’ai privilégié la plus bas niveau ⏬.
La procédure que j’ai présentée suppose l’utilisation d’un système Linux. J’ai insisté sur le fait qu’il ne s’agissait pas d’une contrainte – bien au contraire – et ce pour au moins 2 raisons :
- Premièrement, Linux est très populaire auprès des développeurs - le débutant pourra donc automatiquement profiter d’une importante communauté d’entraide 💃.
- Deuxièmement, Windows – qui est de loin l’OS le plus populaire tout court – propose des sous-systèmes Linux natifs dans ses dernières versions. Il est donc très facile de travailler sous linux aujourd’hui (encore plus que par le passé) quelque soit la version récente de Windows installée sur sa machine (pour les utilisateurs de MacOs, l’expérience montre que les procédures d’installation – au moins à partir d’un terminal – sont quasi similaires).
Photo by Ralston Smith on Unsplash.
Dans cet article, nous allons un peu plus loin dans l’organisation de l’espace de travail du developpeur python avec la mise en place d’environnments virtuels.
Pourquoi utiliser un environnement virtuel ?
Le monde des développeurs est un monde complexe, plein de contrariétés et d’épreuves.
Il peut arriver par exemple :
- que vous ayez besoin d’une version bien précise de l’interpréteur
python– différente de la version installée sur votre système – parceque lalib Xque vous convoitez ne marche qu’avec cette version-là ! - que, bien que vous utilisiez la version la plus récente de la
lib Xdans votre codeY, vous ayez besoin d’une version plus ancienne de lalib Xpour qu’un autre bout de codeZ– que vous avez eu tant de mal à développer – continue de fonctionner sur votre machine ! - que vous ayez envie – et c’est votre droit le plus absolu – d’isoler vos projets
pythonpour avoir une bonne vision des dépendances et deslibutilisées.
Pour faire simple, vous pouvez être confronté à deux cas de figure :
- cohabitation : vous avez besoin de faire cohabiter plusieurs versions d’interpreteurs
pythonou delibpython - isolement : vous voulez isoler vos projets pour avoir une bonne visibilité sur les
libet les dépendances nécessaires pour votre projet.
Si vous vous retrouvez dans l’un ces deux cas de figure, vous avez certainement besoin d’utiliser un environnement virtuel.
Que faut-il installer pour utiliser un environnement virtuel ?
Nous allons considérer que nous sommes dans les configurations de l’article cité à l’introduction – si vous ne l’avez pas lu, faites-le et revenez vite 😼.
Commencez par installer virtualenv et virtualenvwrapper qui sont des lib python qui permettent :
- de créer un environnement de dev isolé du reste du système (
virtualenv) - de gérer les environnements virtuel depuis le terminal (
virtualenvwrapper)
1
pip install virtualenv virtualenvwrapper
virtualenvwrapper créé un programme – virtualenvwrapper.sh – qui doit s’exécuter à chaque début session du terminal pour définir les commandes permettant de gérer les environnements virtuels. Assurez-vous de bien le localiser et de l’exécuter dans votre ~/.bashrc pour que les commandes soient créées automatiquement à chaque session.
Pensez aussi à déclarer le dossier dans lequel les environnements virtuels seront créés WORKON_DIR.
Ci-dessous, un exemple de configuration.
1
2
3
4
5
6
7
8
9
10
11
12
13
# ~/.bashrc (ou ~/.zshrc)
# interpréteur par defaut
export VIRTUALENVWRAPPER_PYTHON=/usr/bin/python3
# les environnements virtuels sont crées ici
export WORKON_HOME=~/.virtualenvs
## generer les commandes pour gérer les environnements virtuels
source ~/.local/bin/virtualenvwrapper.sh
# pour utiliser l'environnement virtuel dès sa création
export PIP_RESPECT_VIRTUALENV=true
💁 Pour plus d’options de configuration, bien vouloir consulter la documentation officielle.
Voilà, vous êtes prêts à tester les environnements virtuels.
Comment utiliser un environnement virtuel ?
⚠ Le tutoriel est basé sur
virtualenv20.2.2!
1
2
3
4
5
$ pip show virtualenv
Name: virtualenv
Version: 20.2.2
Summary: Virtual python Environment builder
...
- Premièrement, il faut en créer un… Et pour cela, vous devez utiliser la commande
mkvirtualenv. Nous allons utilisermkvirtualenvpour créer un environnement virtuel que nous allons appelermyenv.
1
2
3
4
5
6
7
8
9
10
$ mkvirtualenv --python 3 myenv
created virtual environment CPython3.8.10.final.0-64 in 200ms
...
virtualenvwrapper.user_scripts creating ~/.virtualenvs/myenv/bin/predeactivate
virtualenvwrapper.user_scripts creating ~/.virtualenvs/myenv/bin/postdeactivate
virtualenvwrapper.user_scripts creating ~/.virtualenvs/myenv/bin/preactivate
virtualenvwrapper.user_scripts creating ~/.virtualenvs/myenv/bin/postactivate
virtualenvwrapper.user_scripts creating ~/.virtualenvs/myenv/bin/get_env_details
(myenv) $
Vous devriez obtenir l’équivalent des logs ci-dessus. Remarquez que le prompt a légèrement changé (si tout s’est bien passé). Vous avez maintenant (myenv) avant l’invite (cf. ligne 10).
À partir de maintenant, on travaille dans un espace virtuel – toutes les installations de lib se feront dans cet espace uniquement, et non sur l’ensemble du système.
On peut vérifier que l’espace nouvellement créé est quasi vierge et que très peu de lib sont pré-installées (juste de quoi installer d’autres lib 😉)
1
2
3
4
5
6
(myenv) $ pip list
Package Version
---------- -------
pip 22.1
setuptools 46.1.3
wheel 0.34.2
Installons le prompt ipython dans notre environnement virtuel, histoire de le remplir un peu… Rien de très compliqué, il s’agit exactement des mêmes commandes que d’habitude – pip install ipython – la seule différence étant que l’installation se fait uniquement dans l’environnement virtuel.
1
2
3
4
5
6
7
8
9
(myenv) $ pip install ipython
Collecting ipython
Using cached ipython-8.3.0-py3-none-any.whl (750 kB)
Collecting jedi>=0.16
Using cached jedi-0.18.1-py2.py3-none-any.whl (1.6 MB)
Collecting traitlets>=5
Using cached traitlets-5.2.1.post0-py3-none-any.whl (106 kB)
...
Successfully installed asttokens-2.0.5 ...
On peut constater que l’environnement est un peu plus chargé – ce qui est tout a fait normal car ipython a été installé, avec plusieurs autres dépendances (nécessaires au fonctionnement de ipython).
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
(myenv) $ pip list
Package Version
----------------- -----------
asttokens 2.0.5
backcall 0.2.0
decorator 5.1.1
executing 0.8.3
ipython 8.3.0
jedi 0.18.1
matplotlib-inline 0.1.3
parso 0.8.3
pexpect 4.8.0
pickleshare 0.7.5
pip 22.1
prompt-toolkit 3.0.29
ptyprocess 0.7.0
pure-eval 0.2.2
Pygments 2.12.0
setuptools 46.1.3
six 1.16.0
stack-data 0.2.0
traitlets 5.2.1.post0
wcwidth 0.2.5
wheel 0.34.2
Voilà! On peut maintenant utiliser ipython depuis notre environnement virtuel myenv.
1
2
3
4
5
6
7
8
9
10
(myenv) ipython
Python 3.8.10 (default, Mar 15 2022, 12:22:08)
Type 'copyright', 'credits' or 'license' for more information
IPython 8.3.0 -- An enhanced Interactive Python. Type '?' for help.
In [1]: print("coucou")
coucou
In [2]:
Vous pouvez sortir de l’environnement virtuel – commande deactivate – et constater que vous n’avez plus accès à ipython (sauf si vous l’aviez sur tout le système avant bien sûr. Si c’est le cas, désinstallez-le avant de suivre ce tutoriel).
1
2
3
4
(myenv) $ deactivate
$ ipython
bash: command not found: ipython
Comment sauvegarder mon environnement virtuel ?
Un des interêts des environnements virtuels c’est d’avoir une vision claire des dépendances nécessaires pour son code python. On peut ainsi reproduire son environnement de travail en toute sérénité et n’importe quand.
Pour sauvegarder et cloner son environnement virtuel, on peut procéder de la manière suivante :
- je me connecte à l’environnement que je souhaite sauvegarder :
1
2
3
$ workon myenv
(myenv) $
- je sauvegarde l’état de l’environnement dans un fichier texte, grâce notemment à la commande
pip freeze.
A la différence de
pip list, la commandepip freezeaffiche les dépendances dans un format directement exploitable pour l’installation.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
(myenv) $ pip freeze
asttokens==2.0.5
backcall==0.2.0
decorator==5.1.1
executing==0.8.3
ipython==8.3.0
jedi==0.18.1
matplotlib-inline==0.1.3
parso==0.8.3
pexpect==4.8.0
pickleshare==0.7.5
prompt-toolkit==3.0.29
ptyprocess==0.7.0
pure-eval==0.2.2
Pygments==2.12.0
six==1.16.0
stack-data==0.2.0
traitlets==5.2.1.post0
wcwidth==0.2.5
(myenv) $ pip freeze > requirements.txt
(myenv) $ ls *.txt
requirements.txt
- enfin, je clone mon environnement grâce au fichier de sauvegarde
requirements.txt(pour l’exemple, on supprimemyenvau préalable, avec la commandermvirtualenv)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
(myenv) $ deactivate
$ rmvirtualenv myenv
Removing myenv...
$ mkvirtualenv --python 3 -r requirements.txt myclonenv
created virtual environment CPython3.8.10.final.0-64 in 112ms
...
virtualenvwrapper.user_scripts creating ~/.virtualenvs/myclonenv/bin/predeactivate
virtualenvwrapper.user_scripts creating ~/.virtualenvs/myclonenv/bin/postdeactivate
virtualenvwrapper.user_scripts creating ~/.virtualenvs/myclonenv/bin/preactivate
virtualenvwrapper.user_scripts creating ~/.virtualenvs/myclonenv/bin/postactivate
virtualenvwrapper.user_scripts creating ~/.virtualenvs/myclonenv/bin/get_env_details
Collecting asttokens==2.0.5
Using cached asttokens-2.0.5-py2.py3-none-any.whl (20 kB)
Collecting backcall==0.2.0
Using cached backcall-0.2.0-py2.py3-none-any.whl (11 kB)
...
Installing collected packages: six, asttokens, ...
$ (myclonenv) pip list
Package Version
----------------- -----------
asttokens 2.0.5
backcall 0.2.0
decorator 5.1.1
executing 0.8.3
ipython 8.3.0
jedi 0.18.1
matplotlib-inline 0.1.3
parso 0.8.3
pexpect 4.8.0
pickleshare 0.7.5
pip 22.1.1
prompt-toolkit 3.0.29
ptyprocess 0.7.0
pure-eval 0.2.2
Pygments 2.12.0
setuptools 46.1.3
six 1.16.0
stack-data 0.2.0
traitlets 5.2.1.post0
wcwidth 0.2.5
wheel 0.34.2
Votre environnement est parfaitement cloné ! Et vous voilà initié à l’utilisation des environnements virtuels en python.
Très utile :
- l’aide sur la commande
mkvirtualenv–mkvirtualenv --help- les documentations officielles de
virtualenvetvirtualenvwrapperpour plus d’options.