El uso de diferentes versiones de Python con virtualenv

https://stackoverflow.com/questions/1534210

20-09-2019
|

Pregunta

Tengo un sistema Debian ejecutando actualmente con python 2.5.4.Tengo virtualenv correctamente instalado, todo está funcionando bien.Existe una posibilidad de que yo pueda usar un virtualenv con una versión diferente de Python?

He compilado Python 2.6.2 y quisiera usarlo con algunos virtualenv.Es suficiente para sobrescribir el archivo binario?O tengo que cambiar algo en el respeto a las bibliotecas?

Solución

Sólo tiene que utilizar la opción --python (o -p corta) al crear la instancia virtualenv para especificar el ejecutable de Python que desea utilizar, por ejemplo:.

virtualenv --python=/usr/bin/python2.6 <path/to/new/virtualenv/>

N.B. Para Python 3.3 o posterior, consulte responder a continuación.

Otros consejos

ACTUALIZACIÓN: Para Python3.6, el guión pyvenv a continuación está en desuso. En lugar, virtual de los Documentos de Python sugieren crear el entorno virtual con el comando siguiente:

python3 -m venv <myenvname>

Para python3 (3.3+), utilice el método anterior o la guión comando pyvenv

pyvenv /path/to/new/virtual/environment

Tenga en cuenta que venv no permite la creación de virtualenv con otras versiones de Python. Para ello, instalar y utilizar el paquete de virtualenv .

Estos son pasos cuando se está en entorno de alojamiento compartido y se necesita instalar o complie Python desde la fuente y luego crear Venv de su versión de Python. Para Python 2.7.9 que haría algo como lo siguiente:

mkdir ~/src
wget http://www.python.org/ftp/python/2.7.9/Python-2.7.9.tgz
tar -zxvf Python-2.7.9.tgz
cd Python-2.7.9
mkdir ~/.localpython
./configure --prefix=$HOME/.localpython
make
make install

env virtuales

cd ~/src
wget https://pypi.python.org/packages/5c/79/5dae7494b9f5ed061cff9a8ab8d6e1f02db352f3facf907d9eb614fb80e9/virtualenv-15.0.2.tar.gz#md5=0ed59863994daf1292827ffdbba80a63
tar -zxvf virtualenv-15.0.2.tar.gz
cd virtualenv-15.0.2/
~/.localpython/bin/python setup.py install
virtualenv ve -p $HOME/.localpython/bin/python2.7
source ve/bin/activate

Por supuesto esto puede ser aplicable a cualquier situación en la que desea replicar el ambiente exacto que trabaja y desplegar sucesivamente.

virtualenv --python=/usr/bin/python2.6 <path/to/myvirtualenv>

Hay una manera más fácil,

virtualenv venv --python=python2.7

Gracias a un comentario, esto sólo funciona si tiene instalado python2.7 a nivel del sistema (por ejemplo /usr/bin/python2.7).

De lo contrario, si está utilizando homebrew puede utilizar el camino para darle lo que quiere.

virtualenv venv --python=/usr/local/bin/python

Puede encontrar el camino a su instalación de Python con

which python

Esto también funciona con Python 3.

which python3
>> /usr/local/bin/python3
virtualenv venv --python=/usr/local/bin/python3

En última instancia condensación a:

virtualenv venv -p `which python`
virtualenv venv -p `which python3`

En Windows para mí esto funciona:

virtualenv --python=c:\Python25\python.exe envname

sin la python.exe llegué WindowsError: [Error 5] Access is denied He instalado Python2.7.1 con virtualenv 1.6.1, y quería Python 2.5.2.

Mac OS X 10.6.8 (Snow Leopard):

1) Al hacer pip install virtualenv, el comando pip se asocia con una de sus versiones de Python, y virtualenv se instala en esa versión del pitón. Usted puede hacer

 $ which pip

para ver qué versión de Python que es. Si ves algo como:

 $ which pip
 /usr/local/bin/pip

a continuación, hacer:

