Python Language
Entornos virtuales

Introducción

Observaciones

Creando y utilizando un entorno virtual.

virtualenv es una herramienta para construir entornos Python aislados. Este programa crea una carpeta que contiene todos los ejecutables necesarios para usar los paquetes que un proyecto de Python necesitaría.

Instalando la herramienta virtualenv

Esto solo se requiere una vez. El programa virtualenv puede estar disponible a través de su distribución. En las distribuciones similares a Debian, el paquete se llama python-virtualenv o python3-virtualenv .

Alternativamente, puede instalar virtualenv usando pip :

$ pip install virtualenv

Creando un nuevo entorno virtual.

Esto solo se requiere una vez por proyecto. Al iniciar un proyecto para el que desea aislar dependencias, puede configurar un nuevo entorno virtual para este proyecto:

$ virtualenv foo

Esto creará una carpeta foo contiene scripts de herramientas y una copia del propio binario de python . El nombre de la carpeta no es relevante. Una vez que se crea el entorno virtual, es autónomo y no requiere más manipulación con la herramienta virtualenv . Ahora puedes empezar a utilizar el entorno virtual.

Activando un entorno virtual existente

Para activar un entorno virtual, se requiere algo de shell magic, por lo que su Python es el que está dentro de foo lugar del sistema. Este es el propósito del archivo de activate , que debe fuente en su shell actual:

$ source foo/bin/activate

Los usuarios de Windows deben escribir:

$ foo\Scripts\activate.bat

Una vez que se ha activado un entorno virtual, los archivos binarios de python y pip y todos los scripts instalados por módulos de terceros son los que están dentro de foo . En particular, todos los módulos instalados con pip se implementarán en el entorno virtual, lo que permite un entorno de desarrollo contenido. La activación del entorno virtual también debe agregar un prefijo a su solicitud como se ve en los siguientes comandos.

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

Guardar y restaurar dependencias.

Para guardar los módulos que ha instalado a través de pip , puede enumerar todos esos módulos (y las versiones correspondientes) en un archivo de texto usando el comando freeze . Esto permite a otros instalar rápidamente los módulos de Python necesarios para la aplicación mediante el comando de instalación. El nombre convencional para tal archivo es requirements.txt :

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

Tenga en cuenta que la freeze enumera todos los módulos, incluidas las dependencias transitivas requeridas por los módulos de nivel superior que instaló manualmente. Como tal, es posible que prefieren elaborar el requirements.txt archivo a mano , por poner sólo los módulos de alto nivel que necesita.

Salir de un entorno virtual.

Si ha terminado de trabajar en el entorno virtual, puede desactivarlo para volver a su shell normal:

(foo)$ deactivate

Usando un entorno virtual en un host compartido

A veces no es posible $ source bin/activate un virtualenv, por ejemplo, si está utilizando mod_wsgi en un host compartido o si no tiene acceso a un sistema de archivos, como en Amazon API Gateway o Google AppEngine. Para esos casos, puede implementar las bibliotecas que instaló en su virtualenv local y parchear su sys.path .

Luckly virtualenv viene con un script que actualiza tanto su sys.path como su 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))

Debe agregar estas líneas al principio del archivo que ejecutará su servidor.

Encontrará el archivo bin/activate_this.py virtualenv que virtualenv creó en el mismo directorio que está ejecutando y agregará lib/python2.7/site-packages a sys.path

Si usted está buscando para utilizar el activate_this.py guión, recuerde que debe desplegar con, al menos, el bin y lib/python2.7/site-packages directorios y sus contenidos.

$ pyvenv foo
$ source foo/bin/activate

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

Instalación de paquetes en un entorno virtual

Una vez que se haya activado su entorno virtual, cualquier paquete que instale ahora se instalará en virtualenv y no de manera global. Por lo tanto, los nuevos paquetes pueden ser sin necesidad de privilegios de root.

Para verificar que los paquetes se están instalando en el virtualenv ejecute el siguiente comando para verificar la ruta del ejecutable que se está utilizando:

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

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

