Use diferentes versiones de Python con virtualenv


1116

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?


8
Solo menciono que puedes hacer esto usando virtualenvwrapper también.
sesgo

13
Vale la pena señalar que en Python 3, hay un equivalente virtualenv incorporado : venv .
naught101

2
¿No es posible cambiar la versión de Python en el entorno actual sin crear un nuevo entorno?
Charlie Parker el

Respuestas:


1542

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.


160
Pensé que mencionaría que esto también funciona para virtualenvwrappers: mkvirtualenv -p python2.6 env
sesgo

65
Me falta algo aquí, ¿no requiere esto que 2.6 ya esté instalado en el sistema? Pensé que el punto de virtualenv era que podía tener una versión de Python distinta a la principal (en mi caso, 2.4 en CentOS). Estaba asumiendo que podría instalar virtualenv, luego instalar Python 2.6 debajo de él para que los paquetes en el entorno lo utilicen.
John C

42
@John sí, lo eres. Ese no es el punto de virtualenv: el objetivo es crear un entorno de espacio aislado para Python. Primero deberá instalar esa versión; sin embargo, puede instalarla localmente para su usuario.
Daniel Roseman

8
@JohnC Puede usar pythonbrew para instalar pitones alternativos.
Ashwoods

54
Si eres un poco vago:virtualenv -p `which python2.6` <path/to/new/virtualenv>
blaze

294

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.


8
Me alegra que lo hayas señalado, necesita más promoción. Una cuestión menor: ahora están abogando por ejecutarlo python3 -m venv <envname>para evitar la necesidad de scripts de código auxiliar para todo.
Paul Everitt

66
De hecho, el pyvenvscript está en desuso en Python 3.6+, aunque el venvmódulo subyacente en sí no. Así python 3 -m venv <myenvname>que úsalo como dice @PaulEveritt.
RichVel

55
Tenga en cuenta eso pyvenvo python3 -m venv ...NO instale el python-configscript. Esto significa que incluso después de activar su entorno Python3, se invocará todo el sistema python-configcon consecuencias confusas. Vea este informe de error de 2011 github.com/pypa/virtualenv/issues/169 y mi pregunta stackoverflow.com/questions/42020937/…
Laryx Decidua

1
"Tenga en cuenta que venvno permite crear virtualenv con otras versiones de Python". - ¿Estás seguro de que esto es cierto? Parece que funciona bien para mí si lo creo con una versión específica de Python, por ejemplo python3.5 -m venv <myenvname>(siempre que tenga esa versión de Python disponible).
Dominick Pastore

55
Confirmar que la observación de @ Nick funciona: la forma de crear una venvcon una versión específica de Python es usar esa versión al configurarla. Por ejemplo:python3.5 -m venv venv
tanius el

183

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.


2
¿Podría explicar por qué hacerlo de esa manera? ¿Por qué instalar Python localmente? Y, lo que es más importante, ¿por qué instalar virtualenv con la versión de Python que desea utilizar ?
lajarre

15
Por supuesto. Si está en un entorno de alojamiento virtual y el servidor proporciona versiones anteriores de python con las que no está satisfecho, ese fue mi caso. Además, si desarrolla proyectos en diferentes servidores y desea replicar estos entornos en su máquina local ... Virtualenv crea enlaces duros a las bibliotecas de Python. así que es realmente importante con la versión de python que está utilizando para instalar y crear Virtualenv.
zzart

66
O si eres como yo y estoy en una máquina bloqueada en el trabajo sin privilegios de sudo. ¡Copias locales de bibliotecas, bases de datos SQL, idiomas y compiladores en abundancia! ¡Gracias!
zachd1_618

44
Bajo virtualenv 1.9.1, tuve que usar en ~/.localpython/bin/virtualenvlugar de solo la virtualenvconfiguración para completar sin errores. Además, use en source ve/bin/activatelugar de source activate.
Saul

3
Otra razón para hacer esto sería probar las versiones beta antes de que se conviertan en principales para asegurarse de que sus proyectos y sus dependencias sigan funcionando sin arriesgarse a romper su administración de paquetes al golpear algo y dejar archivos colgando por todos lados. Me gusta esta respuesta
RobotHumans

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

2
Vea mi respuesta a continuación para obtener una solución equivalente usando variables de entorno. Ese enfoque significa que no tiene que acordarse de usar -p.
Chris Johnson

55
¿No hay soluciones que cambien entre versiones de Python sin requerir crear un nuevo entorno virtual?
Charlie Parker

3
¿Funcionaría esto si desea instalar una versión de Python que no está instalada en su sistema? Digamos que quieres probar python3.6pero no quieres tocar python3.5instalado en tu computadora?
alpha_989