$ ls -al /usr/local/bin/pip
lrwxrwxr-x  1 root  admin  65 Apr 10  2015 /usr/local/bin/pip ->
../../../Library/Frameworks/Python.framework/Versions/2.7/bin/pip

Se puede ver la versión de Python en la salida.

Por defecto, que será la versión de Python que se utiliza para cualquier nuevo entorno se crea. Sin embargo, puede especificar cualquier versión de Python instalado en su ordenador para utilizar dentro de un nuevo entorno con el -p flag:

$ virtualenv -p python3.2 my_env  
Running virtualenv with interpreter /usr/local/bin/python3.2  
New python executable in my_env/bin/python  
Installing setuptools, pip...done.

virtualenv my_env creará una carpeta en el directorio actual, que contendrá los archivos ejecutables de Python, y una copia del PIP [Comando] que se puede utilizar para instalar otros paquetes.

http://docs.python-guide.org/en/ última / dev / virtualenvs /

virtualenv sólo copias pitón de una ubicación en el equipo en el my_env / bin / directorio recién creado.

2) La pitón sistema está en /usr/bin, mientras que las diferentes versiones de pitón he instalado eran, por defecto, instalado en:

 /usr/local/bin

3) Los diversos pitones he instalado tienen nombres como python2.7 o python3.2, y puedo usar esos nombres en lugar de rutas completas.

======== virtualenvwrapper =========

1) que tenía algunos problemas para conseguir virtualenvwrapper a trabajar. Esto es lo que acabó poniendo en ~/.bash_profile:

export WORKON_HOME=$HOME/.virtualenvs
export PROJECT_HOME=$HOME/django_projects  #Not very important -- mkproject command uses this
#Added the following based on: 
#http://stackoverflow.com/questions/19665327/virtualenvwrapper-installation-snow-leopard-python
export VIRTUALENVWRAPPER_PYTHON=/usr/local/bin/python2.7 
#source /usr/local/bin/virtualenvwrapper.sh
source /Library/Frameworks/Python.framework/Versions/2.7/bin/virtualenvwrapper.sh

2) El -p option funciona de forma diferente con virtualenvwrapper: Tengo que especificar la ruta completa al intérprete de Python para ser utilizado en el nuevo entorno (cuando no quiero utilizar la versión de Python por defecto):

$ mkvirtualenv -p /usr/local/bin/python3.2 my_env
Running virtualenv with interpreter /usr/local/bin/python3
New python executable in my_env/bin/python
Installing setuptools, pip...done.
Usage: source deactivate

removes the 'bin' directory of the environment activated with 'source
activate' from PATH.

A diferencia de virtualenv, virtualenvwrapper va a crear el ambiente en el lugar especificado por la variable de entorno $ WORKON_HOME. Eso mantiene todas sus entornos en un solo lugar.

Supongamos que actualmente tiene Python 2.7 instalado en su virtualenv. Pero que desee hacer uso de python3.2, Usted tendría que actualizar esto con:

$ virtualenv --python=/usr/bin/python3.2 name_of_your_virtualenv

A continuación, activar su virtualenv por:

$ source activate name_of_your_virtualenv

y luego hacer: python --version con cáscara para comprobar si su versión se ha actualizado

Estos dos comandos debería funcionar bien.

virtualenv -p python2 myenv (Para python2)

virtualenv -p python3 myenv (Para python3)

Puede llamar virtualenv con la versión de Python que desea. Por ejemplo:

python3 -m virtualenv venv

O, alternativamente, que apunte directamente a la ruta virtualenv. p.ej. para Windows:

c:\Python34\Scripts\virtualenv.exe venv

Y ejecutando:

venv/bin/python

Python 3.5.1 (v3.5.1:37a07cee5969, Dec  5 2015, 21:12:44) 
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>>

se puede ver la versión Python instalado en el entorno virtual

El enfoque -p funciona bien, pero usted tiene que acordarse de usarlo cada vez. Si su objetivo es cambiar a una versión más reciente de Python en general, eso es un dolor y también puede conducir a errores.

