Python Language
Ambienti virtuali

introduzione

Osservazioni

Creazione e utilizzo di un ambiente virtuale

virtualenv è uno strumento per costruire ambienti Python isolati. Questo programma crea una cartella che contiene tutti gli eseguibili necessari per usare i pacchetti necessari a un progetto Python.

Installazione dello strumento virtualenv

Questo è richiesto solo una volta. Il programma virtualenv potrebbe essere disponibile attraverso la tua distribuzione. Nelle distribuzioni di tipo Debian, il pacchetto si chiama python-virtualenv o python3-virtualenv .

In alternativa, puoi installare virtualenv usando pip :

$ pip install virtualenv

Creare un nuovo ambiente virtuale

Questo è richiesto solo una volta per progetto. Quando si avvia un progetto per il quale si desidera isolare le dipendenze, è possibile impostare un nuovo ambiente virtuale per questo progetto:

$ virtualenv foo

Questo creerà una cartella foo contenente script di strumenti e una copia del binario python stesso. Il nome della cartella non è rilevante. Una volta creato l'ambiente virtuale, esso è autonomo e non richiede ulteriori manipolazioni con lo strumento virtualenv . Ora puoi iniziare a utilizzare l'ambiente virtuale.

Attivazione di un ambiente virtuale esistente

Per attivare un ambiente virtuale, è necessario un po 'di shell magica, quindi il tuo Python è quello interno a foo invece di quello di sistema. Questo è lo scopo del file di activate , che è necessario inserire nella shell corrente:

$ source foo/bin/activate

Gli utenti Windows dovrebbero digitare:

$ foo\Scripts\activate.bat

Una volta che un ambiente virtuale è stato attivato, i binari python e pip e tutti gli script installati da moduli di terze parti sono quelli all'interno di foo . In particolare, tutti i moduli installati con pip verranno distribuiti nell'ambiente virtuale, consentendo un ambiente di sviluppo contenuto. L'attivazione dell'ambiente virtuale dovrebbe anche aggiungere un prefisso al prompt come mostrato nei seguenti comandi.

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

Salvataggio e ripristino delle dipendenze

Per salvare i moduli installati tramite pip , è possibile elencare tutti i moduli (e le versioni corrispondenti) in un file di testo utilizzando il comando freeze . Ciò consente ad altri di installare rapidamente i moduli Python necessari per l'applicazione utilizzando il comando install. Il nome convenzionale per tale file è requirements.txt :

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

Si noti che freeze elenca tutti i moduli, comprese le dipendenze transitive richieste dai moduli di livello superiore installati manualmente. Pertanto, potresti preferire creare manualmente il file requirements.txt , mettendo solo i moduli di livello superiore di cui hai bisogno.

Uscita da un ambiente virtuale

Se hai finito di lavorare nell'ambiente virtuale, puoi disattivarlo per tornare alla tua shell normale:

(foo)$ deactivate

Utilizzo di un ambiente virtuale in un host condiviso

A volte non è possibile $ source bin/activate a virtualenv, ad esempio se si utilizza mod_wsgi nell'host condiviso o se non si ha accesso a un file system, come in Amazon API Gateway o Google AppEngine. In questi casi è possibile distribuire le librerie installate nel virtualenv locale e applicare patch a sys.path .

Fortunatamente virtualenv viene fornito con uno script che aggiorna sia il tuo sys.path che il tuo 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))

Dovresti aggiungere queste righe all'inizio del file che il tuo server eseguirà.

Questo troverà il bin/activate_this.py che virtualenv creato il file nella stessa dir che stai eseguendo e aggiungi i tuoi lib/python2.7/site-packages a sys.path

Se stai cercando di utilizzare lo script activate_this.py , ricorda di implementare con, almeno, le directory bin e lib/python2.7/site-packages e il loro contenuto.

$ pyvenv foo
$ source foo/bin/activate

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

Installazione dei pacchetti in un ambiente virtuale

Una volta che il tuo ambiente virtuale è stato attivato, qualsiasi pacchetto che installerai verrà ora installato nel virtualenv e non a livello globale. Quindi, i nuovi pacchetti possono essere senza bisogno di privilegi di root.

Per verificare che i pacchetti vengano installati in virtualenv eseguire il seguente comando per verificare il percorso dell'eseguibile che si sta utilizzando:

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

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

