Como faço para ativar um virtualenv dentro do terminal da PyCharm?


110

Eu configurei o PyCharm, criei meu virtualenv (por meio do comando virtual env ou diretamente no PyCharm) e ativei esse ambiente como meu intérprete. Tudo está funcionando bem.

No entanto, se eu abrir um terminal usando "Ferramentas, Abrir Terminal", o prompt do shell fornecido não está usando o env virtual; Eu ainda tenho que usar source ~/envs/someenv/bin/activatedentro desse Terminal para ativá-lo.

Outro método é ativar o ambiente em um shell e executar o PyCharm a partir desse ambiente. Isso é "viável", mas muito feio, e significa que tenho grandes problemas se mudar de ambiente ou projeto do PyCharm: agora estou usando o ambiente totalmente errado.

Existe alguma outra maneira muito mais fácil de "Ferramentas, Abrir Terminal" ativar automaticamente o ambiente virtual?

Respostas:


95

Editar:

De acordo com https://www.jetbrains.com/pycharm/whatsnew/#v2016-3-venv-in-terminal , PyCharm 2016.3 (lançado em novembro de 2016) tem suporte virutalenv para terminais prontos para uso

O virtualenv automático é compatível com bash, zsh, fish e Windows cmd. Você pode personalizar suas preferências de shell em Configurações (Preferências) | Ferramentas | Terminal.


Método Antigo:

Crie um arquivo .pycharmrcem sua pasta pessoal com o seguinte conteúdo

source ~/.bashrc
source ~/pycharmvenv/bin/activate

Usando seu caminho virtualenv como último parâmetro.

Em seguida, defina as Preferências do shell-> Configurações do projeto-> Caminho do shell para

/bin/bash --rcfile ~/.pycharmrc

9
Obrigado! Eu não tinha pensado em substituir o arquivo rc do shell. Para melhor suportar o trabalho de pycharm com vários projetos, cada um dos quais pode ter um virtualenv diferente, eu chamaria o arquivo ".pycharmrc" de algo diferente e talvez o colocasse no próprio diretório env. ~/pycharmenv/bin/terminalactivateparece uma boa opção.
Chris Cogdon de

1
O Pycharm 4 tem virtualenvs integrado no IDE. Veja minha resposta para mais informações.
consulta em

1
@PeterGibson, a resposta de pferate não tem nada a ver com a pergunta do OP. O problema é o terminal, não o interpretador Python. A integração com o venv já existe muito antes do PyCharm 4. Mas sua resposta funciona.
Norbert

1
Esta é a solução mais simples, exceto que coloco meu .pycharmrcna pasta de início do projeto, para que possa ter um arquivo diferente para cada projeto. Em um projeto configurado corretamente, não há necessidade de fornecer o caminho absoluto para o .pycharmrcarquivo.
tchakravarty

1
@SiminJie, PyCharm 2016.3.2 tem essa opção na caixa. Vá para: configurações -> Ferramentas -> Terminal. E certifique-se de que a opção "Ativar virtualenv" está habilitada.
renskiy

44

Atualizar:

As preferências em Configurações (Preferências) | Ferramentas | Terminal são globais.
Se você usar um venv para cada projeto, lembre-se de usar a variável de caminho atual e um nome venv padrão:

"cmd.exe" /k ""%CD%\venv\Scripts\activate"" 

Para usuários do Windows: ao usar PyCharm com um ambiente virtual, você pode usar o /Kparâmetro cmd.exepara definir o ambiente virtual automaticamente.

PyCharm 3 ou 4: Settings, Terminal, Default shelle add /K <path-to-your-activate.bat>.

PyCharm 5: Settings, Tools, Terminal, e adicione /K <path-to-your-activate.bat>a Shell path.

PyCharm 2016,1 ou 2016,2: Settings, Tools, Terminal, e adicione ""/K <path-to-your-activate.bat>""a Shell pathe adicione (mente as aspas). Além disso, adicione aspas ao redor de cmd.exe, resultando em:

"cmd.exe" /k ""C:\mypath\my-venv\Scripts\activate.bat""


Neste caso, %CD%é o diretório de trabalho atual, consulte o comando shell do Windows para obter o caminho completo para o diretório atual?
bad_coder

40

Para usuários do Windows ao usar PyCharm e um ambiente virtual no Windows, você pode usar o parâmetro / k para cmd.exe para definir o ambiente virtual automaticamente.

Vá para Configurações, Terminal, Shell padrão e adicione /K <path-to-your-activate.bat>.

Não tenho reputação de comentar sobre a resposta anterior, portanto, estou postando esta versão corrigida. Isso realmente economiza muito tempo.

Atualizar:

Nota: Pycharm agora oferece suporte a ambientes virtuais diretamente e parece funcionar bem para mim - portanto, minha solução alternativa não é mais necessária.


Isso é ótimo, mas apenas quando você tem apenas um virtualenv para todos os seus projetos. A configuração de shell padrão é compartilhada entre os projetos
MartinM

7

Com base nas respostas de Peter e na experimentação, descobri uma boa "solução geral", que resolve o seguinte:

  • Restaura o comportamento de um shell de login. O PyCharm normalmente executa um shell de login, mas --rcfile impediu que isso acontecesse. O script ainda usa --rcfile, mas tenta emular o comportamento INVOCATION de um shell de login.
  • Remove a necessidade de criar um rcfile para cada ambiente
  • Remove a necessidade de atualizar as configurações do projeto se você alterar o ambiente.

Solte este script em um diretório bin em algum lugar. Por exemplo, ~ / bin / pycharmactivate

if [ -r "/etc/profile" ] ; then . /etc/profile ; fi
if [ -r "~/.bash_profile" ] ; then
    . ~/.bash_profile
elif [ -r "~/.bash_login" ] ; then
    . ~/.bash_login
elif [ -r "~/.profile" ] ; then
    . ~/.profile
fi
ACTIVATERC=`cat .idea/workspace.xml | perl -n -e 'print "\$1/bin/activate" if m:option name="SDK_HOME" value="\\\$USER_HOME\\\$(.*)/bin/python":'`
if [ -n "$ACTIVATERC" ] ; then . "$HOME/$ACTIVATERC" ; else echo "Could not find virtualenv from PyCharm" ; fi

Em seguida, defina o caminho do Shell do PyCharm para:

/bin/bash --rcfile ~/bin/pycharmactivate

1
OBRIGADO! Isso funcionou para mim depois de horas de tentativas malsucedidas de descobrir onde iniciar os perfis bashrc e bash. No entanto, ocorreu um erro que não conseguiu encontrar meu env virtual, então eu modifiquei assim, você pode me dizer se está OK? if [ -r "/etc/profile" ] ; then . /etc/profile ; fi if [ -r "~/.bash_profile" ] ; then . ~/.bash_profile elif [ -r "~/.bash_login" ] ; then . ~/.bash_login elif [ -r "~/.profile" ] ; then . ~/.profile fi source ~/learnp/project1/venv/bin/activate
zerohedge de

@zerohedge: Seu script funcionará bem, mas está fixo em seu virtualenv "projeto1". O script acima deveria fazer a detecção automática, mas há um monte de suposições sendo feitas: que o diretório de trabalho inicial é a localização do diretório ".idea"; que o formato do arquivo workspace.xml não muda significativamente. Infelizmente, parece que a versão 5 do pycharm fez mudanças significativas nessa área. Na verdade, não consigo descobrir onde estão os dados agora.
Chris Cogdon de

bem, não me importo em mudar minha adição dependendo do projeto, já que o Shell Path to também é específico do projeto. Eu só consegui obter um prompt dizendo "bash 3.2 $:" antes de encontrar seu script, sem nenhuma indicação do meu diretório atual ou qualquer semelhança com o prompt do meu Terminal. Obrigado de novo!
zerohedge de

