Use uma versão diferente do Python com virtualenv


1115

Eu tenho um sistema Debian atualmente executando com o python 2.5.4. Eu tenho o virtualenv instalado corretamente, tudo está funcionando bem. Existe a possibilidade de eu poder usar um virtualenv com uma versão diferente do Python?

Compilei o Python 2.6.2 e gostaria de usá-lo com algum virtualenv. É suficiente substituir o arquivo binário? Ou tenho que mudar alguma coisa em relação às bibliotecas?


8
Apenas mencionando que você pode fazer isso usando o virtualenvwrapper também.
viés

13
Vale ressaltar que no python 3, existe um equivalente virtualenv interno : venv .
precisa saber é o seguinte

2
Não é possível alternar a versão do python no ambiente atual sem criar um novo ambiente?
Charlie Parker

Respostas:


1542

Basta usar a opção --python(ou curta -p) ao criar sua instância virtualenv para especificar o executável Python que você deseja usar, por exemplo:

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

NB Para Python 3.3 ou posterior, consulte a resposta de Aelfinn abaixo.


160
Pensei em mencionar que isso funciona para virtualenvwrappers também: mkvirtualenv -p python2.6 env
bias

65
Estou faltando alguma coisa aqui - isso não requer que o 2.6 já esteja instalado no sistema? Eu pensei que o objetivo do virtualenv era que eu poderia ter uma versão do python diferente da principal (no meu caso, 2.4 no CentOS). Eu estava assumindo que eu poderia instalar o virtualenv e, em seguida , instalar o Python 2.6 sob ele para pacotes no ambiente para usar?
John C

42
@ John sim, você é. Esse não é o objetivo do virtualenv: o objetivo é criar um ambiente em área restrita para o Python. Você precisará instalar essa versão primeiro - você pode instalá-la localmente para seu usuário.
Daniel Roseman

8
@JohnC Você pode usar o pythonbrew para instalar pythons alternativos.
Ashwoods

54
Se você é um pouco preguiçoso:virtualenv -p `which python2.6` <path/to/new/virtualenv>
chama

293

Desde o Python 3, os documentos do Python sugerem a criação do ambiente virtual com o seguinte comando:

python3 -m venv <myenvname>

Observe que venvnão permite a criação de ambientes virtuais com outras versões do Python. Para isso, instale e use o virtualenv pacote .


Informação obsoleta

O pyvenv script pode ser usado para criar um ambiente virtual

pyvenv /path/to/new/virtual/environment

mas está obsoleto desde o Python 3.6.


8
Que bom que você apontou isso, ele precisa de mais promoção. Um pequeno detalhe: agora eles estão defendendo a execução python3 -m venv <envname>para evitar a necessidade de scripts stub para tudo.
Paul Everitt

6
De fato, o pyvenvscript está obsoleto no Python 3.6+, embora o venvpróprio módulo subjacente não esteja. Então use python 3 -m venv <myenvname>como @PaulEveritt diz.
RichVel

5
Esteja avisado de que pyvenvou python3 -m venv ...NÃO instala o python-configscript. Isso significa que, mesmo após a ativação do ambiente Python3, o sistema python-configserá invocado com conseqüências confusas. Veja este relatório de bug de 2011 github.com/pypa/virtualenv/issues/169 e minha pergunta stackoverflow.com/questions/42020937/…
Laryx Decidua

1
"Observe que venvnão permite a criação de virtualenv com outras versões do Python." - Você tem certeza que isso é verdade? Parece funcionar muito bem para mim se eu criá-lo com uma versão específica do Python, por exemplo python3.5 -m venv <myenvname>(desde que eu tenha essa versão do Python disponível).
Dominick Pastore

5
Confirmando que a observação de @ Nick funciona: A maneira de criar um venvcom uma versão específica do Python é usando essa versão ao configurá-la. Por exemplo:python3.5 -m venv venv
tanius

183

Estas são as etapas que você pode seguir quando estiver em um ambiente de hospedagem compartilhada e precisar instalar e compilar o Python a partir da fonte e criar a venvpartir da sua versão do Python. Para Python 2.7.9. você faria algo nesse 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