Cualquier paquete que se instale utilizando pip se instalará en el virtualenv en el siguiente directorio:

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

Alternativamente, puede crear un archivo con los paquetes necesarios.

requisitos.txt :

requests==2.10.0

Ejecutando:

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

Instalaré la versión 2.10.0 de las requests paquetes.

También puede obtener una lista de los paquetes y sus versiones instaladas actualmente en el entorno virtual activo:

# 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

Alternativamente, no tiene que activar su entorno virtual cada vez que tenga que instalar un paquete. Puede usar directamente el ejecutable pip en el directorio del entorno virtual para instalar paquetes.

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

Puede encontrar más información sobre el uso de pip en el tema PIP .

Dado que está instalando sin root en un entorno virtual, esto no es una instalación global en todo el sistema: el paquete instalado solo estará disponible en el entorno virtual actual.

Creando un entorno virtual para una versión diferente de python

Suponiendo que python y python3 estén instalados, es posible crear un entorno virtual para Python 3, incluso si python3 no es el Python predeterminado:

virtualenv -p python3 foo

o

virtualenv --python=python3 foo   

o

python3 -m venv foo

o

pyvenv foo

En realidad, puede crear un entorno virtual basado en cualquier versión de Python en funcionamiento de su sistema. Puede consultar diferentes python de trabajo en /usr/bin/ o /usr/local/bin/ (En Linux) O en /Library/Frameworks/Python.framework/Versions/XX/bin/ (OSX), luego descifre la --python y usa eso en la --python o -p al crear un entorno virtual.

Gestionar múltiples entornos virtuales con virtualenvwrapper

La utilidad virtualenvwrapper simplifica el trabajo con entornos virtuales y es especialmente útil si está tratando con muchos proyectos / entornos virtuales.

En lugar de tener que lidiar con los directorios del entorno virtual, virtualenvwrapper administra por usted, almacenando todos los entornos virtuales en un directorio central ( ~/.virtualenvs por defecto).

Instalación

Instale virtualenvwrapper con el administrador de paquetes de su sistema.

Basado en Debian / Ubuntu:

apt-get install virtualenvwrapper

Fedora / CentOS / RHEL:

yum install python-virtualenvrwapper

Arch Linux:

pacman -S python-virtualenvwrapper

O instálalo desde PyPI usando pip :

pip install virtualenvwrapper

Bajo Windows, puedes usar virtualenvwrapper-win o virtualenvwrapper-powershell en virtualenvwrapper-powershell lugar.

Uso

Los entornos virtuales se crean con mkvirtualenv . Todos los argumentos del comando virtualenv original también son aceptados.

mkvirtualenv my-project

o por ejemplo

mkvirtualenv --system-site-packages my-project

El nuevo entorno virtual se activa automáticamente. En nuevos shells puede habilitar el entorno virtual con workon

workon my-project

La ventaja del comando workon comparado con el tradicional . path/to/my-env/bin/activate es que el comando workon funcionará en cualquier directorio; no tiene que recordar en qué directorio está almacenado el entorno virtual particular de su proyecto.

Directorios de proyectos

Incluso puede especificar un directorio de proyecto durante la creación del entorno virtual con la opción -a o más adelante con el comando setvirtualenvproject .

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

o

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

La configuración de un proyecto hará que el comando workon cambie al proyecto automáticamente y habilite el comando cdproject que le permite cambiar al directorio del proyecto.

Para ver una lista de todos los virtualenvs gestionados por virtualenvwrapper, use lsvirtualenv .

Para eliminar un virtualenv, use rmvirtualenv :

rmvirtualenv my-project

Cada virtualenv administrado por virtualenvwrapper incluye 4 scripts de bash vacíos: preactivate , postactivate , predeactivate y postdeactivate . Estos sirven como enlaces para ejecutar comandos bash en ciertos puntos del ciclo de vida de virtualenv; por ejemplo, cualquier comando en el script postactivate se ejecutará justo después de que se active virtualenv. Este sería un buen lugar para establecer variables de entorno especiales, alias o cualquier otra cosa relevante. Los 4 scripts se encuentran en .virtualenvs/<virtualenv_name>/bin/ .