7

PyCharm 4 agora tem virtualenvs integrado no IDE. Ao selecionar seu intérprete de projeto, você pode criar, adicionar ou selecionar um virtualenv. Eles adicionaram um "Console Python" que é executado no interpretador de projeto configurado.

Mais informações aqui.


11
Como isso responde ao OP? Ainda tem que source /path/to/venv/bin/activatemanualmente no terminal.
frnhr

6

Obrigado Chris, seu script funcionou para alguns projetos, mas não todos na minha máquina. Aqui está um script que escrevi e espero que alguém o considere útil.

#Stored in ~/.pycharmrc 

ACTIVATERC=$(python -c 'import re
import os
from glob import glob

try:
  #sets Current Working Directory to _the_projects .idea folder
  os.chdir(os.getcwd()+"/.idea") 

  #gets every file in the cwd and sets _the_projects iml file
  for file in glob("*"): 
    if re.match("(.*).iml", file):
      project_iml_file = file

  #gets _the_virtual_env for _the_project
  for line in open(project_iml_file):
    env_name = re.findall("~/(.*)\" jdkType", line.strip())
    # created or changed a virtual_env after project creation? this will be true
    if env_name:
      print env_name[0] + "/bin/activate"
      break

    inherited = re.findall("type=\"inheritedJdk\"", line.strip())
    # set a virtual_env during project creation? this will be true
    if inherited:
      break

  # find _the_virtual_env in misc.xml
  if inherited:
    for line in open("misc.xml").readlines():
      env_at_project_creation = re.findall("\~/(.*)\" project-jdk", line.strip())
      if env_at_project_creation:
        print env_at_project_creation[0] + "/bin/activate"
        break
finally:
  pass
')

if [ "$ACTIVATERC" ] ; then . "$HOME/$ACTIVATERC" ; fi

Obrigado, isso funcionou para mim! Tive que fazer duas coisas adicionais. 1) Adicionar source /etc/profileno início do arquivo ~ / .pycharmrc (no Mac Yosemite) 2) No Pycharm, edite Preferências> Ferramentas> Terminal> Caminho do shell para "/ bin / bash --rcfile ~ / .pycharmrc"
frnhr

Isso é incrível, obrigado! Se você estiver usando Python 3, lembre-se de colocar parênteses para a função de impressão. Eu mesmo tive que colocar "export ~ / .bashrc" antes deste script.
Raphaël Gomès

5

Eu vi todas as respostas acima, mas nenhuma delas é elegante o suficiente para mim. Em PyCharm 2017/01/03 (no meu computador), a maneira mais fácil é abrir Settings->Tools->Terminale verificar Shell integratione Activate virtualenvopções.

imagem


Bem, a resposta aceita cita exatamente a mesma coisa. Só que não tem imagem.
Vikas Prasad de

5

Se você estiver usando a versão windows é bastante fácil. Se você já possui o ambiente virtual basta navegar até a pasta, localize activate.batdentro da Scriptspasta. copie o caminho completo e cole no terminal do pycharm e pressione Entere pronto!

Se você precisa criar um novo ambiente virtual:

Vá para arquivos> configurações, procure project interpreter, abra-o, clique no botão de engrenagem e crie o ambiente onde quiser e siga o primeiro parágrafo.

A engrenagem!


Ótima resposta! Obrigado! Pergunta rápida. Tenho 3 ambientes virtuais diferentes que criei no Anaconda. Existe algo separado activate.batpara cada um deles?
user1700890

1
@ user1700890 sim! Caso você não tenha sobrescrito os ambientes, eles devem ter pastas separadas e, como resultado, activate.batarquivos separados . se gostar da resposta, sinta-se à vontade para
votar positivamente

Obrigado, acabei de verificar, não há pastas na Scriptspasta. O Pycharm também reclama que activate.batnão é um SDK do python válido
user1700890,

