Actualmente tengo un sistema Debian con Python 2.5.4. Tengo virtualenv correctamente instalado, todo funciona bien. ¿Existe la posibilidad de que pueda usar un virtualenv con una versión diferente de Python?

Compilé Python 2.6.2 y me gustaría usarlo con algo de virtualenv. ¿Es suficiente sobrescribir el archivo binario? ¿O tengo que cambiar algo con respecto a las bibliotecas?

Simplemente use la opción --python(o abreviada -p) al crear su instancia virtualenv para especificar el ejecutable de Python que desea usar, por ejemplo:

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

Nota: para Python 3.3 o posterior, consulte la respuesta de The Aelfinn a continuación.

Desde Python 3, los documentos de Python sugieren crear el entorno virtual con el siguiente comando:

python3 -m venv <myenvname>

Tenga en cuenta que venvno permite crear entornos virtuales con otras versiones de Python. Para eso, instale y use el virtualenv paquete .

Información obsoleta

El pyvenv script se puede usar para crear un entorno virtual.

pyvenv /path/to/new/virtual/environment

pero ha quedado en desuso desde Python 3.6.

Estos son los pasos que puede seguir cuando se encuentra en un entorno de alojamiento compartido y necesita instalar y compilar Python desde el origen y luego crear venvdesde su versión de Python. Para Python 2.7.9. harías algo en este sentido:

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 virtual

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   

Naturalmente, esto puede ser aplicable a cualquier situación en la que desee replicar el entorno exacto en el que trabaja e implementar.

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 solo funciona si tienes instalado python2.7 en el nivel del sistema (por ejemplo, /usr/bin/python2.7).

De lo contrario, si está utilizando homebrew, puede usar la ruta para obtener lo que desea.

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

Puede encontrar la ruta a su instalación de Python con

which python

Esto también funcionará con Python 3.

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

Finalmente condensando 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 el python.exeque tengo WindowsError: [Error 5] Access is denied tengo Python2.7.1 instalado con virtualenv 1.6.1, y quería python 2.5.2.

Mac OSX 10.6.8 (Snow Leopard):

1) Cuando lo hace pip install virtualenv, el comando pip se asocia con una de sus versiones de python y virtualenvse instala en esa versión de python. Tu puedes hacer

 $ which pip   

para ver qué versión de python es esa. Si ves algo como:

 $ which pip
 /usr/local/bin/pip

entonces hazlo:

$ 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

Puede ver la versión de Python en la salida.

De forma predeterminada, esa será la versión de Python que se utilizará para cualquier entorno nuevo que cree. Sin embargo, puede especificar cualquier versión de python instalada en su computadora para usar dentro de un nuevo entorno con -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 puede usar para instalar otros paquetes.

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

virtualenv simplemente copia python desde una ubicación en su computadora al directorio my_env / bin / recién creado.

2) El sistema Python está en funcionamiento /usr/bin, mientras que las diversas versiones de Python que instalé se instalaron de manera predeterminada en:

 /usr/local/bin

3) Las varias pitones que instalé tienen nombres como python2.7o python3.2, y puedo usar esos nombres en lugar de rutas completas.

======== VIRTUALENVWRAPPER =========

1) Tuve algunos problemas para hacer que virtualenvwrapper funcionara. Esto es lo que terminé poniendo ~/.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) -p optionFunciona de manera diferente con virtualenvwrapper: tengo que especificar la ruta completa al intérprete de Python que se utilizará en el nuevo entorno (cuando no quiero usar la versión predeterminada de Python):

$ 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 creará el entorno en la ubicación especificada por la variable de entorno $ WORKON_HOME. Eso mantiene todos sus entornos en un solo lugar.

Estos dos comandos deberían funcionar bien.

virtualenv -p python2 myenv (Para python2)

virtualenv -p python3 myenv (Para python3)

Suponga que actualmente tiene python 2.7 instalado en su virtualenv. Pero si quieres utilizar python3.2, deberías actualizar esto con:

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

Luego active su virtualenv :

$ source activate name_of_your_virtualenv

y luego hazlo: python --versionen shell para verificar si tu versión ahora está actualizada.

Puedes llamar virtualenvcon la versión de python que quieras. Por ejemplo:

python3 -m virtualenv venv

O bien, apunte directamente a su camino virtualenv. por ejemplo para ventanas:

c:\Python34\Scripts\virtualenv.exe venv

Y corriendo:

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.
>>>

puedes ver la versión de python instalada en un entorno virtual

El -penfoque funciona bien, pero debe recordar usarlo siempre. Si su objetivo es cambiar a una versión más nueva 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 haga lo mismo que -p. Establezca esto a través de su ~/.bashrcarchivo o donde sea que administre variables de entorno para sus sesiones de inicio de sesión:

export VIRTUALENV_PYTHON=/path/to/desired/version

Luego virtualenvlo usará en cualquier momento que no especifique -pen la línea de comando.

Aún más fácil, usando la sustitución de comandos para encontrar python2 para usted:

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

O al usar virtualenvwrapper:

mkvirtualenv -p $(which python2) <env_name>

Para Mac (High Sierra), instale virtualenv en python3 y cree 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

En Mac utilizo pyenv y virtualenvwrapper. Tuve que crear un nuevo virtualenv. Necesitas homebrew, que supongo que has instalado si estás en una Mac, pero solo 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 congelé mis requisitos primero para poder simplemente reinstalar en el nuevo virtualenv con:

pip install -r requirements.txt

[Noviembre de 2019] Necesitaba instalar un entorno Python 3.7 (env) en mi sistema Arch Linux basado en Python 3.8. Python 3.7 ya no estaba en el sistema, por lo que no pude degradar Python para instalar un paquete que necesitaba.

Además, quería usar ese paquete / Python 3.7 dentro de un entorno virtual (venv). Así es como lo hice.

Descargue los archivos fuente de la versión Python:

Descargué los archivos fuente Python 3.7.4 de

https://www.python.org/downloads/source/

a

/mnt/Vancouver/apps/python_versions/src/Python-3.7.4.tgz

Luego extraje ese archivo (archivos fuente) a

/mnt/Vancouver/apps/python_versions/src/Python-3.7.4/

Instalación:

[Nota: en mi sistema env, no un venv.]

cd /mnt/Vancouver/apps/python_versions/src/Python-3.7.4/
time ./configure                 ## 17 sec
time make                        ## 1 min 51 sec
time sudo make install           ## 18 sec
time make clean                  ## 0.3 sec

Examine las versiones de Python instaladas:

$ which python
/usr/bin/python

$ python --version
Python 3.8.0

$ which python3.7
/usr/local/bin/python3.7

