Python Language
Środowiska wirtualne

Wprowadzenie

Uwagi

Tworzenie i używanie środowiska wirtualnego

virtualenv to narzędzie do budowania izolowanych środowisk Python. Ten program tworzy folder zawierający wszystkie pliki wykonywalne niezbędne do korzystania z pakietów potrzebnych projektowi Python.

Instalowanie narzędzia virtualenv

Jest to wymagane tylko raz. Program virtualenv może być dostępny za pośrednictwem Twojej dystrybucji. W dystrybucjach podobnych do Debiana pakiet nazywa się python-virtualenv lub python3-virtualenv .

Alternatywnie możesz zainstalować virtualenv za pomocą pip :

$ pip install virtualenv

Tworzenie nowego środowiska wirtualnego

Wymagało to tylko raz na projekt. Podczas uruchamiania projektu, dla którego chcesz wyodrębnić zależności, możesz skonfigurować nowe środowisko wirtualne dla tego projektu:

$ virtualenv foo

Spowoduje to utworzenie folderu foo zawierającego skrypty narzędziowe i kopię samego pliku binarnego python . Nazwa folderu nie jest istotna. Po utworzeniu środowiska wirtualnego jest ono samoistne i nie wymaga dalszej manipulacji za pomocą narzędzia virtualenv . Możesz teraz zacząć korzystać ze środowiska wirtualnego.

Aktywacja istniejącego środowiska wirtualnego

Aby aktywować środowisko wirtualne, wymagana jest trochę magii powłoki, więc Python jest tym wewnątrz foo zamiast systemowym. Jest to celem pliku activate , który musisz zdobyć w swojej bieżącej powłoce:

$ source foo/bin/activate

Użytkownicy systemu Windows powinni wpisać:

$ foo\Scripts\activate.bat

Po aktywacji środowiska wirtualnego, pliki binarne python i pip oraz wszystkie skrypty instalowane przez moduły stron trzecich są tymi wewnątrz foo . W szczególności wszystkie moduły zainstalowane z pip zostaną wdrożone w środowisku wirtualnym, umożliwiając zamknięte środowisko programistyczne. Aktywacja środowiska wirtualnego powinna również dodać przedrostek do pytania, jak pokazano w poniższych poleceniach.

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

Zapisywanie i przywracanie zależności

Aby zapisać moduły zainstalowane przez pip , możesz wyświetlić wszystkie te moduły (i odpowiadające im wersje) w pliku tekstowym za pomocą polecenia freeze . Dzięki temu inni mogą szybko zainstalować moduły Python potrzebne do aplikacji za pomocą komendy install. Tradycyjna nazwa takiego pliku to requirements.txt :

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

Pamiętaj, że freeze wyświetla wszystkie moduły, w tym zależności przechodnie wymagane przez ręcznie zainstalowane moduły najwyższego poziomu. W związku z tym możesz ręcznie requirements.txt plik requirements.txt , umieszczając tylko potrzebne moduły najwyższego poziomu.

Wyjście ze środowiska wirtualnego

Jeśli zakończysz pracę w środowisku wirtualnym, możesz go dezaktywować, aby wrócić do normalnej powłoki:

(foo)$ deactivate

Korzystanie ze środowiska wirtualnego we współdzielonym hoście

Czasami nie jest możliwe $ source bin/activate virtualenv, na przykład, jeśli używasz mod_wsgi na współdzielonym hoście lub jeśli nie masz dostępu do systemu plików, takiego jak Amazon API Gateway lub Google AppEngine. W takich przypadkach możesz wdrożyć biblioteki zainstalowane w lokalnej virtualenv i załatać sys.path .

Na szczęście virtualenv jest dostarczany ze skryptem, który aktualizuje zarówno sys.path i 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))

Powinieneś dołączyć te linie na samym początku pliku, który wykona twój serwer.

Znajduje bin/activate_this.py virtualenv który utworzył plik virtualenv w tym samym katalogu, który wykonujesz, i dodaje twój lib/python2.7/site-packages sys.path

Jeśli szukasz używać activate_this.py skrypt, należy pamiętać, aby wdrożyć się przynajmniej na bin i lib/python2.7/site-packages katalogów i ich zawartości.

$ pyvenv foo
$ source foo/bin/activate

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

Instalowanie pakietów w środowisku wirtualnym

Po aktywacji środowiska wirtualnego każdy pakiet, który instalujesz, będzie teraz instalowany w virtualenv nie globalnie. Dlatego nowe pakiety mogą być pozbawione uprawnień roota.

Aby sprawdzić, czy pakiety są instalowane w virtualenv uruchom następującą komendę, aby sprawdzić ścieżkę używanego pliku wykonywalnego:

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

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