1
Então eu acho que você deve primeiro tentar encontrar a pasta de ambiente virtual criada quando você activateestava usando o Anaconda e, em seguida, executar o arquivo em lote dentro dela. ou se for possível para você, vá com a criação de um novo ambiente.
AmiNadimi

3

No Mac é PyCharm => Preferências ... => Ferramentas => Terminal => Ativar virtualenv , que deve estar habilitado por padrão.


2

Acabei de adicionar um script chamado pycharmactivate ao meu diretório inicial. Defina o valor de PyCharm (4.0.1) Arquivo> Configurações> Ferramentas> Terminal> Caminho do shell para / bin / bash --rcfile ~ / pycharmactivate. Talvez não seja a melhor solução no caso de você ter diferentes projetos e diretórios / nomes de virtualenv, mas funciona para mim. Este script contém as 3 linhas a seguir e assume que seu virtualenv tem o mesmo nome que seu diretório de projeto.

source ~/.bashrc
projectdir=${PWD##*/}
source ~/.virtualenvs/$projectdir/bin/activate

2

Seguindo a resposta de Peter, aqui está a versão para Mac do .pycharmrcarquivo:

source /etc/profile
source ~/.bash_profile
source  <venv_dir>/bin/activate

Galinha


1

Tenho uma solução que funcionou na minha máquina com Windows 7.

Acredito que o terminal do PyCharm é o resultado de sua execução cmd.exe, que carregará a PATHvariável do Windows e usará a versão do Python que encontrar primeiro dentro dela PATH. Para editar esta variável, clique com o botão direito em Meu Computador -> Propriedades -> Configurações Avançadas do Sistema -> guia Avançado -> botão Variáveis ​​de Ambiente .... Na seção Variáveis do sistema , selecione e edite a PATHvariável.

Aqui está a parte relevante do meu PATH antes de editar:

C: \ Python27 \;
C: \ Python27 \ Lib \ site-packages \ pip \;
C: \ Python27 \ Scripts;
C: \ Python27 \ Lib \ site-packages \ django \ bin;

... e após a edição PATH(apenas 3 linhas agora):

C: [caminho_projeto] \ virtualenv-Py2.7_Dj1.7 \ Lib \ site-packages \ pip;
C: [project_path] \ virtualenvs \ virtualenv-Py2.7_Dj1.7 \ Scripts;
C: [caminho_projeto] \ virtualenvs \ virtualenv-Py2.7_Dj1.7 \ Lib \ site-packages \ django \ bin;

Para testar isso, abra um novo terminal do Windows ( Iniciar -> digite cmde pressione Enter) e veja se ele está usando seu ambiente virtual. Se funcionar, reinicie o PyCharm e teste-o no terminal do PyCharm.


1

isto é o que estou fazendo: criar um arquivo activate_env.bat (windows, talvez .sh no linux) no seguinte código-fonte:

/env_yourenvlocate/scripts/activate.bat

e outro arquivo deactivate_env.bat:

/env_yourenvlocate/scripts/deactivate.bat

toda vez que abrir a janela do terminal, basta executar o arquivo bat para ativar / desativar o virtualenv, você ficará no caminho do código-fonte, não há necessidade de alterar o caminho de ida e volta.

E:\Projects\django_study\src>active_env.bat

E:\Projects\django_study\src>../env_django_study/scripts/activate.bat
(env_django_study) E:\Projects\django_study\src>



(env_django_study) E:\Projects\django_study\src>deactive_env.bat

(env_django_study)E:\Projects\django_study\src>../env_django_study/scripts/deactivate.bat
E:\Projects\django_study\src>

1

Se o seu Pycharm 2016.1.4v e superior você deve usar "default path" /K "<path-to-your-activate.bat>" não se esqueça das citações


1

Se você moveu seu projeto para outro diretório, pode definir o novo caminho na caixa de diálogo Configurações. E então você precisa definir este intérprete de projeto na caixa de diálogo Editar configuração.

insira a descrição da imagem aqui

insira a descrição da imagem aqui


0

Outra alternativa é usar o virtualenvwrapper para gerenciar seus ambientes virtuais. Parece que uma vez que o script virtualenvwrapper é ativado , o pycharm pode usá-lo e então o workoncomando simples estará disponível no console do pycharm e apresentará os ambientes virtuais disponíveis:

kevin@debian:~/Development/django-tutorial$ workon
django-tutorial
FlaskHF
SQLAlchemy
themarkdownapp
kevin@debian:~/Development/django-tutorial$ workon django-tutorial
(django-tutorial)kevin@debian:~/Development/django-tutorial$ 

1
No entanto, isso exige que eu ative o script workon toda vez que abro o terminal e saiba qual ambiente virtual o pycharm está usando no momento para executar o programa, ambos os quais eu estava explicitamente tentando evitar.
Chris Cogdon

@ChrisCogdon ah, entendo
ksaylor11

0

Este método deve funcionar com ambientes virtuais arbitrários por projeto e não faz suposições em seu ambiente, pois usa ganchos que você cria.

Você escreve:

  • Um script global que invoca o gancho
  • Um script de gancho por projeto PyCharm (não obrigatório)

Dado que o PyCharm mais recente atual (Community 2016.1) não permite que as configurações do Terminal por projeto iniciem com o script que invoca o gancho específico do projeto. Este é o meu ~/.pycharmrc:

if [ -r ".pycharm/term-activate" ]; then
   echo "Terminal activation hook detected."
   echo "Loading Bash profile..."
   source ~/.bash_profile
   echo "Activating terminal hook..."
   source ".pycharm/term-activate"
   source activate $PYCHARM_VENV
fi

Se você estiver usando algo diferente do Bash, invoque seu próprio .bash_profileequivalente se desejar.

Agora configure seu PyCharm "Ferramentas -> Terminal -> Caminho do Shell" para invocar este script, por exemplo: /bin/bash --rcfile ~/.pycharmrc

Finalmente, para cada projeto PyCharm você precisa de um ambiente virtual específico ativado, crie um arquivo dentro da raiz do projeto PyCharm .pycharm/term-activate. Este é o seu gancho e ele simplesmente definirá o nome do ambiente virtual desejado para o seu projeto PyCharm:

export PYCHARM_VENV=<your-virtual-env-name>

É claro que você pode estender seus ganchos com qualquer coisa que achar útil no ambiente de terminal de seu projeto PyCharm específico.


0

Para ambientes virtuais conda no Windows, certifique-se de que seu arquivo em lote NÃO seja nomeado, activate.batpois isso causará um conflito com o activatecomando conda , resultando em uma chamada recursiva do arquivo em lote.

O que funciona para mim é o seguinte caminho do Shell:

"cmd.exe" /k ""C:\FullPathToYourProject\activate-env.bat""

E no arquivo activate-env.bat:

call activate myenvname

0

Eu queria um ambiente virtual separado para cada projeto e não me importava muito em ter arquivos adicionais para facilitar isso. Uma solução que você só precisa fazer uma vez e funciona para todos os projetos é adicionar o seguinte ao seu .bashrcou .bash_profile:

if [ -d "./venv" ]; then
    source ./venv/bin/activate
fi

Isso verifica se há um ambiente virtual onde o terminal está sendo aberto e, se houver, o ativa (e, claro, outros caminhos relativos podem ser usados). As configurações do terminal do PyCharm podem ser deixadas como padrão.


0

PyCharm 4.5.4

Crie um arquivo .pycharmrc em sua pasta pessoal com o seguinte conteúdo

source ~/.bashrc
source ~/pycharmvenv/bin/activate

Usando seu caminho virtualenv como último parâmetro.

Em seguida, defina as Preferências do shell-> Configurações do projeto-> Caminho do shell para

/bin/bash --rcfile ~/.pycharmrc

Não sei por quê, mas não funciona para mim. PyCharm imprime um erro.

cmd.exe /K "<path-to-your-activate.bat>" Funciona, mas cria o mesmo virtualenv para cada projeto, mesmo que não seja necessário.

Este recibo está funcionando! Mas a string /env_yourenvlocate/scripts/activate.batdeve conter aspas, como esta "Full_path_to_your_env_locate\scripts\activate.bat"!

Desativar o virtualenv é muito fácil - digite no terminal 'desativar'

(virt_env) D:\Projects\src>deactivate
D:\Projects\src>

"Não sei por quê, mas não funciona para mim" - talvez porque essa solução seja boa para linux / mac - não para windows? ;)
Nir Alfasi

