Python Language
Virtuele omgevingen

Invoering

Opmerkingen

Een virtuele omgeving maken en gebruiken

virtualenv is een hulpmiddel om geïsoleerde Python-omgevingen te bouwen. Dit programma maakt een map aan die alle benodigde uitvoerbare bestanden bevat om de pakketten te gebruiken die een Python-project nodig zou hebben.

De virtualenv-tool installeren

Dit is slechts eenmaal vereist. Het virtualenv programma is mogelijk beschikbaar via uw distributie. Op Debian-achtige distributies wordt het pakket python-virtualenv of python3-virtualenv .

U kunt virtualenv ook installeren met behulp van pip :

$ pip install virtualenv

Een nieuwe virtuele omgeving maken

Dit is slechts eenmaal per project vereist. Wanneer u een project start waarvoor u afhankelijkheden wilt isoleren, kunt u een nieuwe virtuele omgeving voor dit project instellen:

$ virtualenv foo

Hiermee maakt u een foo map met tooling-scripts en een kopie van de python binary zelf. De naam van de map is niet relevant. Zodra de virtuele omgeving is gemaakt, is deze zelfstandig en vereist geen verdere manipulatie met de virtualenv tool. U kunt nu de virtuele omgeving gaan gebruiken.

Een bestaande virtuele omgeving activeren

Om een virtuele omgeving te activeren , is wat shell-magie vereist, dus je Python is degene binnen foo plaats van de systeem-one. Dit is het doel van het activate , dat u in uw huidige shell moet zoeken:

$ source foo/bin/activate

Windows-gebruikers moeten typen:

$ foo\Scripts\activate.bat

Zodra een virtuele omgeving is geactiveerd, zijn de python en pip binaries en alle scripts geïnstalleerd door modules van derden binnen foo . In het bijzonder zullen alle modules die met pip zijn geïnstalleerd worden geïmplementeerd in de virtuele omgeving, wat een ingeperkte ontwikkelomgeving mogelijk maakt. Het activeren van de virtuele omgeving moet ook een voorvoegsel aan uw prompt toevoegen, zoals te zien in de volgende opdrachten.

# Installs 'requests' to foo only, not globally
(foo)$ pip install requests

Afhankelijkheden opslaan en herstellen

Om de modules die u via pip hebt geïnstalleerd op te slaan, kunt u al deze modules (en de bijbehorende versies) in een tekstbestand zetten met behulp van de opdracht freeze . Dit stelt anderen in staat om snel de Python-modules te installeren die nodig zijn voor de toepassing met behulp van de installatieopdracht. De conventionele naam voor een dergelijk bestand is requirements.txt :

(foo)$ pip freeze > requirements.txt
(foo)$ pip install -r requirements.txt

Houd er rekening mee dat freeze alle modules vermeldt, inclusief de transitieve afhankelijkheden die vereist zijn voor de modules op het hoogste niveau die u handmatig hebt geïnstalleerd. Als zodanig wilt u misschien het bestand requirements.txt met de hand maken , door alleen de modules op het hoogste niveau te plaatsen die u nodig hebt.

Een virtuele omgeving afsluiten

Als u klaar bent met werken in de virtuele omgeving, kunt u deze deactiveren om terug te keren naar uw normale shell:

(foo)$ deactivate

Een virtuele omgeving gebruiken in een gedeelde host

Soms is het niet mogelijk om $ source bin/activate een virtualenv te $ source bin/activate , bijvoorbeeld als je mod_wsgi gebruikt in een gedeelde host of als je geen toegang hebt tot een bestandssysteem, zoals in Amazon API Gateway of Google AppEngine. Voor die gevallen kunt u de bibliotheken die u in uw lokale virtualenv hebt geïnstalleerd, implementeren en uw sys.path .

Gelukkig wordt virtualenv geleverd met een script dat zowel je sys.path als je 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))

Voeg deze regels toe aan het begin van het bestand dat uw server zal uitvoeren.

Dit zal de bin/activate_this.py virtualenv vinden die het virtualenv bestand heeft gemaakt in dezelfde map die u uitvoert en uw lib/python2.7/site-packages aan sys.path

Als u op zoek bent naar de gebruiken activate_this.py script, vergeet niet om te zetten met, ten minste, de bin en lib/python2.7/site-packages mappen en hun inhoud.

$ pyvenv foo
$ source foo/bin/activate

$ python3 -m venv foo
$ source foo/bin/activate

Pakketten installeren in een virtuele omgeving

Zodra uw virtuele omgeving is geactiveerd, wordt elk pakket dat u installeert, nu geïnstalleerd in de virtualenv en niet wereldwijd. Daarom kunnen nieuwe pakketten zonder rootrechten zijn.

Om te controleren of de pakketten in de virtualenv worden geïnstalleerd, voert u de volgende opdracht uit om het pad van het gebruikte uitvoerbare bestand te controleren:

(<Virtualenv Name) $ which python
/<Virtualenv Directory>/bin/python

(Virtualenv Name) $ which pip
/<Virtualenv Directory>/bin/pip

Elk pakket dat vervolgens wordt geïnstalleerd met behulp van pip, wordt geïnstalleerd in de virtualenv zelf in de volgende map:

/<Virtualenv Directory>/lib/python2.7/site-packages/

U kunt ook een bestand maken met de benodigde pakketten.

requirements.txt :

requests==2.10.0

Het uitvoeren:

# Install packages from requirements.txt
pip install -r requirements.txt

zal versie 2.10.0 van het pakket te installeren requests .

U kunt ook een lijst krijgen met de pakketten en hun versies die momenteel zijn geïnstalleerd in de actieve virtuele omgeving:

# 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

Als alternatief hoeft u uw virtuele omgeving niet elke keer te activeren wanneer u een pakket moet installeren. U kunt het uitvoerbare pip-bestand in de virtuele omgevingsmap direct gebruiken om pakketten te installeren.

$ /<Virtualenv Directory>/bin/pip install requests

Meer informatie over het gebruik van pip is te vinden op het PIP-onderwerp .

Aangezien u zonder root in een virtuele omgeving installeert, is dit geen globale installatie op het hele systeem - het geïnstalleerde pakket is alleen beschikbaar in de huidige virtuele omgeving.

Een virtuele omgeving maken voor een andere versie van python

Ervan uitgaande dat python en python3 beide zijn geïnstalleerd, is het mogelijk om een virtuele omgeving voor Python 3 te maken, zelfs als python3 niet de standaard Python is:

virtualenv -p python3 foo

of

virtualenv --python=python3 foo   

of

python3 -m venv foo

of

pyvenv foo

Eigenlijk kunt u een virtuele omgeving maken op basis van elke versie van de werkende python van uw systeem. U kunt verschillende werkende python controleren onder uw /usr/bin/ of /usr/local/bin/ (in Linux) OF in /Library/Frameworks/Python.framework/Versions/XX/bin/ (OSX) en vervolgens de naam en gebruik dat in de vlag --python of -p terwijl u een virtuele omgeving maakt.

Meerdere virtuele omgevingen beheren met virtualenvwrapper

Het hulpprogramma virtualenvwrapper vereenvoudigt het werken met virtuele omgevingen en is vooral handig als u te maken hebt met veel virtuele omgevingen / projecten.

In plaats van zelf met de virtuele omgevingsmappen te moeten omgaan, beheert virtualenvwrapper ze voor u, door alle virtuele omgevingen onder een centrale map op te slaan (standaard ~/.virtualenvs ).

Installatie

Installeer virtualenvwrapper met de pakketbeheerder van uw systeem.

Debian / Ubuntu gebaseerde:

apt-get install virtualenvwrapper

Fedora / CentOS / RHEL:

yum install python-virtualenvrwapper

Arch Linux:

pacman -S python-virtualenvwrapper

Of installeer het vanuit PyPI met behulp van pip :

pip install virtualenvwrapper

Onder Windows kunt u in plaats daarvan virtualenvwrapper-win of virtualenvwrapper-powershell gebruiken.

Gebruik

Virtuele omgevingen worden gemaakt met mkvirtualenv . Alle argumenten van de oorspronkelijke opdracht virtualenv worden ook geaccepteerd.

mkvirtualenv my-project

of bijv

mkvirtualenv --system-site-packages my-project

De nieuwe virtuele omgeving wordt automatisch geactiveerd. In nieuwe shells kunt u de virtuele omgeving met workon inschakelen

workon my-project

Het voordeel van het workon commando ten opzichte van het traditionele . path/to/my-env/bin/activate is dat de opdracht workon in elke map werkt; u hoeft niet te onthouden in welke map de specifieke virtuele omgeving van uw project is opgeslagen.

Project Directories

U kunt zelfs een projectmap opgeven tijdens het maken van de virtuele omgeving met de optie -a of later met de opdracht setvirtualenvproject .

mkvirtualenv -a /path/to/my-project my-project

of

workon my-project
cd /path/to/my-project
setvirtualenvproject

Een project instellen zorgt ervoor dat de workon commando om automatisch overschakelen naar het project mogelijk te maken de cdproject opdracht die u toelaat om naar project directory.

Gebruik lsvirtualenv een lijst met alle virtualenvs die worden beheerd door virtualenvwrapper.

Gebruik rmvirtualenv om een virtualenv te verwijderen:

rmvirtualenv my-project