Para más detalles lea la documentación de virtualenvwrapper .

Descubrir qué entorno virtual está utilizando

Si está utilizando el indicador de bash predeterminado en Linux, debería ver el nombre del entorno virtual al inicio de su indicador.

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

Especificando la versión específica de Python para usar en el script en Unix / Linux

Para especificar qué versión de python el shell de Linux debe usar, la primera línea de scripts de Python puede ser una línea shebang, que comienza con #! :

#!/usr/bin/python

Si está en un entorno virtual, entonces python myscript.py Python usará Python de su entorno virtual, pero ./myscript.py usará el intérprete de Python en el #! línea. Para asegurarse de que se utiliza Python del entorno virtual, cambie la primera línea a:

#!/usr/bin/env python

Después de especificar la línea shebang, recuerde dar permisos de ejecución al script haciendo lo siguiente:

chmod +x myscript.py

Hacer esto le permitirá ejecutar el script ejecutando ./myscript.py (o proporcionará la ruta absoluta al script) en lugar de python myscript.py o python3 myscript.py .

Usando virtualenv con cáscara de pescado

Fish Shell es más amigable, pero es posible que tengas problemas al usar virtualenv o virtualenvwrapper . Alternativamente existe el virtualfish para el rescate. Simplemente siga la secuencia a continuación para comenzar a usar Fish Shell con virtualenv.

• Instalar virtualfish en el espacio global

   sudo pip install virtualfish
  

• Cargue el módulo virtual de python durante el inicio de shell de peces.

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

• Edite esta función fish_prompt con $ funced fish_prompt --editor vim y agregue las líneas siguientes y cierre el editor vim

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

  Nota: Si no está familiarizado con vim, simplemente suministre a su editor favorito como este $ funced fish_prompt --editor nano o $ funced fish_prompt --editor gedit

• Guardar cambios utilizando funcsave

   funcsave fish_prompt
  

• Para crear un nuevo entorno virtual usa vf new

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

• Si desea crear un nuevo entorno python3, especifíquelo mediante el indicador -p

   vf new -p python3 my_new_env
  

• Para cambiar entre entornos virtuales, use vf deactivate y vf activate another_env

Enlaces oficiales:

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

Realización de entornos virtuales utilizando Anaconda.

Una poderosa alternativa a virtualenv es Anaconda : un administrador de paquetes multiplataforma, similar a pip , con características para crear y eliminar rápidamente entornos virtuales. Después de instalar Anaconda, aquí hay algunos comandos para comenzar:

Crear un entorno

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

donde <envname> en un nombre arbitrario para su entorno virtual, y <version> es una versión específica de Python que desea configurar.

Activa y desactiva tu entorno.

# Linux, Mac
source activate <envname>                            
source deactivate

o

# Windows
activate <envname>                                    
deactivate

Ver una lista de entornos creados.

conda env list

Eliminar un entorno

conda env remove -n <envname>

Encuentra más comandos y características en la documentación oficial de conda .

Comprobando si se ejecuta dentro de un entorno virtual

A veces, el indicador de comandos de la shell no muestra el nombre del entorno virtual y quiere estar seguro de si está en un entorno virtual o no.

Ejecuta el intérprete de python y prueba:

import sys
sys.prefix
sys.real_prefix

• Fuera de un entorno virtual, sys.prefix apuntará a la instalación de python del sistema y sys.real_prefix no está definido.

• Dentro de un entorno virtual, sys.prefix apuntará a la instalación de python del entorno virtual y sys.real_prefix apuntará a la instalación de python del sistema.

Para los entornos virtuales creados con el módulo venv de la biblioteca estándar , no hay sys.real_prefix . En su lugar, compruebe si sys.base_prefix es el mismo que sys.prefix .