Qualsiasi pacchetto quindi installato usando pip verrà installato nello stesso virtualenv nella seguente directory:

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

In alternativa, puoi creare un file che elenca i pacchetti necessari.

requirements.txt :

requests==2.10.0

Esecuzione:

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

installerà la versione 2.10.0 delle requests del pacchetto.

Puoi anche ottenere un elenco dei pacchetti e delle loro versioni attualmente installati nell'ambiente virtuale attivo:

# 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

In alternativa, non è necessario attivare l'ambiente virtuale ogni volta che si deve installare un pacchetto. È possibile utilizzare direttamente il pip eseguibile nella directory dell'ambiente virtuale per installare i pacchetti.

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

Ulteriori informazioni sull'utilizzo di pip sono disponibili nell'argomento PIP .

Poiché stai installando senza root in un ambiente virtuale, questa non è un'installazione globale, nell'intero sistema: il pacchetto installato sarà disponibile solo nell'attuale ambiente virtuale.

Creazione di un ambiente virtuale per una versione diversa di python

Supponendo che python e python3 siano entrambi installati, è possibile creare un ambiente virtuale per Python 3 anche se python3 non è il Python predefinito:

virtualenv -p python3 foo

o

virtualenv --python=python3 foo   

o

python3 -m venv foo

o

pyvenv foo

In realtà è possibile creare un ambiente virtuale basato su qualsiasi versione di Python funzionante del proprio sistema. Puoi controllare diversi python funzionanti sotto /usr/bin/ o /usr/local/bin/ (in Linux) OPPURE in /Library/Frameworks/Python.framework/Versions/XX/bin/ (OSX), quindi scopri --python e --python flag --python o -p mentre crei un ambiente virtuale.

Gestione di più ambienti virtuali con virtualenvwrapper

L'utilità virtualenvwrapper semplifica il lavoro con gli ambienti virtuali ed è particolarmente utile se hai a che fare con molti ambienti / progetti virtuali.

Invece di dover gestire autonomamente le directory dell'ambiente virtualenvwrapper , virtualenvwrapper gestisce per te, memorizzando tutti gli ambienti virtuali in una directory centrale ( ~/.virtualenvs per impostazione predefinita).

Installazione

Installa virtualenvwrapper con il gestore di pacchetti del tuo sistema.

Debian / Ubuntu-based:

apt-get install virtualenvwrapper

Fedora / CentOS / RHEL:

yum install python-virtualenvrwapper

Arch Linux:

pacman -S python-virtualenvwrapper

Oppure installalo da PyPI usando pip :

pip install virtualenvwrapper

In Windows è possibile utilizzare virtualenvwrapper-win o virtualenvwrapper-powershell .

uso

Gli ambienti virtuali sono creati con mkvirtualenv . Sono accettati anche tutti gli argomenti del comando virtualenv originale.

mkvirtualenv my-project

o ad es

mkvirtualenv --system-site-packages my-project

Il nuovo ambiente virtuale viene attivato automaticamente. Nelle nuove shell è possibile abilitare l'ambiente virtuale con workon

workon my-project

Il vantaggio del comando workon rispetto al tradizionale . path/to/my-env/bin/activate è, che il comando workon funzionerà in qualsiasi directory; non è necessario ricordare in quale directory è memorizzato il particolare ambiente virtuale del progetto.

Directory di progetto

È anche possibile specificare una directory di progetto durante la creazione dell'ambiente virtuale con l'opzione -a o successiva con il comando setvirtualenvproject .

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

o

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

L'impostazione di un progetto farà sì che il comando workon passi automaticamente al progetto e abiliti il ​​comando cdproject che consente di passare alla directory del progetto.

Per visualizzare un elenco di tutti i virtualenv gestiti da virtualenvwrapper, utilizzare lsvirtualenv .

Per rimuovere un virtualenv, utilizzare rmvirtualenv :

rmvirtualenv my-project