ambiente 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, isso pode ser aplicável a qualquer situação em que você deseja replicar o ambiente exato em que trabalha e implementa.


2
Você poderia explicar por que fazê-lo dessa maneira: Por que instalar o python localmente? E o mais importante: por que instalar o virtualenv usando a versão python que você deseja usar ?
Lajarre 8/10

15
certo. Se você estiver no ambiente de hospedagem virtual e o servidor fornecer versões mais antigas do python com as quais você não está satisfeito - esse foi o meu caso. Além disso, se você desenvolver projetos em diferentes servidores e quiser replicar esses ambientes em sua máquina local ... O Virtualenv cria links físicos para bibliotecas python. portanto, é realmente importante com a versão do python que você está usando para instalar e criar o Virtualenv.
Zzart

6
Ou se você é como eu e está em uma máquina trancada no trabalho, sem privilégios de sudo. Cópias locais de bibliotecas, bancos de dados SQL, idiomas e compiladores em abundância! Obrigado!
zachd1_618 24/01

4
No virtualenv 1.9.1, tive que usar em ~/.localpython/bin/virtualenvvez de apenas virtualenvpara concluir a instalação sem erros. Além disso, use em source ve/bin/activatevez de source activate.
Saul

3
Outro motivo para fazer isso seria experimentar os betas antes que eles se tornem principais para garantir que seus projetos e suas dependências ainda funcionem sem o risco de interromper o gerenciamento de pacotes, atrapalhando algo e deixando arquivos pendentes por todo o lugar. Eu gosto desta resposta.
RobotHumans

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

2
Veja minha resposta abaixo para obter uma solução equivalente usando variáveis ​​de ambiente. Essa abordagem significa que você não precisa se lembrar de usar -p.
31416 Chris Johnson

5
Não há soluções que alternem entre versões python sem a necessidade de criar um novo ambiente virtual?
Charlie Parker

3
Isso funcionaria, se você deseja instalar uma versão python que não está instalada no seu sistema? Digamos que você queira testar, python3.6mas não quer tocar python3.5instalado no seu computador?
31818 alpha_989

1
@ alpha_989 você encontra a solução para fazer isso?
Daniil Mashkin

97

Existe uma maneira mais fácil,

virtualenv venv --python=python2.7

Graças a um comentário, isso só funciona se você tiver o python2.7 instalado no nível do sistema (por exemplo, /usr/bin/python2.7).

Caso contrário, se você estiver usando o homebrew, poderá usar o caminho para fornecer o que deseja.

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

Você pode encontrar o caminho para sua instalação python com

which python

Isso também funcionará com o python 3.

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

Por fim, condensando-se em:

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

1
FYI, só funciona se você tiver python2.7 instalado no nível do sistema (por exemplo /usr/bin/python2.7)
kingb12

Eu era capaz de fazer isso com virtualenv venv --python=python3.6bem
Jordan

Você pode realmente soltar o número da versão secundária. virtualenv env --python=python2
Anshul

Essa é uma solução adequada. Depois de ter todas as versões, você está interessado em justificar o uso do alias e não do caminho completo
user1767754

No Windows, isso funcionou como um encanto com um pequeno ajuste: virtualenv venv --python=<insert_your_python_version_here>onde <insert_your_python_version_here>estava no meu casoC:\Python\Python368\python.exe
abautista

70

No Windows para mim, isso funciona:

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

sem o que python.exeeu tenho WindowsError: [Error 5] Access is denied , tenho o Python2.7.1 instalado com o virtualenv 1.6.1 e queria o python 2.5.2.


32

Mac OSX 10.6.8 (Snow Leopard):

1) Quando você faz isso pip install virtualenv, o comando pip está associado a uma das suas versões do python e virtualenvé instalado nessa versão do python. Você pode fazer

 $ which pip   

para ver qual versão do python é essa. Se você vir algo como:

 $ which pip
 /usr/local/bin/pip

então faça:

$ 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

Você pode ver a versão python na saída.

Por padrão, essa será a versão do python usada para qualquer novo ambiente que você criar. No entanto, você pode especificar qualquer versão do python instalada no seu computador para usar dentro de um novo ambiente com -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 criará uma pasta no diretório atual que conterá os arquivos executáveis ​​do Python e uma cópia do pip [comando] que você pode usar para instalar outros pacotes.

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

