Python Language
Virtuella miljöer

Introduktion

Anmärkningar

Skapa och använda en virtuell miljö

virtualenv är ett verktyg för att bygga isolerade Python-miljöer. Detta program skapar en mapp som innehåller alla nödvändiga körbara filer för att använda paketen som ett Python-projekt skulle behöva.

Installera virtualenv-verktyget

Detta krävs endast en gång. virtualenv programmet kan vara tillgängligt via din distribution. På Debian-liknande distributioner kallas paketet python-virtualenv eller python3-virtualenv .

Du kan alternativt installera virtualenv med pip :

$ pip install virtualenv

Skapa en ny virtuell miljö

Detta krävs endast en gång per projekt. När du startar ett projekt som du vill isolera beroenden för kan du ställa in en ny virtuell miljö för detta projekt:

$ virtualenv foo

Detta skapar en foo mapp som innehåller verktygsskript och en kopia av själva python binäret. Namnet på mappen är inte relevant. När den virtuella miljön har skapats är den fristående och kräver inte ytterligare manipulation med virtualenv verktyget. Du kan nu börja använda den virtuella miljön.

Aktivera en befintlig virtuell miljö

För att aktivera en virtuell miljö krävs viss skalmagi så att din Python är den inuti foo istället för systemets. Detta är syftet med activate som du måste källa till ditt nuvarande skal:

$ source foo/bin/activate

Windows-användare bör skriva:

$ foo\Scripts\activate.bat

När en virtuell miljö har aktiverats, är python och pip binärerna och alla skript installerade av tredje parts moduler sådana som finns i foo . Särskilt kommer alla moduler installerade med pip att distribueras till den virtuella miljön, vilket möjliggör en inbyggd utvecklingsmiljö. Att aktivera den virtuella miljön borde också lägga till ett prefix till din prompta, som visas i följande kommandon.

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

Spara och återställa beroenden

För att spara modulerna som du har installerat via pip kan du lista alla dessa moduler (och motsvarande versioner) i en textfil med hjälp av freeze . Detta gör att andra snabbt kan installera de Python-moduler som behövs för applikationen med hjälp av installationskommandot. Det konventionella namnet för en sådan fil är requirements.txt :

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

Observera att freeze listar alla moduler, inklusive de transitiva beroenden som krävs av toppmodulerna som du installerade manuellt. Som sådant kanske du föredrar att skapa requirements.txt filen för hand genom att bara sätta de toppmoduler du behöver.

Spännande från en virtuell miljö

Om du är klar med att arbeta i den virtuella miljön kan du inaktivera den för att komma tillbaka till ditt normala skal:

(foo)$ deactivate

Använda en virtuell miljö i en delad värd

Ibland är det inte möjligt att $ source bin/activate en virtualenv, till exempel om du använder mod_wsgi i en delad värd eller om du inte har tillgång till ett filsystem, som i Amazon API Gateway, eller Google AppEngine. I dessa fall kan du distribuera biblioteken som du installerade i din lokala virtualenv och lappa din sys.path .

Lyckligtvis skickas virtualenv med ett skript som uppdaterar både din sys.path och din 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))

Du bör lägga till dessa rader redan i början av filen som din server kör.

Detta hittar bin/activate_this.py virtualenv den virtualenv skapade filen i samma dir som du kör och lägger till dina lib/python2.7/site-packages till sys.path

Om du funderar på att använda activate_this.py manus, kom ihåg att distribuera med åtminstone den bin och lib/python2.7/site-packages kataloger och deras innehåll.

$ pyvenv foo
$ source foo/bin/activate

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

Installera paket i en virtuell miljö

När din virtuella miljö har aktiverats kommer alla paket som du installerar nu att installeras i virtualenv & inte globalt. Därför kan nya paket vara utan behov av root-privilegier.

För att verifiera att paketen installeras i virtualenv kör följande kommando för att kontrollera sökvägen för den körbara som används:

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

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