Su otra opción es establecer una variable de entorno que hace lo mismo que -p. Establecer esto a través de su archivo ~/.bashrc o donde sea a manejar las variables de entorno para sus sesiones de inicio de sesión:

export VIRTUALENV_PYTHON=/path/to/desired/version

A continuación, virtualenv usarán que cada vez que no se especifica -p en la línea de comandos.

Para Mac (High Sierra), instale el virtualenv en python3 y crear un virtualenv para python2:

 $ python3 -m pip install virtualenv
 $ python3 -m virtualenv --python=python2 vp27
 $ source vp27/bin/activate
 (vp27)$ python --version
 Python 2.7.14

Aún más fácil, mediante el uso de sustitución de comandos para encontrar python2 para usted:

virtualenv -p $(which python2) <path/to/new/virtualenv/>

O cuando se utiliza virtualenvwrapper:

mkvirtualenv -p $(which python2) <env_name>

En el Mac utilizo pyenv y virtualenvwrapper. Tuve que crear una nueva virtualenv. Es necesario homebrew, que voy a suponer que haya instalado, si estás en un Mac, pero sólo por diversión:

ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"


brew install pyenv
pyenv install 2.7.10
pyenv global 2.7.10
export PATH=/Users/{USERNAME}/.pyenv/versions/2.7.10/bin:$PATH
mkvirtualenv -p ~/.pyenv/versions/2.7.10/bin/python  {virtual_env_name}

También se congeló mis necesidades primero, así que podría simplemente volver a instalar en la nueva virtualenv con:

pip install -r requirements.txt

En subsistema de ventanas para Linux:

Crea ambiente para python3:

virtualenv --python=/usr/bin/python3 env

Activar que:
```
source env/bin/activate
```

Sí, las respuestas anteriores es correcta y funciona correctamente en los sistemas basados en Unix como Linux & MAC OS X.

Traté de crear virtualenv para Python2 & Python3 con los siguientes comandos.

Aquí he utilizado venv2 & venv3 como sus nombres para Python2 & Python3 respectivamente.

Python2 "

MacBook-Pro-2:~ admin$ virtualenv venv2 --python=`which python2`
Running virtualenv with interpreter /usr/local/bin/python2
New python executable in /Users/admin/venv2/bin/python
Installing setuptools, pip, wheel...done.
MacBook-Pro-2:~ admin$ 
MacBook-Pro-2:~ admin$ ls venv2/bin/
activate        easy_install        pip2.7          python2.7
activate.csh        easy_install-2.7    python          wheel
activate.fish       pip         python-config
activate_this.py    pip2            python2
MacBook-Pro-2:~ admin$

Python3 "

MacBook-Pro-2:~ admin$ virtualenv venv3 --python=`which python3`
Running virtualenv with interpreter /usr/local/bin/python3
Using base prefix '/Library/Frameworks/Python.framework/Versions/3.6'
New python executable in /Users/admin/venv3/bin/python3
Also creating executable in /Users/admin/venv3/bin/python
Installing setuptools, pip, wheel...done.
MacBook-Pro-2:~ admin$ 
MacBook-Pro-2:~ admin$ ls venv3/bin/
activate        easy_install        pip3.6          python3.6
activate.csh        easy_install-3.6    python          wheel
activate.fish       pip         python-config
activate_this.py    pip3            python3
MacBook-Pro-2:~ admin$

Comprobación de la instalación de Python ubicaciones

MacBook-Pro-2:~ admin$ which python2
/usr/local/bin/python2
MacBook-Pro-2:~ admin$ 
MacBook-Pro-2:~ admin$ which python3
/usr/local/bin/python3
MacBook-Pro-2:~ admin$

Funcionó para mí

sudo apt-get install python3-minimal

virtualenv --no-site-packages --distribute -p /usr/bin/python3 ~/.virtualenvs/py3

En las ventanas:

py -3.4x32 -m venv venv34

py -2.6.2 -m venv venv26

Se utiliza el href="https://docs.python.org/3/using/windows.html#launcher" rel="nofollow noreferrer"> py lanzador

virtualenv -p python3 myenv

Enlace a la creación de virtualenv

Para Debian (debian 9) Systems en 2019, he descubierto una solución simple que puede resolver el problema desde dentro del entorno virtual.

Supongamos que el entorno virtual se crearon a través de:

python3.7 -m venv myenv

pero sólo tiene versiones de python2 y python2.7, y necesita las características de los últimos python3.7.

A continuación, sólo tiene que ejecutar el comando:

(myvenv) $ python3.7 -m venv --upgrade /home/username/path/to/myvenv/

agregará paquetes python3.7 si ya están disponibles en el sistema.

Esto fue un error con virtualenv. Sólo la actualización de su PIP debe ser el punto de referencia.

pip install --upgrade virtualenv

Se trabajó para mí en ventanas con la instalación de Python 2:

Paso 1: instalar Python 3 versión.
Paso 2: crear una carpeta para el env el entorno virtual.
Paso 3: c: \ Python37 \ python -m Venv c:. \ ruta \ a \ env

Esta es la forma en que creé Python 3 entorno virtual en mi instalación existente pitón 2.

pyenv para gestionar mi versión pitón.

pyenv install 3.7.3
pyenv local 3.7.3

Para comprobar la versión de Python:

$ python --version
Python 3.7.3

Cree el entorno virtual con Venv :

python -m venv .

A continuación, active el entorno virtual:

source bin/activate

Para comprobar la versión de Python:

$ python --version
Python 3.7.3

Es posible que tenga que quitar el entorno virtual anterior

rm -rf bin

Puede hacerlo al hacer esto:

virtualenv -p python3 .

Si sólo tiene que instalar la otra versión de pitón, y definir la ubicación de su otra versión del pitón en su orden como:

virtualenv / home / nómina / Documentos / env -p / usr / bin / python3

Aquí está el stepbystep cómo crear el entorno Virtual en el Código de Visual Studio carpeta:He utilizado Powershell (modo Administrador):
1.Puedo crear un VSCode carpeta - "D:\Code_Python_VE" cuando quiero crear un entorno Virtual.
2.Lo siguiente que escriba el comando "pip3 instalar virtualenv".(D:\Code_Python_VE> pip3 instalar virtualenv ) 3.D:\Code_Python_VE> python3 -m venv project_env
4.D:\Code_Python_VE>project_env\secuencias de comandos\activar.bat
5.D:\Code_Python_VE> ls - Esto mostrará una lista de un nuevo directorio "project_env".
6.D:\Code_Python_VE> código .Esto iniciará el Código de Visual Studio.Asegúrese de que el comando es (de código .).
7.Crear lanzamiento.jason con el contenido siguiente:

{
    // Use IntelliSense to learn about possible attributes.
    // Hover to view descriptions of existing attributes.
    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
    "version": "0.2.0",
    "configurations": [
        {
            "type": "python",
            "request": "launch",
            "name": "Python: Current File (Integrated Terminal 1)",
            "program": "${file}"
        },
        {
            "name": "Python: Current File (Integrated Terminal 2)",
            "type": "python",
            "request": "launch",
            "program": "${file}",
            "console": "integratedTerminal"
        },
    ]
}

(Por favor, buscar cómo ir a la ventana de Depuración y Agregar nueva Configuración en el VS de Código).

Pulse F1 en el código de Visual studio y el comando de paleta se abre - Seleccione Intérprete de Python y seleccionar el entorno virtual project_env.
Agregar test.py archivo con una instrucción print("Hola Mundo").
Ejecutar este programa.
En el Código de Visual studio terminal -
(project_env) d:\Code_Python_VE>python -m pip install --actualización
Espero que esto ayude.

Licenciado bajo: CC-BY-SA con atribución

No afiliado a StackOverflow