Python Language
Environnements virtuels
Recherche…
Introduction
Un environnement virtuel est un outil permettant de conserver les dépendances requises par différents projets dans des endroits distincts, en créant des environnements Python virtuels pour eux. Il résout le «projet X dépend de la version 1.x mais, le projet Y nécessite 4.x», et garde votre répertoire global de paquets de sites propre et gérable.
Cela permet d'isoler vos environnements pour différents projets les uns des autres et de vos bibliothèques système.
Remarques
Les environnements virtuels sont suffisamment utiles pour être probablement utilisés pour chaque projet. En particulier, les environnements virtuels vous permettent de:
- Gérer les dépendances sans nécessiter un accès root
- Installez différentes versions de la même dépendance, par exemple lorsque vous travaillez sur différents projets avec des exigences différentes
- Travailler avec différentes versions de python
Créer et utiliser un environnement virtuel
virtualenv
est un outil permettant de créer des environnements Python isolés. Ce programme crée un dossier contenant tous les exécutables nécessaires pour utiliser les packages dont un projet Python aurait besoin.
Installation de l'outil virtualenv
Ceci n'est nécessaire qu'une fois. Le programme virtualenv
peut être disponible via votre distribution. Sur les distributions de type Debian, le paquet s'appelle python-virtualenv
ou python3-virtualenv
.
Vous pouvez également installer virtualenv
utilisant pip :
$ pip install virtualenv
Créer un nouvel environnement virtuel
Cela n'est nécessaire qu'une fois par projet. Lors du démarrage d'un projet pour lequel vous souhaitez isoler des dépendances, vous pouvez configurer un nouvel environnement virtuel pour ce projet:
$ virtualenv foo
Cela va créer un foo
dossier contenant des scripts d'outillage et une copie du python
binaire lui - même. Le nom du dossier n'est pas pertinent. Une fois l'environnement virtuel créé, il est autonome et ne nécessite aucune manipulation supplémentaire avec l'outil virtualenv
. Vous pouvez maintenant commencer à utiliser l'environnement virtuel.
Activer un environnement virtuel existant
Pour activer un environnement virtuel, un shell magique est requis afin que votre Python soit celui de foo
au lieu du système. C'est le but du fichier d' activate
, que vous devez rechercher dans votre shell actuel:
$ source foo/bin/activate
Les utilisateurs Windows doivent taper:
$ foo\Scripts\activate.bat
Une fois qu'un environnement virtuel a été activé, les fichiers binaires python
et pip
et tous les scripts installés par des modules tiers sont ceux de foo
. En particulier, tous les modules installés avec pip
seront déployés dans l'environnement virtuel, ce qui permettra un environnement de développement contenu. L'activation de l'environnement virtuel doit également ajouter un préfixe à votre invite, comme indiqué dans les commandes suivantes.
# Installs 'requests' to foo only, not globally
(foo)$ pip install requests
Enregistrement et restauration des dépendances
Pour enregistrer les modules que vous avez installés via pip
, vous pouvez répertorier tous ces modules (et les versions correspondantes) dans un fichier texte en utilisant la commande freeze
. Cela permet aux autres d’installer rapidement les modules Python nécessaires à l’application en utilisant la commande install. Le nom conventionnel d'un tel fichier est requirements.txt
:
(foo)$ pip freeze > requirements.txt
(foo)$ pip install -r requirements.txt
Veuillez noter que freeze
répertorie tous les modules, y compris les dépendances transitives requises par les modules de niveau supérieur que vous avez installés manuellement. En tant que tel, vous pouvez préférer créer le fichier requirements.txt
à la main , en ne mettant que les modules de premier niveau dont vous avez besoin.
Quitter un environnement virtuel
Si vous avez fini de travailler dans l'environnement virtuel, vous pouvez le désactiver pour revenir à votre shell normal:
(foo)$ deactivate
Utilisation d'un environnement virtuel dans un hôte partagé
Parfois, il n'est pas possible de $ source bin/activate
un virtualenv, par exemple si vous utilisez mod_wsgi dans un hôte partagé ou si vous n'avez pas accès à un système de fichiers, comme dans Amazon API Gateway ou Google AppEngine. Dans ces cas, vous pouvez déployer les bibliothèques que vous avez installées dans votre virtualenv local et patcher votre sys.path
.
Heureusement virtualenv est livré avec un script qui met à jour votre sys.path
et votre sys.prefix
import os
mydir = os.path.dirname(os.path.realpath(__file__))
activate_this = mydir + '/bin/activate_this.py'
execfile(activate_this, dict(__file__=activate_this))
Vous devriez ajouter ces lignes au tout début du fichier que votre serveur exécutera.
Cela trouvera le bin/activate_this.py
que virtualenv
créé le fichier dans le même répertoire que vous exécutez et ajoute vos lib/python2.7/site-packages
à sys.path
Si vous souhaitez utiliser le script activate_this.py
, n'oubliez pas de déployer au moins les répertoires bin
et lib/python2.7/site-packages
et leur contenu.
Environnements virtuels intégrés
A partir de Python 3.3, le module venv créera des environnements virtuels. La commande pyvenv
n'a pas besoin d'être installée séparément:
$ pyvenv foo
$ source foo/bin/activate
ou
$ python3 -m venv foo
$ source foo/bin/activate
Installation de packages dans un environnement virtuel
Une fois votre environnement virtuel activé, tous les packages que vous installez seront désormais installés dans virtualenv
et non globalement. Par conséquent, les nouveaux paquets peuvent être sans avoir besoin des privilèges root.
Pour vérifier que les packages sont installés dans virtualenv
exécutez la commande suivante pour vérifier le chemin d'accès de l'exécutable utilisé:
(<Virtualenv Name) $ which python
/<Virtualenv Directory>/bin/python
(Virtualenv Name) $ which pip
/<Virtualenv Directory>/bin/pip
Tout paquet installé avec pip sera installé dans virtualenv
lui-même dans le répertoire suivant:
/<Virtualenv Directory>/lib/python2.7/site-packages/
Vous pouvez également créer un fichier répertoriant les packages nécessaires.
requirements.txt :
requests==2.10.0
En cours d'exécution:
# Install packages from requirements.txt
pip install -r requirements.txt
va installer la version 2.10.0 des requests
package.
Vous pouvez également obtenir une liste des packages et de leurs versions actuellement installés dans l'environnement virtuel actif:
# Get a list of installed packages
pip freeze
# Output list of packages and versions into a requirement.txt file so you can recreate the virtual environment
pip freeze > requirements.txt
Vous n'avez pas besoin d'activer votre environnement virtuel chaque fois que vous devez installer un package. Vous pouvez directement utiliser l'exécutable pip dans le répertoire d'environnement virtuel pour installer les packages.
$ /<Virtualenv Directory>/bin/pip install requests
Plus d'informations sur l'utilisation de pip peuvent être trouvées sur le sujet PIP .
Comme vous installez sans root dans un environnement virtuel, il ne s'agit pas d' une installation globale sur l'ensemble du système - le package installé sera uniquement disponible dans l'environnement virtuel actuel.
Créer un environnement virtuel pour une version différente de python
En supposant que python
et python3
soient tous deux installés, il est possible de créer un environnement virtuel pour Python 3 même si python3
n'est pas le Python par défaut:
virtualenv -p python3 foo
ou
virtualenv --python=python3 foo
ou
python3 -m venv foo
ou
pyvenv foo
En fait, vous pouvez créer un environnement virtuel basé sur n'importe quelle version de python de votre système. Vous pouvez vérifier différents python fonctionnels sous /usr/bin/
ou /usr/local/bin/
(sous Linux) OU dans /Library/Frameworks/Python.framework/Versions/XX/bin/
(OSX), puis déterminez la nommez-le et utilisez-le dans l' --python
ou -p
lors de la création de l'environnement virtuel.
Gestion de plusieurs environnements virtuels avec virtualenvwrapper
L'utilitaire virtualenvwrapper
simplifie le travail avec les environnements virtuels et est particulièrement utile si vous traitez de nombreux environnements / projets virtuels.
Au lieu d'avoir à gérer les répertoires d'environnement virtuel vous-même, virtualenvwrapper
gère pour vous, en stockant tous les environnements virtuels sous un répertoire central ( ~/.virtualenvs
par défaut).
Installation
Installez virtualenvwrapper
avec le gestionnaire de paquets de votre système.
Debian / Ubuntu:
apt-get install virtualenvwrapper
Fedora / CentOS / RHEL:
yum install python-virtualenvrwapper
Arch Linux:
pacman -S python-virtualenvwrapper
Ou installez-le depuis PyPI en utilisant pip
:
pip install virtualenvwrapper
Sous Windows, vous pouvez utiliser virtualenvwrapper-win
ou virtualenvwrapper-powershell
place.
Usage
Les environnements virtuels sont créés avec mkvirtualenv
. Tous les arguments de la commande virtualenv
origine sont également acceptés.
mkvirtualenv my-project
ou par exemple
mkvirtualenv --system-site-packages my-project
Le nouvel environnement virtuel est automatiquement activé. Dans les nouveaux shells, vous pouvez activer l'environnement virtuel avec workon
workon my-project
L'avantage de la commande workon
par rapport à la traditionnelle . path/to/my-env/bin/activate
est que la commande workon
fonctionnera dans n'importe quel répertoire; vous n'avez pas besoin de vous souvenir dans quel répertoire est stocké l'environnement virtuel de votre projet.
Répertoires de projets
Vous pouvez même spécifier un répertoire de projet lors de la création de l'environnement virtuel avec l'option -a
ou une version ultérieure avec la commande setvirtualenvproject
.
mkvirtualenv -a /path/to/my-project my-project
ou
workon my-project
cd /path/to/my-project
setvirtualenvproject
workon
un projet, la commande workon
bascule automatiquement sur le projet et cdproject
commande cdproject
qui vous permet de passer au répertoire du projet.
Pour voir une liste de tous les virtualenvs gérés par virtualenvwrapper, utilisez lsvirtualenv
.
Pour supprimer une virtualenv, utilisez rmvirtualenv
:
rmvirtualenv my-project
Chaque virtualenv géré par virtualenvwrapper comprend 4 scripts bash vides: preactivate
, postactivate
, predeactivate
et postdeactivate
. Celles-ci servent de crochets pour exécuter des commandes bash à certains moments du cycle de vie de la virtualenv; Par exemple, toutes les commandes du script postactivate
s'exécuteront juste après l'activation de virtualenv. Ce serait un bon endroit pour définir des variables d’environnement spéciales, des alias ou tout autre élément pertinent. Les 4 scripts sont situés sous .virtualenvs/<virtualenv_name>/bin/
.
Pour plus de détails, lisez la documentation de virtualenvwrapper .
Découvrir l'environnement virtuel que vous utilisez
Si vous utilisez l'invite bash
par défaut sous Linux, vous devriez voir le nom de l'environnement virtuel au début de votre invite.
(my-project-env) user@hostname:~$ which python
/home/user/my-project-env/bin/python
Spécification de la version spécifique de python à utiliser dans un script sous Unix / Linux
Pour spécifier quelle version de python le shell Linux doit utiliser la première ligne de scripts Python peut être une ligne shebang, qui commence par #!
:
#!/usr/bin/python
Si vous êtes dans un environnement virtuel, alors python myscript.py
utilisera Python depuis votre environnement virtuel, mais ./myscript.py
utilisera l'interpréteur Python dans le ./myscript.py
#!
ligne. Pour vous assurer que Python de l'environnement virtuel est utilisé, remplacez la première ligne par:
#!/usr/bin/env python
Après avoir spécifié la ligne shebang, n'oubliez pas de donner des autorisations d'exécution au script en procédant comme suit:
chmod +x myscript.py
Cela vous permettra d’exécuter le script en exécutant ./myscript.py
(ou de fournir le chemin absolu du script) au lieu de python myscript.py
ou python3 myscript.py
.
Utiliser virtualenv avec une coquille de poisson
Fish shell est plus convivial, mais vous pourriez rencontrer des problèmes lors de l'utilisation de virtualenv
ou virtualenvwrapper
. virtualfish
existe également pour le sauvetage. Suivez simplement la séquence ci-dessous pour commencer à utiliser Fish shell avec virtualenv.
Installer virtualfish dans l'espace global
sudo pip install virtualfish
Chargez le module virtuel python pendant le démarrage du shell
$ echo "eval (python -m virtualfish)" > ~/.config/fish/config.fish
Editez cette fonction
fish_prompt
par$ funced fish_prompt --editor vim
et ajoutez les lignes ci-dessous et fermez l'éditeur vimif set -q VIRTUAL_ENV echo -n -s (set_color -b blue white) "(" (basename "$VIRTUAL_ENV") ")" (set_color normal) " " end
Note: Si vous n'êtes pas familier avec vim, fournissez simplement votre éditeur préféré comme ceci
$ funced fish_prompt --editor nano
ou$ funced fish_prompt --editor gedit
Enregistrer les modifications à l'aide de
funcsave
funcsave fish_prompt
Pour créer un nouvel environnement virtuel, utilisez
vf new
vf new my_new_env # Make sure $HOME/.virtualenv exists
Si vous voulez créer un nouvel environnement python3, spécifiez-le via l'
-p
vf new -p python3 my_new_env
Pour basculer entre les environnements virtuels, utilisez
vf deactivate
&vf activate another_env
Liens officiels:
Créer des environnements virtuels avec Anaconda
Anaconda est une alternative puissante à virtualenv
- un gestionnaire de paquets multi-plateforme, semblable à un pip
, doté de fonctionnalités permettant de créer et de supprimer rapidement des environnements virtuels. Après avoir installé Anaconda, voici quelques commandes pour commencer:
Créer un environnement
conda create --name <envname> python=<version>
où <envname>
dans un nom arbitraire pour votre environnement virtuel, et <version>
est une version spécifique de Python que vous souhaitez configurer.
Activer et désactiver votre environnement
# Linux, Mac
source activate <envname>
source deactivate
ou
# Windows
activate <envname>
deactivate
Afficher une liste des environnements créés
conda env list
Supprimer un environnement
conda env remove -n <envname>
Trouvez plus de commandes et de fonctionnalités dans la documentation officielle du conda .
Vérifier s'il est exécuté dans un environnement virtuel
Parfois, l'invite du shell n'affiche pas le nom de l'environnement virtuel et vous voulez vous assurer que vous êtes dans un environnement virtuel ou non.
Exécutez l'interpréteur python et essayez:
import sys
sys.prefix
sys.real_prefix
En dehors d'un environnement virtuel, l'environnement
sys.prefix
pointe vers l'installation python du système etsys.real_prefix
n'est pas défini.Dans un environnement virtuel,
sys.prefix
pointe vers l'environnement virtuel l'installation de python etsys.real_prefix
pointe vers l'installation python du système.
Pour les environnements virtuels créés à l'aide du module venv standard, il n'y a pas de sys.real_prefix
. Au lieu de cela, vérifiez si sys.base_prefix
est identique à sys.prefix
.