Dowolny pakiet następnie zainstalowany za pomocą pip zostanie zainstalowany w samym virtualenv w następującym katalogu:

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

Alternatywnie możesz utworzyć plik z listą potrzebnych pakietów.

wymagania.txt :

requests==2.10.0

Wykonywanie:

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

zainstaluje wersję 2.10.0 requests pakietów.

Możesz również uzyskać listę pakietów i ich wersji aktualnie zainstalowanych w aktywnym środowisku wirtualnym:

# 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

Alternatywnie nie musisz aktywować środowiska wirtualnego za każdym razem, gdy musisz zainstalować pakiet. Możesz bezpośrednio użyć pliku wykonywalnego pip w katalogu środowiska wirtualnego, aby zainstalować pakiety.

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

Więcej informacji na temat korzystania z pip można znaleźć na temat PIP .

Ponieważ instalujesz bez roota w środowisku wirtualnym, nie jest to instalacja globalna w całym systemie - zainstalowany pakiet będzie dostępny tylko w bieżącym środowisku wirtualnym.

Tworzenie środowiska wirtualnego dla innej wersji Pythona

Zakładając, że zarówno python i python3 są zainstalowane, możliwe jest utworzenie wirtualnego środowiska dla Pythona 3, nawet jeśli python3 nie jest domyślnym Pythonem:

virtualenv -p python3 foo

lub

virtualenv --python=python3 foo   

lub

python3 -m venv foo

lub

pyvenv foo

W rzeczywistości możesz stworzyć środowisko wirtualne w oparciu o dowolną wersję działającego Pythona w twoim systemie. Możesz sprawdzić różne działające pytony pod /usr/bin/ lub /usr/local/bin/ (w systemie Linux) LUB w /Library/Frameworks/Python.framework/Versions/XX/bin/ (OSX), a następnie wymyśl nazwij i użyj tego w --python lub -p podczas tworzenia środowiska wirtualnego.

Zarządzanie wieloma środowiskami wirtualnymi za pomocą virtualenvwrapper

Narzędzie virtualenvwrapper upraszcza pracę ze środowiskami wirtualnymi i jest szczególnie przydatne w przypadku wielu środowisk / projektów wirtualnych.

Zamiast samodzielnie zajmować się katalogami środowiska wirtualnego, virtualenvwrapper zarządza nimi za Ciebie, przechowując wszystkie środowiska wirtualne w centralnym katalogu (domyślnie ~/.virtualenvs ).

Instalacja

Zainstaluj virtualenvwrapper pomocą menedżera pakietów systemu.

Oparte na Debianie / Ubuntu:

apt-get install virtualenvwrapper

Fedora / CentOS / RHEL:

yum install python-virtualenvrwapper

Arch Linux:

pacman -S python-virtualenvwrapper

Lub zainstaluj go z PyPI przy użyciu pip :

pip install virtualenvwrapper

W systemie Windows można zamiast tego użyć virtualenvwrapper-win lub virtualenvwrapper-powershell .

Stosowanie

Środowiska wirtualne są tworzone za pomocą mkvirtualenv . Wszystkie argumenty oryginalnej komendy virtualenv są również akceptowane.

mkvirtualenv my-project

lub np

mkvirtualenv --system-site-packages my-project

Nowe środowisko wirtualne zostanie aktywowane automatycznie. W nowych powłokach możesz włączyć środowisko wirtualne za pomocą workon

workon my-project

Zaleta polecenia workon porównaniu z tradycyjnym . path/to/my-env/bin/activate workon to, że polecenie workon będzie działać w dowolnym katalogu; nie musisz pamiętać, w którym katalogu przechowywane jest określone środowisko wirtualne twojego projektu.

Katalogi projektów

Możesz nawet określić katalog projektu podczas tworzenia środowiska wirtualnego za pomocą opcji -a lub później za pomocą polecenia setvirtualenvproject .

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

lub

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

Ustawienie projektu spowoduje workon przełączenie polecenia workon na projekt i włączenie polecenia cdproject które umożliwia przejście do katalogu projektu.

Aby zobaczyć listę wszystkich virtualenvs zarządzanych przez virtualenvwrapper, użyj lsvirtualenv .

Aby usunąć virtualenv, użyj rmvirtualenv :

rmvirtualenv my-project

Każdy virtualenv zarządza virtualenvwrapper obejmuje 4 pustych skrypty bash preactivate , postactivate , predeactivate i postdeactivate . Służą one jako zaczepy do wykonywania poleceń bash w określonych punktach cyklu życia virtualenv; na przykład, wszelkie polecenia w skrypcie postactivate będą wykonywane zaraz po aktywacji virtualenv. Byłoby to dobre miejsce do ustawienia specjalnych zmiennych środowiskowych, aliasów lub cokolwiek innego istotnego. Wszystkie 4 skrypty znajdują się w .virtualenvs/<virtualenv_name>/bin/ .