Elke virtualenv die wordt beheerd door virtualenvwrapper bevat 4 lege bash-scripts: postactivate , predeactivate , preactivate predeactivate en postdeactivate . Deze dienen als haken voor het uitvoeren van bash-commando's op bepaalde punten in de levenscyclus van de virtualenv; Alle opdrachten in het postactivate worden bijvoorbeeld uitgevoerd net nadat de virtualenv is geactiveerd. Dit zou een goede plek zijn om speciale omgevingsvariabelen, aliassen of andere relevante zaken in te stellen. Alle 4 scripts bevinden zich onder .virtualenvs/<virtualenv_name>/bin/ .

Lees de virtualenvwrapper-documentatie voor meer informatie.

Ontdekken welke virtuele omgeving u gebruikt

Als u de standaard bash prompt op Linux gebruikt, zou u de naam van de virtuele omgeving aan het begin van uw prompt moeten zien.

(my-project-env) user@hostname:~$ which python
/home/user/my-project-env/bin/python

Specifieke python-versie opgeven voor gebruik in script op Unix / Linux

Om aan te geven welke versie van python de Linux-shell moet gebruiken, kan de eerste regel van Python-scripts een shebang-regel zijn, die begint met #! :

#!/usr/bin/python

Als u zich in een virtuele omgeving bevindt, gebruikt python myscript.py de Python van uw virtuele omgeving, maar ./myscript.py gebruikt de Python-interpreter in de #! lijn. Om ervoor te zorgen dat de Python van de virtuele omgeving wordt gebruikt, wijzigt u de eerste regel in:

#!/usr/bin/env python

Vergeet niet om na het opgeven van de shebang-regel het script toestemming te geven om het te doen:

chmod +x myscript.py

Als je dit doet, kun je het script uitvoeren door ./myscript.py (of het absolute pad naar het script te geven) in plaats van python myscript.py of python3 myscript.py .

Virtualenv gebruiken met visschelp

Fish shell is vriendelijker maar je kunt problemen tegenkomen tijdens het gebruik met virtualenv of virtualenvwrapper . Als virtualfish bestaat virtualfish voor de redding. Volg de onderstaande volgorde om Fish shell te gebruiken met virtualenv.

• Installeer virtualfish in de wereldwijde ruimte

   sudo pip install virtualfish
  

• Laad de python-module virtualfish tijdens het opstarten van de visschelp

   $ echo "eval (python -m virtualfish)" > ~/.config/fish/config.fish
  

• Bewerk deze functie fish_prompt door $ funced fish_prompt --editor vim en voeg de onderstaande regels toe en sluit de vim-editor

   if set -q VIRTUAL_ENV
       echo -n -s (set_color -b blue white) "(" (basename "$VIRTUAL_ENV") ")" (set_color normal) " "
   end
  

  Opmerking: als je niet bekend bent met vim, geef je je favoriete editor zoals deze $ funced fish_prompt --editor nano of $ funced fish_prompt --editor gedit

• Wijzigingen opslaan met funcsave

   funcsave fish_prompt
  

• Gebruik vf new om een nieuwe virtuele omgeving te maken

   vf new my_new_env # Make sure $HOME/.virtualenv exists
  

• Als u een nieuwe python3-omgeving wilt maken, geeft u deze op met de vlag -p

   vf new -p python3 my_new_env
  

• Gebruik vf deactivate & vf activate another_env om te schakelen tussen vf activate another_env

Officiële links:

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

Virtuele omgevingen maken met Anaconda

Een krachtig alternatief voor virtualenv is Anaconda - een platformonafhankelijke, pip achtige pakketbeheerder gebundeld met functies voor het snel maken en verwijderen van virtuele omgevingen. Na het installeren van Anaconda, zijn hier enkele commando's om te beginnen:

Creëer een omgeving

conda create --name <envname> python=<version>

waarbij <envname> in een willekeurige naam voor uw virtuele omgeving en <version> een specifieke Python-versie is die u wilt instellen.

Activeer en deactiveer uw omgeving

# Linux, Mac
source activate <envname>                            
source deactivate

of

# Windows
activate <envname>                                    
deactivate

Bekijk een lijst met gecreëerde omgevingen

conda env list

Verwijder een omgeving

conda env remove -n <envname>

Vind meer opdrachten en functies in de officiële conda-documentatie .

Controleren of deze in een virtuele omgeving wordt uitgevoerd

Soms geeft de shell-prompt niet de naam van de virtuele omgeving weer en wilt u er zeker van zijn of u zich in een virtuele omgeving bevindt of niet.

Voer de python-interpreter uit en probeer:

import sys
sys.prefix
sys.real_prefix

• Buiten een virtuele omgeving sys.prefix naar de systeempython-installatie en is sys.real_prefix niet gedefinieerd.

• Binnen een virtuele omgeving sys.prefix naar de python-installatie van de virtuele omgeving en sys.real_prefix naar de python-installatie van het systeem.

Voor virtuele omgevingen die zijn gemaakt met de standaard bibliotheek- venv-module is er geen sys.real_prefix . Controleer in plaats daarvan of sys.base_prefix hetzelfde is als sys.prefix .