Ogni virtualenv gestita da virtualenvwrapper include 4 script di bash vuoti: preactivate , postactivate , predeactivate - postdeactivate e postdeactivate - postdeactivate . Questi servono da hook per l'esecuzione di comandi bash in determinati punti del ciclo di vita del virtualenv; ad esempio, qualsiasi comando nello script postactivate verrà eseguito subito dopo l'attivazione di virtualenv. Questo sarebbe un buon posto per impostare variabili d'ambiente speciali, alias o qualsiasi altra cosa rilevante. Tutti e 4 gli script si trovano sotto .virtualenvs/<virtualenv_name>/bin/ .

Per maggiori dettagli leggi la documentazione di virtualenvwrapper .

Scopri quale ambiente virtuale stai usando

Se stai usando il prompt di bash predefinito su Linux, dovresti vedere il nome dell'ambiente virtuale all'inizio del tuo prompt.

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

Specifica specifica della versione python da usare nello script su Unix / Linux

Per specificare quale versione di Python utilizzare la prima shell di Linux nella prima riga di script Python può essere una riga shebang, che inizia con #! :

#!/usr/bin/python

Se sei in un ambiente virtuale, python myscript.py userà Python dal tuo ambiente virtuale, ma ./myscript.py userà l'interprete Python nel #! linea. Per assicurarti che venga utilizzato Python dell'ambiente virtuale, modifica la prima riga in:

#!/usr/bin/env python

Dopo aver specificato la riga shebang, ricorda di dare le autorizzazioni di esecuzione allo script facendo:

chmod +x myscript.py

In questo modo potrai eseguire lo script eseguendo ./myscript.py (o fornisci il percorso assoluto per lo script) invece di python myscript.py o python3 myscript.py .

Utilizzo di virtualenv con guscio di pesce

Il guscio di pesce è più amichevole eppure potresti incontrare dei problemi mentre usi virtualenv o virtualenvwrapper . In alternativa esiste virtualfish per il salvataggio. Segui la sequenza qui sotto per iniziare a utilizzare Fish Shell con virtualenv.

• Installa virtualfish nello spazio globale

   sudo pip install virtualfish
  

• Carica il modulo virtuale python durante l'avvio della fish shell

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

• Modifica questa funzione fish_prompt di $ funced fish_prompt --editor vim e aggiungi le linee sottostanti e chiudi l'editor di vim

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

  Nota: se non hai familiarità con vim, fornisci semplicemente il tuo editor preferito come $ funced fish_prompt --editor nano o $ funced fish_prompt --editor gedit

• Salva le modifiche usando funcsave

   funcsave fish_prompt
  

• Per creare un nuovo ambiente virtuale usa vf new

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

• Se vuoi creare un nuovo ambiente python3, specificalo tramite -p flag

   vf new -p python3 my_new_env
  

• Per passare da virtualenvironments usa vf deactivate e vf activate another_env

Link ufficiali:

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

Realizzare ambienti virtuali usando Anaconda

Una potente alternativa a virtualenv è Anaconda - un cross-platform, pip direttore -come pacchetto in bundle con le caratteristiche per la produzione e la rimozione di ambienti virtuali in modo rapido. Dopo aver installato Anaconda, ecco alcuni comandi per iniziare:

Crea un ambiente

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

dove <envname> in un nome arbitrario per il tuo ambiente virtuale, e <version> è una specifica versione di Python che desideri configurare.

Attiva e disattiva il tuo ambiente

# Linux, Mac
source activate <envname>                            
source deactivate

o

# Windows
activate <envname>                                    
deactivate

Visualizza un elenco di ambienti creati

conda env list

Rimuovi un ambiente

conda env remove -n <envname>

Trova altri comandi e funzionalità nella documentazione ufficiale di conda .

Verifica se si sta eseguendo all'interno di un ambiente virtuale

A volte il prompt della shell non visualizza il nome dell'ambiente virtuale e vuoi essere sicuro di trovarti in un ambiente virtuale o meno.

Esegui l'interprete python e prova:

import sys
sys.prefix
sys.real_prefix

• Al di fuori di un ambiente virtuale, sys.prefix punta all'installazione di python di sistema e sys.real_prefix non è definito.

• All'interno di un ambiente virtuale, sys.prefix punterà all'installazione python dell'ambiente virtuale e sys.real_prefix punterà all'installazione di python di sistema.

Per gli ambienti virtuali creati utilizzando il modulo venv della libreria standard non esiste sys.real_prefix . Invece, controlla se sys.base_prefix è uguale a sys.prefix .