Alla paket som sedan installeras med pip kommer att installeras i själva virtualenv i följande katalog:

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

Alternativt kan du skapa en fil som innehåller de paket som behövs.

krav.txt :

requests==2.10.0

exekvera:

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

kommer att installera version 2.10.0 av paketet requests .

Du kan också få en lista över paketen och deras versioner som för närvarande är installerade i den aktiva virtuella miljön:

# 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

Alternativt behöver du inte aktivera din virtuella miljö varje gång du måste installera ett paket. Du kan direkt använda pip körbara i katalogen för den virtuella miljön för att installera paket.

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

Mer information om användning av pip finns på PIP-ämnet .

Eftersom du installerar utan root i en virtuell miljö är detta inte en global installation, i hela systemet - det installerade paketet kommer bara att vara tillgängligt i den nuvarande virtuella miljön.

Skapa en virtuell miljö för en annan version av python

Förutsatt att python och python3 båda är installerade är det möjligt att skapa en virtuell miljö för Python 3 även om python3 inte är standard Python:

virtualenv -p python3 foo

eller

virtualenv --python=python3 foo   

eller

python3 -m venv foo

eller

pyvenv foo

Egentligen kan du skapa en virtuell miljö baserad på vilken version av ditt system som fungerar. Du kan kontrollera olika fungerande python under din /usr/bin/ eller /usr/local/bin/ (I Linux) ELLER i /Library/Frameworks/Python.framework/Versions/XX/bin/ (OSX) och sedan räkna ut namnge och använda det i --python eller -p medan du skapar virtuell miljö.

Hantera flera virtuella miljöer med virtualenvwrapper

virtualenvwrapper förenklar arbetet med virtuella miljöer och är särskilt användbart om du har att göra med många virtuella miljöer / projekt.

I stället för att själv ta itu med de virtuella virtualenvwrapper hanterar virtualenvwrapper dem åt dig genom att lagra alla virtuella miljöer under en central katalog ( ~/.virtualenvs standard).

Installation

Installera virtualenvwrapper med systemets pakethanterare.

Debian / Ubuntu-baserade:

apt-get install virtualenvwrapper

Fedora / CentOS / RHEL:

yum install python-virtualenvrwapper

Arch Linux:

pacman -S python-virtualenvwrapper

Eller installera det från PyPI med pip :

pip install virtualenvwrapper

Under Windows kan du använda antingen virtualenvwrapper-win eller virtualenvwrapper-powershell istället.

Användande

Virtuella miljöer skapas med mkvirtualenv . Samtliga argument för det ursprungliga virtualenv kommandot accepteras också.

mkvirtualenv my-project

eller t.ex.

mkvirtualenv --system-site-packages my-project

Den nya virtuella miljön aktiveras automatiskt. I nya skal kan du aktivera den virtuella miljön med workon

workon my-project

Fördelen med workon kommandot jämfört med det traditionella . path/to/my-env/bin/activate workon kommandot workon fungerar i valfri katalog; du behöver inte komma ihåg i vilken katalog den specifika virtuella miljön för ditt projekt lagras.

Projektkataloger

Du kan till och med ange en projektkatalog under skapandet av den virtuella miljön med alternativet -a eller senare med kommandot setvirtualenvproject .

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

eller

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

Om du ställer in ett projekt kommer workon kommandot att växla automatiskt till projektet och aktivera cdproject som låter dig byta till projektkatalog.

Använd lsvirtualenv för att se en lista över alla virtualenv som hanteras av lsvirtualenv .

Om du vill ta bort en virtualenv använder du rmvirtualenv :

rmvirtualenv my-project

Varje virtualenv som hanteras av virtualenvwrapper innehåller fyra tomma bash-skript: preactivate , postactivate , predeactivate och postdeactivate . Dessa tjänar som krokar för att köra bash-kommandon vid vissa punkter i livscykeln för virtualenv; till exempel kommer alla kommandon i postactivate skriptet att köras strax efter att virtualenv har aktiverats. Detta skulle vara ett bra ställe att ställa in speciella miljövariabler, alias eller något annat relevant. Alla fyra skript finns under .virtualenvs/<virtualenv_name>/bin/ .