virtualenv apenas copia python de um local no seu computador para o diretório my_env / bin / recém-criado.

2) O python do sistema está dentro /usr/bin, enquanto as várias versões do python que eu instalei foram, por padrão, instaladas em:

 /usr/local/bin

3) Os vários pitães que instalei têm nomes como python2.7ou python3.2, e posso usá-los em vez de caminhos completos.

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

1) Tive alguns problemas para fazer o virtualenvwrapper funcionar. Foi isso que acabei colocando ~/.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 maneira diferente com o virtualenvwrapper: tenho que especificar o caminho completo para o interpretador python a ser usado no novo ambiente (quando não quiser usar a versão python padrão):

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

Diferente do virtualenv, o virtualenvwrapper criará o ambiente no local especificado pela variável de ambiente $ WORKON_HOME. Isso mantém todos os seus ambientes em um só lugar.


which pipnão me diz a versão do Python. Isso me dá isso /usr/local/bin/pip.
precisa

@Sankalp, Se você faz o cd /usr/local/bine o faz $ ls -al pip, deverá ver algo como: pip -> ../../../Library/Frameworks/Python.framework/Versions/2.7/bin/pip
7stud

Já um pouco anotado na resposta, mas mkprojecté o comando a ser usado se você deseja criar o diretório do projeto e um ambiente virtual de uma determinada versão python. mkproject -p /usr/bin/python3.6 myNewPython36Project
Jim Factor

22

Esses dois comandos devem funcionar bem.

virtualenv -p python2 myenv (Para python2)

virtualenv -p python3 myenv (Para python3)


1
O sinalizador -p python2 funciona equivalente a procurar / usr / bin / python2. Use: virtualenv -p python2.7 myenv para 2.7 etc.
Yash Sharma

21

Suponha que você tenha atualmente o python 2.7 instalado no seu virtualenv. Mas, se você quiser usar python3.2, será necessário atualizar isso com:

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

Em seguida, ative seu virtualenv :

$ source activate name_of_your_virtualenv

e então faça: python --versionno shell para verificar se sua versão está atualizada.


Veja minha resposta abaixo para obter uma solução equivalente usando variáveis ​​de ambiente. Essa abordagem significa que você não precisa se lembrar de usar -p.
31416 Chris Johnson

13

Você pode ligar virtualenvcom a versão python desejada. Por exemplo:

python3 -m virtualenv venv

Ou, como alternativa, aponte diretamente para o seu caminho virtualenv. por exemplo, para janelas:

c:\Python34\Scripts\virtualenv.exe venv

E executando:

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

você pode ver a versão python instalada no ambiente virtual


Eu tenho esse erro sobre a execução do primeiro comando / usr / local / bin / python3: No módulo chamado virtualenv
Tanvi

2
@tanvi: Você precisa instalar o virtualenv no seu python3 primeiro. Corra pip3 install virtualenvprimeiro
Nima Soroush 23/05

12

o -p abordagem funciona bem, mas você deve se lembrar de sempre usá-la. Se seu objetivo é mudar para uma versão mais recente do Python em geral, isso é uma dor e também pode levar a erros.

Sua outra opção é definir uma variável de ambiente que faça a mesma coisa que -p. Defina isso através do seu ~/.bashrcarquivo ou onde quer que você gerencie variáveis ​​de ambiente para suas sessões de login:

export VIRTUALENV_PYTHON=/path/to/desired/version

Em seguida virtualenv, usará isso sempre que você não especificar -pna linha de comando.


Isso funcionou lindamente. Alguma idéia de por que a configuração export VIRTUALENVWRAPPER_PYTHON=/path/to/desired/versionpelos documentos do virtualenvwrapper não funcionou, mas esta solução funcionou?
usar o seguinte comando

Esse env var controla o que o Python virtualenvwrapperusa quando executado, nada a ver com instalações.
Chris Johnson

Isso funcionou para mim. Não é mais necessário usar -p sempre que eu criar um novo virtualenv. Obrigado!
Nedblorf # 10/19

7

Ainda mais fácil, usando a substituição de comandos para encontrar o python2 para você:

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