Aby uzyskać więcej informacji, przeczytaj dokumentację virtualenvwrapper .

Odkrywanie używanego środowiska wirtualnego

Jeśli używasz domyślnego monitu bash w Linuksie, powinieneś zobaczyć nazwę środowiska wirtualnego na początku monitu.

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

Określanie konkretnej wersji Pythona do użycia w skrypcie w systemach Unix / Linux

Aby określić, która wersja Pythona powłoka Linux powinna używać pierwszego wiersza skryptów Pythona, może być wierszem shebang, który zaczyna się od #! :

#!/usr/bin/python

Jeśli jesteś w środowisku wirtualnym, to python myscript.py użyje Pythona ze środowiska wirtualnego, ale ./myscript.py użyje interpretera Pythona w #! linia. Aby upewnić się, że używany jest język Python środowiska wirtualnego, zmień pierwszy wiersz na:

#!/usr/bin/env python

Po określeniu linii shebang pamiętaj, aby dać skryptowi uprawnienia do wykonywania, wykonując:

chmod +x myscript.py

Spowoduje to wykonanie skryptu przez uruchomienie ./myscript.py (lub ./myscript.py bezwzględnej ścieżki do skryptu) zamiast python myscript.py lub python3 myscript.py .

Korzystanie z virtualenv z powłoką rybną

Skorupa rybna jest bardziej przyjazna, ale możesz napotkać problemy podczas korzystania z virtualenv lub virtualenvwrapper . Alternatywnie istnieje virtualfish na ratunek. Wystarczy postępować zgodnie z poniższą sekwencją, aby rozpocząć korzystanie z powłoki Fish z virtualenv.

• Zainstaluj virtualfish w globalnej przestrzeni

   sudo pip install virtualfish
  

• Załaduj wirtualną rybę modułu python podczas uruchamiania powłoki ryby

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

• Edytuj tę funkcję fish_prompt przez $ funced fish_prompt --editor vim i dodaj poniższe linie i zamknij edytor vim

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

  Uwaga: Jeśli nie $ funced fish_prompt --editor nano , po prostu podaj swój ulubiony edytor, taki jak $ funced fish_prompt --editor nano lub $ funced fish_prompt --editor gedit

• Zapisz zmiany za pomocą funcsave

   funcsave fish_prompt
  

• Aby utworzyć nowe środowisko wirtualne, użyj vf new

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

• Jeśli chcesz utworzyć nowe środowisko python3, określ je za pomocą opcji -p

   vf new -p python3 my_new_env
  

• Aby przełączać się między środowiskami wirtualnymi, użyj vf deactivate i vf activate another_env

Oficjalne linki:

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

Tworzenie wirtualnych środowisk za pomocą Anacondy

virtualenv alternatywą dla virtualenv jest Anaconda - wieloplatformowy, podobny do pip menedżer pakietów w pakiecie z funkcjami szybkiego tworzenia i usuwania środowisk wirtualnych. Po zainstalowaniu Anacondy, oto kilka poleceń, aby zacząć:

Utwórz środowisko

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

gdzie <envname> w dowolnej nazwie dla środowiska wirtualnego, a <version> jest konkretną wersją <envname> Python, którą chcesz skonfigurować.

Aktywuj i dezaktywuj swoje środowisko

# Linux, Mac
source activate <envname>                            
source deactivate

lub

# Windows
activate <envname>                                    
deactivate

Wyświetl listę utworzonych środowisk

conda env list

Usuń środowisko

conda env remove -n <envname>

Znajdź więcej poleceń i funkcji w oficjalnej dokumentacji conda .

Sprawdzanie, czy działa w środowisku wirtualnym

Czasami monit powłoki nie wyświetla nazwy środowiska wirtualnego i chcesz być pewien, czy jesteś w środowisku wirtualnym, czy nie.

Uruchom interpreter Pythona i spróbuj:

import sys
sys.prefix
sys.real_prefix

• Poza wirtualnym, sys.prefix środowiska sys.prefix instalację systemu w Pythonie, a sys.real_prefix nie jest zdefiniowany.

• W środowisku wirtualnym sys.prefix wskaże instalację środowiska wirtualnego Python, a sys.real_prefix wskaże instalację systemu python.

W środowiskach wirtualnych utworzonych przy użyciu standardowego modułu biblioteki venv nie ma sys.real_prefix . Zamiast tego sprawdź, czy sys.base_prefix jest taki sam jak sys.prefix .