Passo 1 de 7
Entender o que um ambiente virtual separa
Entenda como ambientes virtuais mantêm separados os pacotes de diferentes projetos e reconheça os limites desse isolamento.
Trilha de aprendizado · Nível 5 · Tutorial 5
Criar um ambiente isolado para cada projeto e confirmar que terminal e editor usam o interpretador associado a esse ambiente.
Entender o que um ambiente virtual separa
Entenda como ambientes virtuais mantêm separados os pacotes de diferentes projetos e reconheça os limites desse isolamento. 2 min
Criar a pasta .venv do projeto
Prepare uma pasta local, escolha o comando do Python 3 e crie nela um ambiente virtual chamado .venv. 3 min
Executar o Python do ambiente sem ativar
Inicie diretamente o interpretador da pasta .venv pelo caminho correspondente ao seu sistema, sem depender de ativação. 2 min
Confirmar qual interpretador está em uso
Use evidências fornecidas pelo próprio Python para distinguir o interpretador base da .venv do projeto. 3 min
Ativar e desativar no terminal
Ative a .venv no terminal atual, confirme a mudança de interpretador e restaure a resolução anterior de comandos. 3 min
Alinhar o editor com o terminal
Selecione no editor o interpretador da .venv e compare as evidências do diagnóstico com a execução pelo terminal. 3 min
Aplicar o fluxo completo em um projeto
Crie uma nova .venv e reúna evidências de que o terminal ativado, o editor e a execução direta usam o interpretador correto. 3 min
Passo 1 de 7
Entenda como ambientes virtuais mantêm separados os pacotes de diferentes projetos e reconheça os limites desse isolamento.
Um ambiente virtual é um ambiente de pacotes separado, criado a partir de uma instalação de Python já existente.
Cada projeto pode ter seu próprio ambiente. Assim, os pacotes de terceiros disponíveis em um projeto não aparecem automaticamente no ambiente de outro. Esse isolamento ocorre por padrão entre os ambientes.
O Python usado como ponto de partida continua existindo: o ambiente virtual fica associado a ele, mas passa a oferecer ao projeto um local próprio para seu interpretador e seus pacotes.
Observe que uma instalação base pode dar origem a ambientes diferentes. Cada projeto mantém seus arquivos de código e seu próprio conjunto de pacotes.
Os dois projetos partem de uma instalação de Python, mas seus ambientes de pacotes permanecem separados.
Os arquivos .py são o código que você escreve e organiza no projeto. A pasta do ambiente virtual contém arquivos usados para executar Python e manter o ambiente de pacotes daquele projeto.
Mesmo quando essa pasta fica dentro da pasta do projeto, ela não deve ser confundida com o código-fonte. Nos próximos passos, você criará o código fora dela.
Exemplo
Imagine um projeto de relatórios e outro de gráficos. Cada um pode usar um conjunto diferente de pacotes — ou até versões diferentes de um mesmo pacote — sem que um ambiente altere o outro.
Não é necessário adicionar pacotes agora: o ponto importante é que cada ambiente possui seu próprio espaço para eles.
Atenção
Um venv não é uma máquina virtual e não cria uma barreira para proteger o computador. Um programa executado dentro dele ainda pode acessar recursos permitidos ao seu usuário, como arquivos e rede. Portanto, não use um ambiente virtual como justificativa para executar código desconhecido.
Dois projetos usam ambientes virtuais diferentes. O que isso significa?
Passo 2 de 7
Prepare uma pasta local, escolha o comando do Python 3 e crie nela um ambiente virtual chamado .venv.
Crie no seu computador uma pasta chamada ambiente-demo e abra o terminal dentro dela. Você pode fazer isso pelo gerenciador de arquivos ou navegar até a pasta com o terminal.
Antes de criar o ambiente, descubra qual comando inicia o Python 3 desejado na sua instalação. Normalmente será python, python3 ou, no Windows, py -3.
Teste os comandos aplicáveis ao seu sistema. Escolha um cuja saída comece com Python 3. Não é necessário que todos funcionem.
python --version
python3 --version
py -3 --versionDica
O ambiente será criado a partir do interpretador usado no comando. Por exemplo, se python3 --version mostrar a versão desejada, use python3 também na criação.
Com o terminal aberto em ambiente-demo, execute somente a linha correspondente ao comando de Python 3 que você escolheu. O módulo venv criará a pasta .venv dentro do projeto.
Escolha uma das três linhas, conforme o comando disponível no seu computador.
python -m venv .venv
python3 -m venv .venv
py -3 -m venv .venvDica
.venv é um nome convencional para o ambiente do projeto. Seus arquivos .py devem ficar na pasta do projeto, fora de .venv. A criação da pasta não significa que o ambiente já esteja ativado.
Após o comando terminar, procure .venv dentro de ambiente-demo. Como o nome começa com ponto, talvez seja necessário habilitar a exibição de itens ocultos.
No Windows, a estrutura deve conter uma pasta Scripts. No macOS e no Linux, deve conter uma pasta bin. Outros arquivos e pastas também são normais.
A pasta do projeto contém o código do aluno e a .venv como elementos separados. Apenas a estrutura interna principal muda entre os sistemas.
O código permanece fora de .venv; procure Scripts no Windows ou bin no macOS/Linux.
Atenção
Em algumas instalações Linux, o comando pode informar que venv ou ensurepip não está disponível. Nesse caso, instale pelo gerenciador do sistema o componente de venv correspondente à versão usada — por exemplo, python3-venv ou um pacote específico como python3.12-venv em distribuições baseadas em Debian. O nome e o comando variam conforme a distribuição; consulte a documentação dela ou peça ajuda ao administrador. Depois, repita a criação.
No seu computador, conclua a criação e relate: qual versão do Python 3 você escolheu, qual comando executou e se encontrou Scripts ou bin dentro de .venv. Não envie arquivos.
Escreva pelo menos 40 caracteres (0/40).
Passo 3 de 7
Inicie diretamente o interpretador da pasta .venv pelo caminho correspondente ao seu sistema, sem depender de ativação.
A .venv criada no projeto já contém um interpretador Python. Você pode iniciá-lo diretamente, informando o caminho até o executável — não é necessário ativar o ambiente.
O caminho relativo funciona a partir da pasta atual do terminal. Por isso, nos próximos comandos, mantenha o terminal aberto na pasta ambiente-demo, que contém a .venv.
A estrutura interna muda conforme o sistema, mas a ideia é a mesma: partir da pasta do projeto e indicar diretamente o executável dentro da .venv.
No Windows, o executável fica em Scripts; no macOS e Linux, fica em bin.
Execute somente a linha correspondente ao seu sistema e terminal. A opção --version inicia o executável indicado e mostra sua versão do Python.
Execute com o terminal na pasta ambiente-demo.
.\.venv\Scripts\python.exe --versionO prefixo ./ indica que o caminho começa na pasta atual.
./.venv/bin/python --versionExemplo
Se o Python base usado na criação mostrou Python 3.12.4, é esperado que o comando direto da .venv também mostre Python 3.12.4.
Essa saída confirma apenas que o executável indicado iniciou. A versão, sozinha, não identifica conclusivamente qual ambiente está em uso, pois o Python base e diferentes ambientes podem ter a mesma versão. A verificação conclusiva será feita no próximo passo.
Os comandos anteriores usam caminhos relativos à pasta atual. Se o terminal estiver em outra pasta, volte para ambiente-demo ou informe o caminho absoluto até o executável.
Quando um caminho contiver espaços, coloque-o entre aspas. No PowerShell, um caminho entre aspas precisa do operador de chamada & para ser executado.
Substitua os caminhos ilustrativos pelo caminho real no seu computador e execute apenas o exemplo correspondente ao seu terminal.
# PowerShell
& "C:\Meus Projetos\ambiente-demo\.venv\Scripts\python.exe" --version
# Prompt de Comando
"C:\Meus Projetos\ambiente-demo\.venv\Scripts\python.exe" --version
# macOS/Linux — bash ou zsh
"/home/usuario/Meus Projetos/ambiente-demo/.venv/bin/python" --versionDica
Se o terminal já estiver em ambiente-demo, prefira o caminho relativo curto. Use um caminho absoluto quando precisar executar a .venv a partir de outra pasta.
Com o terminal aberto em ambiente-demo, digite o comando completo adequado ao seu sistema para iniciar diretamente o Python da .venv e mostrar a versão. Responda com apenas uma opção: a que corresponde ao terminal que você usa.
O Python base e o comando direto da .venv exibiram a mesma versão. Qual interpretação está correta?
Passo 4 de 7
Use evidências fornecidas pelo próprio Python para distinguir o interpretador base da .venv do projeto.
O módulo sys permite conferir o interpretador que realmente iniciou o programa:
sys.executable: caminho do executável Python em uso.sys.prefix: prefixo do ambiente atual.sys.base_prefix: prefixo da instalação base que originou o ambiente.Em um ambiente criado com venv, sys.prefix != sys.base_prefix resulta em True. No Python base, normalmente resulta em False.
O resultado True comprova que há um ambiente virtual em uso, mas não garante que seja a .venv deste projeto. Para isso, confira também se sys.executable aponta para a pasta .venv esperada.
No Python base, os prefixos coincidem. Na venv, o prefixo atual muda e o executável deve apontar para a .venv correta.
Na pasta principal do projeto, crie um arquivo chamado diagnostico.py. Ele deve ficar ao lado da pasta .venv, e não dentro dela. Esse mesmo script será reutilizado nas próximas verificações.
Código completo do diagnóstico:
import sys
print(f"Executável: {sys.executable}")
print(f"Prefixo atual: {sys.prefix}")
print(f"Prefixo base: {sys.base_prefix}")
print(f"Está em venv: {sys.prefix != sys.base_prefix}")Dica
Compare a relação entre os caminhos, não os valores literais dos exemplos. Procure a pasta do projeto e o trecho .venv no valor de Executável.
Com o terminal aberto na pasta do projeto e sem depender de ativação, primeiro execute o script com o comando do Python base que você escolheu ao criar o ambiente. Depois, execute-o pelo caminho direto da .venv.
Use a linha correspondente ao seu sistema. Substitua python por python3 ou py -3 na primeira execução, caso esse tenha sido seu comando base.
# Python base escolhido
python diagnostico.py
# Windows — PowerShell ou Prompt de Comando
.\.venv\Scripts\python.exe diagnostico.py
# macOS/Linux — bash ou zsh
./.venv/bin/python diagnostico.pyExemplo
Na execução pelo Python base, Prefixo atual e Prefixo base tendem a ser iguais, e Está em venv mostra False.
Na execução pelo caminho direto, Está em venv mostra True. Além disso, Executável deve apontar para .venv\Scripts\python.exe no Windows ou .venv/bin/python no macOS/Linux.
Se aparecer True, mas o executável apontar para a .venv de outro projeto, existe uma venv em uso — porém não a venv desejada.
Uma execução mostra Está em venv: True, mas sys.executable aponta para outro_projeto/.venv/.../python. O que isso comprova?
Execute diagnostico.py pelo caminho direto do Python virtual. Registre o valor de Executável, informe se Está em venv mostrou True ou False e justifique se a execução corresponde à .venv deste projeto.
Escreva pelo menos 80 caracteres (0/80).
Passo 5 de 7
Ative a .venv no terminal atual, confirme a mudança de interpretador e restaure a resolução anterior de comandos.
Ativar a .venv não cria nem inicia outro Python. A ativação apenas ajusta temporariamente o terminal atual para colocar a pasta Scripts ou bin da .venv no início do PATH — a lista de pastas consultada para localizar comandos.
Assim, ao digitar python, o terminal prioriza o interpretador da .venv. Esse ajuste vale somente para a sessão em que a ativação foi executada.
Antes da ativação, o comando python segue a resolução normal do terminal. Depois, o executável da .venv passa a ter prioridade.
A ativação muda a prioridade de busca do comando; ela não substitui nem apaga o Python base.
Com o terminal aberto na pasta ambiente-demo, execute somente o comando correspondente ao shell que você está usando. No Windows, PowerShell e Prompt de Comando usam scripts diferentes.
Execute o script de ativação do PowerShell:
.\.venv\Scripts\Activate.ps1No Prompt de Comando, use o arquivo em lote:
.venv\Scripts\activate.batEm bash ou zsh, carregue o script com source:
source .venv/bin/activateApós ativar, o prompt pode mostrar (.venv), mas isso é apenas uma pista. A confirmação deve vir do arquivo diagnostico.py já criado: execute-o com python e confira o caminho de Executável e se Está em venv mostra True.
Depois, use deactivate. Isso restaura a resolução anterior de comandos, sem excluir a .venv e sem encerrar programas que já foram iniciados. Mudar de pasta não desativa o ambiente; abrir outro terminal cria outra sessão, que não fica ativada automaticamente.
Na primeira medição, execute somente o comando base que você usou para criar a .venv. Durante a ativação, use python. Depois de deactivate, execute exatamente o mesmo comando base usado na primeira medição.
# ANTES DE ATIVAR — execute somente uma alternativa:
python diagnostico.py
# ou: python3 diagnostico.py
# ou: py -3 diagnostico.py
# Execute agora o comando de ativação adequado ao seu terminal.
# DURANTE A ATIVAÇÃO — use esta linha:
python diagnostico.py
# Restaure a resolução anterior:
deactivate
# DEPOIS DE DESATIVAR — repita exatamente a alternativa inicial:
python diagnostico.py
# ou: python3 diagnostico.py
# ou: py -3 diagnostico.pyAtenção
Não altere políticas de execução para concluir esta prática. Continue usando diretamente o interpretador da .venv pelo caminho já conhecido ou abra o Prompt de Comando na pasta ambiente-demo e execute .venv\Scripts\activate.bat.
Dica
Mesmo sem ativação, o ambiente continua utilizável. A ativação apenas torna mais conveniente digitar python em vez do caminho completo do interpretador virtual.
Associe cada terminal ao comando correto para ativar a .venv.
Toque em um item e depois no par correspondente.
Execute o diagnóstico antes da ativação, durante a ativação e depois de deactivate. Na última execução, repita exatamente o comando base usado na primeira. Relate o comando executado, o caminho mostrado por sys.executable e se sys.prefix era igual ou diferente de sys.base_prefix em cada momento.
Escreva pelo menos 80 caracteres (0/80).
Passo 6 de 7
Selecione no editor o interpretador da .venv e compare as evidências do diagnóstico com a execução pelo terminal.
Ativar a .venv em um terminal e selecionar um interpretador no editor são configurações distintas. O terminal ativado resolve o comando python pela .venv, enquanto o botão de executar do editor usa o interpretador escolhido para o projeto.
Por isso, uma configuração correta não garante automaticamente a outra. O objetivo é fazer as duas apontarem para o executável da .venv de ambiente-demo.
As duas formas de execução devem convergir para o mesmo executável dentro da .venv do projeto.
Terminal e editor são configurados separadamente, mas devem executar o Python da mesma .venv.
Abra a pasta ambiente-demo como projeto no editor e escolha o executável correspondente ao seu sistema:
.venv\Scripts\python.exe.venv/bin/pythonNo VS Code, abra a Paleta de Comandos, procure Python: Select Interpreter e escolha o interpretador localizado em .venv.
No PyCharm, abra as configurações do projeto, acesse Python Interpreter e selecione ou adicione um interpretador local existente. Os nomes exatos dos menus podem variar conforme a versão.
Dica
Use a opção de informar ou procurar manualmente o caminho do interpretador. Navegue até ambiente-demo/.venv e selecione Scripts\python.exe no Windows ou bin/python no macOS e Linux. Não selecione apenas a pasta .venv: indique o executável dentro dela.
Primeiro, ative a .venv no terminal como no passo anterior e execute python diagnostico.py. Depois, abra diagnostico.py no editor e use o comando ou botão do editor para executar o arquivo Python.
Compare as duas saídas. Em ambas:
Executável deve apontar para a .venv de ambiente-demo;Está em venv deve mostrar True;Prefixo atual e Prefixo base devem ser diferentes.Se houver divergência, selecione novamente o interpretador do projeto no editor e repita a execução.
Exemplo
No Windows, as duas execuções devem indicar um caminho terminado em ambiente-demo\.venv\Scripts\python.exe. No macOS ou Linux, devem indicar um caminho terminado em ambiente-demo/.venv/bin/python.
O início e a apresentação dos caminhos podem variar. O importante é que ambos pertençam à .venv deste projeto.
Dica
O editor pode ativar automaticamente a .venv em seu terminal integrado. Isso confirma apenas a configuração daquele terminal. Execute também diagnostico.py pelo comando ou botão de execução do editor, pois essa ação pode usar outro interpretador.
Execute diagnostico.py no terminal com a .venv ativada e pelo comando de executar do editor. Relate o valor de Executável e o resultado de Está em venv nas duas execuções. Se os resultados divergirem, corrija a seleção do interpretador no editor, repita o diagnóstico e descreva o que mudou.
Escreva pelo menos 80 caracteres (0/80).
Passo 7 de 7
Crie uma nova .venv e reúna evidências de que o terminal ativado, o editor e a execução direta usam o interpretador correto.
Crie uma nova pasta local chamada ambiente-final e abra um terminal nela. Nesta aplicação, você repetirá o fluxo completo: escolherá o Python 3 base, criará .venv, salvará diagnostico.py fora do ambiente e verificará o mesmo interpretador por três rotas diferentes.
A confirmação final reúne três formas de executar o projeto. Todas devem chegar ao executável localizado na .venv de ambiente-final.
Criar a pasta não basta: as três rotas de execução devem usar a .venv correta.
Na pasta ambiente-final, confira o Python 3 escolhido e execute somente a variante correspondente.
# Escolha um comando para conferir a versão
python --version
python3 --version
py -3 --version
# Depois, execute somente a variante correspondente
python -m venv .venv
python3 -m venv .venv
py -3 -m venv .venvCrie este arquivo na pasta ambiente-final, ao lado de .venv.
import sys
print(f"Executável: {sys.executable}")
print(f"Prefixo atual: {sys.prefix}")
print(f"Prefixo base: {sys.base_prefix}")
print(f"Está em venv: {sys.prefix != sys.base_prefix}").venv e execute python diagnostico.py. Depois, use deactivate..venv como interpretador do projeto e execute diagnostico.py pelo comando ou botão de executar do editor.diagnostico.py informando diretamente o caminho do Python da .venv.Nas três saídas, Executável deve pertencer a ambiente-final/.venv, Está em venv deve mostrar True e os prefixos atual e base devem ser diferentes.
Use somente os comandos correspondentes ao seu sistema e terminal. A execução direta deve ocorrer depois de deactivate.
# Windows — PowerShell
.\.venv\Scripts\Activate.ps1
python diagnostico.py
deactivate
.\.venv\Scripts\python.exe diagnostico.py
# Windows — Prompt de Comando
.venv\Scripts\activate.bat
python diagnostico.py
deactivate
.venv\Scripts\python.exe diagnostico.py
# macOS ou Linux — bash ou zsh
source .venv/bin/activate
python diagnostico.py
deactivate
./.venv/bin/python diagnostico.pyAtenção
Para esta atividade, não substitua a evidência do terminal ativado por outra execução direta. Abra o Prompt de Comando na pasta ambiente-final, execute .venv\Scripts\activate.bat, rode python diagnostico.py e use deactivate. Só depois faça a terceira verificação com .venv\Scripts\python.exe diagnostico.py.
Dica
Está em venv: True confirma que existe um ambiente virtual em uso. O valor de Executável é que permite conferir se ele pertence especificamente à .venv de ambiente-final.
Relate: o comando usado para criar .venv; o valor ou final relevante de Executável nas execuções pelo terminal ativado, pelo editor e pelo caminho direto após deactivate; o resultado de Está em venv; e se os prefixos eram diferentes. Conclua se as três rotas usaram a mesma .venv.
Escreva pelo menos 120 caracteres (0/120).
Resumo
Um ambiente estar criado não significa que ele esteja sendo usado. A confirmação depende das evidências fornecidas pelo Python.
.venv com o módulo venv.deactivate.sys.executable, sys.prefix e sys.base_prefix..venv existente de uma .venv efetivamente usada.Parabéns! Você concluiu: Criar ambientes virtuais com venv
Parabéns! Você já consegue criar uma .venv e confirmar que terminal e editor usam o interpretador correto.
100 XP
Milhares de cursos online em vídeo, ebooks e áudiobooks.
Para testar seus conhecimentos no decorrer dos cursos online
Gerado diretamente na galeria de fotos do seu celular e enviado ao seu e-mail
Baixe nosso aplicativo pelo QR Code ou pelos links abaixo:.
Leve o conhecimento no seu bolso.
Baixe o aplicativo Cursa.
São centenas de Cursos gratuitos a disposição, com Certificado de conclusão gratuito que é salvo em sua galeria de imagens do celular.
Baixe o app para ter acesso ao Certificado de conclusão de Curso Gratuitamente.
+ de 10 milhões
de alunos
Certificado grátis e
válido em todo o Brasil
60 mil exercícios
gratuitos
4,8/5 classificação
nas lojas de apps
Cursos gratuitos em
vídeo, ebooks e audiobooks
