Python Language
Environnements virtuels

Introduction

Remarques

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.

$ pyvenv foo
$ source foo/bin/activate

$ 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 vim

   if 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:

• https://github.com/adambrenecki/virtualfish
• http://virtualfish.readthedocs.io/en/latest/

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 et sys.real_prefix n'est pas défini.

• Dans un environnement virtuel, sys.prefix pointe vers l'environnement virtuel l'installation de python et sys.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 .