1
@ alpha_989 ¿encuentra la solución para hacer esto?
Daniil Mashkin el

97

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`

1
Para su información, solo funciona si tiene instalado python2.7 en el nivel del sistema (por ejemplo, /usr/bin/python2.7)
kingb12

Yo era capaz de hacer esto con virtualenv venv --python=python3.6así
Jordan

De hecho, puede soltar el número de versión menor. virtualenv env --python=python2
Anshul

Esa es una solución adecuada, una vez que tenga todas las versiones, está interesado en usar el alias, no la ruta completa
usuario 1767754,

En Windows, esto funcionó de virtualenv venv --python=<insert_your_python_version_here><insert_your_python_version_here>C:\Python\Python368\python.exe
maravilla

70

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.


32

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.


which pipno me dice la versión de Python. Me da esto /usr/local/bin/pip.
Sankalp

@Sankalp, si lo /usr/local/binhaces y lo haces $ ls -al pip, deberías ver algo como: pip -> ../../../Library/Frameworks/Python.framework/Versions/2.7/bin/pip
7stud

Ya se ha notado algo en la respuesta, pero mkprojectes el comando que se debe usar si desea crear tanto el directorio del proyecto como un entorno virtual de una versión de Python dada. mkproject -p /usr/bin/python3.6 myNewPython36Project
Jim Factor

22

Estos dos comandos deberían funcionar bien.

virtualenv -p python2 myenv (Para python2)

virtualenv -p python3 myenv (Para python3)


1
La bandera -p python2 funciona de manera equivalente a buscar / usr / bin / python2. Uso: virtualenv -p python2.7 myenv para 2.7 etc.
Yash Sharma

21

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.


Vea mi respuesta a continuación para obtener una solución equivalente usando variables de entorno. Ese enfoque significa que no tiene que acordarse de usar -p.
Chris Johnson

13

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


Recibí este error al ejecutar el primer comando / usr / local / bin / python3: ningún módulo llamado virtualenv
tanvi

2
@tanvi: Primero debes instalar virtualenv en tu python3. Corre pip3 install virtualenvprimero
Nima Soroush

12

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.


Esto funcionó muy bien. ¿Alguna idea de por qué la configuración export VIRTUALENVWRAPPER_PYTHON=/path/to/desired/versionsegún los documentos virtualenvwrapper no funcionó pero esta solución funcionó?
YPCrumble

Esa env var controla qué Python virtualenvwrapperusa cuando se ejecuta, nada que ver con las instalaciones.
Chris Johnson el

Esto funcionó para mí. Ya no tengo que usar -p cada vez que creo un nuevo virtualenv. ¡Gracias!
nedblorf

7

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>


7

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

1
Instale virtualenv en python3 si no tiene:python3 -m pip install virtualenv
Zihao Zhao

No funciona Mi versión de Python sigue siendo 3.
Shivendra Pratap Singh

6

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

El comando debe ser mkvirtualenv -p ~/.pyenv/versions/2.7.10/bin/python {virtual_env_name}versiones, no versiones. Si SO permitiera ediciones cortas, lo arreglaría.
Martin Burch

pyenvincluye soporte virtualenv a través del pyenv-virtualenvcomplemento, por lo que creo que realmente no necesito virtualenvwrapper. Más detalles en mi respuesta pyenv .
RichVel

5

[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] 
>>>

1
¡Esta es una respuesta extremadamente completa! :) Me encuentro con este problema cada vez que necesito transferir algo de Arch Linux a cualquier otro sistema (por ejemplo, Debian-ish).
Robbie Capps

1
@Victoria Stuart, muchas gracias. Esto es exactamente lo que estaba buscando.
daddyodevil

4

En el subsistema de Windows para Linux:

  1. Crear entorno para python3:

    virtualenv --python=/usr/bin/python3 env
  2. Activalo:

    source env/bin/activate

3

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


3

, 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$ 

2

Funciono para mi

sudo apt-get install python3-minimal

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

2

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

2

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.


¿No debería ser py -3.7 -m venv enven su lugar ( -mfalta el)?
sinoroc

Sí, arreglado en el post !.
Cole Smith


1

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.


1

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

pip install --upgrade virtualenv


1

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

0

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.



0

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


0

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

  1. 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.
  2. Agregue el archivo test.py con una declaración de impresión ("Hello World").
  3. Ejecute este programa
  4. En Visual Studio Code terminal -
    (project_env) d: \ Code_Python_VE> python -m pip install --upgrade
    Espero que esto ayude.

-2

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

Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.