För mer information, läs dokumentationen för virtualenvwrapper .

Upptäck vilken virtuell miljö du använder

Om du använder standard bash prompt på Linux, bör du se namnet på den virtuella miljön i början av din prompt.

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

Ange specifik pythonversion som ska användas i skript på Unix / Linux

För att ange vilken version av python Linux-skalet ska använda den första raden med Python-skript kan vara en shebang-linje, som börjar med #! :

#!/usr/bin/python

Om du befinner dig i en virtuell miljö, kommer python myscript.py att använda Python från din virtuella miljö, men ./myscript.py kommer att använda Python-tolk i #! linje. För att se till att den virtuella miljöns Python används ändrar du den första raden till:

#!/usr/bin/env python

Kom ihåg att ge exekverande behörigheter till skriptet när du har angett shebanglinjen genom att göra:

chmod +x myscript.py

Genom att göra detta kan du köra skriptet genom att köra ./myscript.py (eller ge den absoluta sökvägen till skriptet) istället för python myscript.py eller python3 myscript.py .

Använda virtualenv med fiskskal

Fiskskal är vänligare men du kanske stöter på problem när du använder med virtualenv eller virtualenvwrapper . Alternativt finns virtualfish för att rädda. Följ bara sekvensen nedan för att börja använda Fish shell med virtualenv.

• Installera virtualfish i det globala utrymmet

   sudo pip install virtualfish
  

• Ladda Python-modulen virtuell fisk under fiskskalens start

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

• Redigera denna funktion fish_prompt av $ funced fish_prompt --editor vim och lägg till raderna nedan och stäng vim-redigeraren

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

  Obs: Om du inte känner till vim, leverera helt enkelt din favoritredigerare som denna $ funced fish_prompt --editor nano eller $ funced fish_prompt --editor gedit

• Spara ändringar med funcsave

   funcsave fish_prompt
  

• För att skapa en ny virtuell miljö, använd vf new

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

• Om du vill skapa en ny python3-miljö anger du den via -p flaggan

   vf new -p python3 my_new_env
  

• För att växla mellan virtuella miljöer, använd vf deactivate & vf activate another_env

Officiella länkar:

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

Skapa virtuella miljöer med Anaconda

Ett kraftfullt alternativ till virtualenv är Anaconda - ett plattformsoberoende, pip -liknande pakethanterare levereras med funktioner för att snabbt ringa och ta bort virtuella miljöer. Efter installation av Anaconda, här är några kommandon för att komma igång:

Skapa en miljö

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

där <envname> i ett godtyckligt namn för din virtuella miljö, och <version> är en specifik Python-version som du vill ställa in.

Aktivera och inaktivera din miljö

# Linux, Mac
source activate <envname>                            
source deactivate

eller

# Windows
activate <envname>                                    
deactivate

Visa en lista över skapade miljöer

conda env list

Ta bort en miljö

conda env remove -n <envname>

Hitta fler kommandon och funktioner i den officiella conda-dokumentationen .

Kontrollera om det körs i en virtuell miljö

Ibland visar shell-prompten inte namnet på den virtuella miljön och du vill vara säker på om du befinner dig i en virtuell miljö eller inte.

Kör pytontolkaren och försök:

import sys
sys.prefix
sys.real_prefix

• Utanför en virtuell sys.prefix miljö sys.prefix på systemets sys.real_prefix och sys.real_prefix är inte definierat.

• Inuti en virtuell miljö kommer sys.prefix att peka på den virtuella miljön sys.real_prefix och sys.real_prefix pekar på systempythoninstallationen.

För virtuella miljöer skapade med standardbibliotek venv-modulen finns det ingen sys.real_prefix . Kontrollera istället om sys.base_prefix är densamma som sys.prefix .