0

Solução para WSL (Ubuntu no Windows)

Se estiver usando WSL (Ubuntu no Windows), você também pode abrir o bash como terminal no pycharm e ativar um virtualenv do linux.

Use um .pycharmrcarquivo como descrito na resposta de Peter Gibson; Adicione o .pycharmrcarquivo ao seu diretório inicial com o seguinte conteúdo:

source ~/.bashrc
source ~/path_to_virtualenv/bin/activate

Em Arquivo Pycharm > Configurações> Ferramentas> Terminal, adicione o seguinte 'Caminho do shell':

"C:/Windows/system32/bash.exe" -c "bash --rcfile ~/.pycharmrc"


Virtualenv específico do projeto

O caminho para o seu virtualenv in .pycharmrcnão precisa ser absoluto. Você pode definir um virtualenv específico do projeto definindo um caminho relativo do diretório do projeto. Meu virtualenv está sempre localizado em uma pasta 'venv' no diretório do meu projeto, então meu .pycharmrcarquivo se parece com este:

source ~ / .bashrc
 source ~ / pycharmvenv / bin / activate #absolute path
source ./venv/bin/activate #relative path


BÔNUS: abre automaticamente o túnel ssh para conectar o virtualenv como intérprete do projeto

Adicione o seguinte ao seu .pycharmrcarquivo:

if [ $(ps -aux | grep -c 'ssh') -lt 2 ]; then
    sudo service ssh start 
fi

Isso verifica se um túnel ssh já está aberto e abre um caso contrário. Em Arquivo -> Configurações -> Projeto -> Intérprete do projeto no Pycharm, adicione um novo interpretador remoto com a seguinte configuração:

+ -------------------------- + ---------------------- ----------- + ------- + ---- +
| Nome: | <Nome do intérprete> | | |
| Selecione | 'Credenciais SSH' | | |
| Host: | 127.0.0.1 | Porto: | 22
| Usuário: | <Nome de usuário do Linux> | | |
| Tipo de autenticação: | 'Senha' | | |
| Senha: | <Senha do Linux> | | |
| Caminho do interpretador Python: | <Caminho do Linux para seu virtualenv> | | |
| Caminho dos ajudantes Python: | <Definir automaticamente> | | |
+ -------------------------- + ---------------------- ----------- + ------- + ---- +

Agora, quando você abre seu projeto, seu bash inicia automaticamente em seu virtualenv, abre um túnel ssh e o pycharm conecta o virtualenv como interpretador remoto.

aviso: a última atualização no Windows inicia automaticamente um serviço SshBroker e SshProxy na inicialização. Eles bloqueiam o túnel ssh do Linux para o Windows. Você pode interromper esses serviços em Gerenciador de Tarefas -> Serviços, após o qual tudo funcionará novamente.


0

Uma opção que você tem ao entrar no terminal> Executar> Depurar> Editar Configurações insira a descrição da imagem aqui

insira a descrição da imagem aqui

selecione o ambiente conda apropriado. Além disso, quando você cria um novo projeto - ele pede para configurar este local.

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.