$ python    ## Python 3.8 [system / env]
Python 3.8.0 (default, Oct 23 2019, 18:51:26) 
[GCC 9.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>

$ python3.7    ## newly-installed Python 3.7 package
Python 3.7.4 (default, Nov 20 2019, 11:36:53) 
[GCC 9.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import sys
>>> print(sys.version)
3.7.4 (default, Nov 20 2019, 11:36:53) 
[GCC 9.2.0]
>>>

$ python3.7 --version                                                                                                 
Python 3.7.4

Cómo crear un venv para una versión específica de Python:

https://docs.python.org/3/tutorial/venv.html

12.2 CREANDO ENTORNOS VIRTUALES

Se llama al módulo utilizado para crear y administrar entornos virtuales venv.venvgeneralmente instalará la versión más reciente de Python que tenga disponible. Si tiene varias versiones de Python en su sistema, puede seleccionar una versión específica de Python ejecutando python3 o la versión que desee.

Para crear un entorno virtual, decida el directorio donde desea ubicarlo y ejecute el módulo venv como un script con la ruta del directorio:

python3 -m venv tutorial-env

Esto creará el tutorial-envdirectorio si no existe, y también creará directorios que contengan una copia del intérprete de Python, la biblioteca estándar y varios archivos de soporte. ...

Cree Python 3.7 venv [en un entorno / sistema operativo Python 3.8]:

python3.7 -m venv ~/venv/py3.7      ## create Python 3.7-based venv
source ~/venv/py3.7/bin/activate    ## activate that venv
deactivate                          ## deactivate that venv (when done, there)

Añadido a ~/.bashrc:

alias p37='echo "   [Python 3.7 venv (source ~/venv/py3.7/bin/activate)]" && source ~/venv/py3.7/bin/activate'

Prueba Python 3.7 venv:

$ p37                                                                                                                 
[Python 3.7 venv (source ~/venv/py3.7/bin/activate)]

(py3.7)$ python --version
Python 3.7.4

(py3.7)$ python
Python 3.7.4 (default, Nov 20 2019, 11:36:53) 
[GCC 9.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import sys
>>> print(sys.version)
3.7.4 (default, Nov 20 2019, 11:36:53) 
[GCC 9.2.0] 
>>>

En el subsistema de Windows para Linux:

1. Crear entorno para python3:

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

2. Activalo:

   source env/bin/activate

En windows:

py -3.4x32 -m venv venv34

o

py -2.6.2 -m venv venv26

Esto utiliza el pyiniciador que encontrará el ejecutable de Python adecuado para usted (suponiendo que lo tenga instalado).

Sí , las respuestas anteriores son correctas y funcionan bien en sistemas basados ​​en Unix como Linux y MAC OS X .

Intenté crear virtualenv para Python2 y Python3 con los siguientes comandos.

Aquí he usado venv2 y venv3 como sus nombres para Python2 y 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 ubicaciones de instalación de Python

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$ 

Funciono para mi

sudo apt-get install python3-minimal

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

Yo uso pyenv para administrar mi versión de Python.

pyenv install 3.7.3
pyenv local 3.7.3

Comprueba tu versión de Python:

$ python --version
Python 3.7.3

Cree el entorno virtual con venv :

python -m venv .

Luego active el entorno virtual:

source bin/activate

Comprueba tu versión de Python:

$ python --version
Python 3.7.3

Es posible que deba eliminar el entorno virtual anterior

rm -rf bin

Estos parecen un poco complicados para Windows. Si está en Windows con Python 3.3 o posterior, puede usar el iniciador de Python pypara hacerlo mucho más fácilmente. Simplemente instale la versión diferente de Python, luego ejecute:

py -[my version] -m venv env

Esto creará un entorno virtual llamado enven su directorio actual, usando python [my version]. Como ejemplo:

py -3.7 -m venv env
./env/Scripts/activate

Esto crea un entorno virtual llamado envusando python3.7 y lo activa. No se requieren caminos u otras cosas complejas.

virtualenv -p python3 myenv

Enlace para crear virtualenv

Para los sistemas Debian (debian 9) en 2019, descubrí una solución simple que puede resolver el problema desde el entorno virtual.

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

python3.7 -m venv myenv

pero solo tiene versiones de python2ypython2.7 , y necesita las características recientes de python3.7.

Luego, simplemente ejecutando el comando:

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

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

Esto fue un error con virtualenv. Solo actualizar tu pip debería ser la solución.

pip install --upgrade virtualenv

Como ya se mencionó en múltiples respuestas, usar virtualenv es una solución limpia. Sin embargo, un pequeño inconveniente que todos deben tener en cuenta es que si se establece un alias para python en bash_aliases como:

python=python3.6

Este alias también se utilizará dentro del entorno virtual. Entonces, en este escenario que se ejecuta python -Vdentro del entorno virtual, siempre se generará 3.6independientemente de qué intérprete se use para crear el entorno:

virtualenv venv --python=pythonX.X

Me funcionó en Windows con la instalación de Python 2:

1. Paso 1: Instale la versión de Python 3.
2. Paso 2: crea una carpeta env para el entorno virtual.
3. Paso 3: c: \ Python37 \ python -m venv c: \ path \ to \ env.

Así es como creé el entorno virtual de Python 3 en mi instalación existente de Python 2.

Puedes hacerlo haciendo esto:

virtualenv -p python3 .

Sí, solo necesita instalar la otra versión de python y definir la ubicación de su otra versión de python en su comando como:

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

Aquí está el paso a paso sobre cómo crear el entorno virtual en la carpeta de código de Visual Studio: utilicé Powershell (modo Administrador):
1. Creo una carpeta VSCode - "D: \ Code_Python_VE" donde quiero crear un entorno virtual.
2. Luego escribo el comando - "pip3 install virtualenv". (D: \ Code_Python_VE> pip3 install virtualenv) 3. D: \ Code_Python_VE> python3 -m venv project_env
4. D: \ Code_Python_VE> project_env \ Scripts \ generate.bat
5. D: \ Code_Python_VE> ls - Esto mostrará una nueva directorio "project_env".
6. D: \ Code_Python_VE> código. Esto iniciará Visual Studio Code. Asegúrese de que el comando sea (código).
7. Cree launch.jason con el siguiente contenido:

{
    // 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"
        }
    ]
}

(Busque cómo ir a la ventana Depurar y Agregar nueva configuración en el Código VS).

8. Presione F1 en el código de Visual Studio y se abrirá la paleta de comandos: seleccione Python Interpreter y seleccione el entorno virtual project_env.
9. Agregue el archivo test.py con una declaración de impresión ("Hello World").
10. Ejecute este programa
11. En Visual Studio Code terminal -
    (project_env) d: \ Code_Python_VE> python -m pip install --upgrade
    Espero que esto ayude.

UBUNTU 19.04 / Global Python 3.7.

Esto funcionó para mí, habilitando un entorno Python 3.8 usando el venv recomendado para el desarrollo de python 3.

Instale el módulo venv 3.8 y 3.8

$ sudo apt install python3.8 python3.8-venv ## más cualquier otro módulo que necesite

Crea tu Env Virtual usando la versión de python que quieras en ese env

$ /usr/bin/python3.8 -m venv python38-env

cambia a tu entorno virtual

$ source python38-env / bin / enable

python -V = python 3.8