Ou ao usar virtualenvwrapper:

mkvirtualenv -p $(which python2) <env_name>


7

Para Mac (High Sierra), instale o virtualenv no python3 e crie um 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 o virtualenv no python3 se você não tiver:python3 -m pip install virtualenv
Zihao Zhao

Isso não funciona. Minha versão python ainda é 3.
shivendra pratap singh

6

No mac eu uso pyenv e virtualenvwrapper. Eu tive que criar um novo virtualenv. Você precisa de homebrew, que eu assumo que você instalou se estiver em um mac, mas apenas por diversão:

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}

Também congelei meus requisitos primeiro para poder simplesmente reinstalar no novo virtualenv com:

pip install -r requirements.txt

O comando deve ser mkvirtualenv -p ~/.pyenv/versions/2.7.10/bin/python {virtual_env_name}versões, não versão. Se o SO permitisse edições curtas, eu o teria corrigido.
Martin Burch

pyenvinclui suporte ao virtualenv por meio do pyenv-virtualenvplug - in, então acho que realmente não preciso do virtualenvwrapper. Mais detalhes na minha resposta pyenv .
RichVel

5

[Novembro de 2019] Eu precisava instalar um ambiente Python 3.7 (env) no meu sistema Arch Linux baseado em Python 3.8. O Python 3.7 não estava mais no sistema, então não pude fazer o downgrade do Python para instalar um pacote que eu precisava.

Além disso, eu queria usar esse pacote / Python 3.7 dentro de um ambiente virtual (venv). Foi assim que eu fiz.


Faça o download dos arquivos de origem da versão do Python:

Eu baixei os arquivos de origem Python 3.7.4 de

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

para

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

Eu então extraí esse arquivo morto (arquivos de origem) para

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


Instalação:

[Nota: no meu sistema env, não um 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 as versões instaladas do Python:

$ 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

Como criar um venv para uma versão específica do Python:

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

12.2 CRIANDO AMBIENTES VIRTUAIS

O módulo usado para criar e gerenciar ambientes virtuais é chamado venv. venvgeralmente instala a versão mais recente do Python que você tem disponível. Se você possui várias versões do Python em seu sistema, pode selecionar uma versão específica do Python executando python3 ou a versão que desejar.

Para criar um ambiente virtual, decida o diretório em que deseja colocá-lo e execute o módulo venv como um script com o caminho do diretório:

python3 -m venv tutorial-env

Isso criará o tutorial-envdiretório, se ele não existir, e também criará diretórios dentro dele, contendo uma cópia do interpretador Python, a biblioteca padrão e vários arquivos de suporte. ...


Crie o Python 3.7 venv [em um sistema operacional / sistema 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)

Adicionado a ~/.bashrc:

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

Teste o 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 é uma resposta extremamente completa! :) Eu encontro esse problema toda vez que preciso transferir algo do Arch Linux para qualquer outro sistema (por exemplo, Debian-ish).
Robbie Capps

1
@ Victoria Stuart, muito obrigado. Era exatamente isso que eu estava procurando.
daddyodevil

4

No subsistema Windows para linux:

  1. Crie um ambiente para python3:

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

    source env/bin/activate

3

No Windows:

py -3.4x32 -m venv venv34

ou

py -2.6.2 -m venv venv26

Isso usa o pyiniciador que encontrará o executável python certo para você (supondo que você o tenha instalado).


3

Sim , as respostas acima estão corretas e funcionam bem em sistemas baseados em Unix, como Linux e MAC OS X .

Tentei criar o virtualenv para Python2 e Python3 com os seguintes comandos.

Aqui, usei venv2 e venv3 como seus nomes para Python2 e 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$ 

Verificando os locais de instalação do 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

Funcionou para mim

sudo apt-get install python3-minimal

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

2

Eu uso o pyenv para gerenciar minha versão do python.

pyenv install 3.7.3
pyenv local 3.7.3

Verifique sua versão do python:

$ python --version
Python 3.7.3

Crie o ambiente virtual com venv :

python -m venv .

Em seguida, ative o ambiente virtual:

source bin/activate

Verifique sua versão do python:

$ python --version
Python 3.7.3

