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?

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.

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.

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.

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

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`

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.

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.

Esses dois comandos devem funcionar bem.

virtualenv -p python2 myenv (Para python2)

virtualenv -p python3 myenv (Para python3)

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.

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

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.

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>

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

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

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

No subsistema Windows para linux:

1. Crie um ambiente para python3:

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

2. Ative-o:

   source env/bin/activate

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

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$ 

Funcionou para mim

sudo apt-get install python3-minimal

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

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

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.

virtualenv -p python3 myenv

Link para Criando virtualenv

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.

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

pip install --upgrade virtualenv

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

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.

Você pode fazer isso fazendo o seguinte:

virtualenv -p python3 .

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

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

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

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