Pode ser necessário remover o ambiente virtual anterior

rm -rf bin

2

Estes parecem um pouco complicados para o Windows. Se você estiver no Windows executando o python 3.3 ou posterior, poderá usar o iniciador de python pypara fazer isso com muito mais facilidade. Simplesmente instale a versão diferente do python e execute:

py -[my version] -m venv env

Isso criará um ambiente virtual chamado envem seu diretório atual, usando python [my version]. Como um exemplo:

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

Isso cria um ambiente virtual chamado envusando python3.7 e o ativa. Nenhum caminho ou outro material complexo é necessário.


Não deveria ser py -3.7 -m venv env(o que -mestá faltando)?
sinoroc 08/03

Sim, consertado no post !.
Cole Smith em


1

Para os sistemas Debian (debian 9) em 2019, descobri uma solução simples que pode resolver o problema de dentro do ambiente virtual.

Suponha que o ambiente virtual tenha sido criado via:

python3.7 -m venv myenv

mas tem apenas versões de python2epython2.7 , e você precisa dos recursos recentes do python3.7.

Em seguida, basta executar o comando:

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

adicionará pacotes python3.7 se eles já estiverem disponíveis no seu sistema.


1

Este foi um erro com o virtualenv. Apenas atualizar o seu pip deve ser a solução.

pip install --upgrade virtualenv


1

Como já mencionado em várias respostas, o uso do virtualenv é uma solução limpa. No entanto, uma pequena armadilha que todos devem estar cientes é que, se um alias para python for definido em bash_aliases como:

python=python3.6

esse alias também será usado dentro do ambiente virtual. Portanto, nesse cenário, a execução python -Vdentro do ambiente virtual sempre será exibida, 3.6independentemente do intérprete usado para criar o ambiente:

virtualenv venv --python=pythonX.X

0

Funcionou para mim no Windows com a instalação do python 2:

  1. Etapa 1: Instale a versão python 3.
  2. Etapa 2: crie uma pasta env para o ambiente virtual.
  3. Etapa 3: c: \ Python37 \ python -m venv c: \ caminho \ para \ env.

Foi assim que criei o ambiente virtual Python 3 na minha instalação existente do python 2.



0

Sim, você só precisa instalar a outra versão do python e definir o local da sua outra versão do python em seu comando, como:

virtualenv / home / folha de pagamento / Documents / env -p / usr / bin / python3


0

Aqui está o passo a passo de como criar o ambiente virtual na pasta Código do Visual Studio: Usei o Powershell (modo Administrador):
1. Crio uma pasta VSCode - "D: \ Code_Python_VE" onde desejo criar o ambiente virtual.
2. Em seguida, digite o comando - "pip3 install virtualenv". (D: \ Code_Python_VE> pip3 instala o virtualenv) 3. D: \ Code_Python_VE> python3 -m venv project_env
4. D: \ Code_Python_VE> project_env \ Scripts
\ enable.bat 5. D: \ Code_Python_VE> ls - Listará um novo diretório "project_env".
6. D: \ Code_Python_VE> código. Isso iniciará o Visual Studio Code. Verifique se o comando é (código).
7. Crie launch.jason com o seguinte conteúdo:

{
    // 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, procure como ir para a janela Debug e adicionar nova configuração no código VS).

  1. Pressione F1 no código do Visual studio e o comando pallet será aberto - Selecione Python Interpreter e selecione o ambiente virtual project_env.
  2. Adicione o arquivo test.py com uma declaração impressa ("Hello World").
  3. Execute este programa.
  4. No terminal de código do Visual studio -
    (project_env) d: \ Code_Python_VE> python -m pip install --upgrade
    Espero que isso ajude.

-2

UBUNTU 19.04 / Global Python 3.7.

Isso funcionou para mim, permitindo um ambiente Python 3.8 usando o venv recomendado para o desenvolvimento do python 3.

Instale os módulos venv 3.8 e 3.8

$ sudo apt install python3.8 python3.8-venv ## além de outros módulos que você precisa

Crie seu Env virtual usando a versão python que você deseja nesse env

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

mude para o seu ambiente virtual

$ source python38-env / bin / ativar

python -V = python 3.8

Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.