Ambientes virtuais são uma ferramenta essencial no desenvolvimento Python. Eles permitem que cada projeto tenha suas próprias dependências, isoladas do sistema global e de outros projetos. Isso evita conflitos de versões e garante que o que funciona em um ambiente funcione em outro.

Nesta aula, vamos explorar o conceito de isolamento, criar ambientes virtuais com o módulo venv, ativá-los e gerenciar dependências com requirements.txt. Ao final, você terá uma base sólida para organizar seus projetos de forma profissional.

Por que isolar

Quando você instala pacotes globalmente no Python, eles ficam disponíveis para todos os projetos. Isso pode causar problemas: um projeto pode precisar da versão 1.0 de uma biblioteca, enquanto outro precisa da 2.0. Se você atualizar globalmente, um dos projetos pode quebrar. Além disso, projetos diferentes podem usar versões diferentes do mesmo pacote, e não há como manter isso sem isolamento.

Outro motivo para isolar é a reprodutibilidade. Quando você compartilha seu projeto com outras pessoas, ou o implanta em um servidor, é crucial que as mesmas versões das dependências sejam instaladas. Com um ambiente virtual e um arquivo requirements.txt, você garante que todos usem exatamente as mesmas versões, evitando o famoso problema "funciona na minha máquina".

Além disso, ambientes virtuais mantêm seu sistema operacional limpo, pois você não instala pacotes Python globalmente, o que pode ser difícil de gerenciar e remover. Isso é especialmente importante em sistemas Linux, onde o Python global é usado pelo próprio sistema.

venv

O módulo venv é a ferramenta padrão do Python para criar ambientes virtuais. Ele está disponível desde o Python 3.3 e é a maneira recomendada de isolar dependências. Com ele, você cria uma pasta que contém uma instalação isolada do Python e seus pacotes.

Para criar um ambiente virtual, use o comando python -m venv nome_do_ambiente. Isso criará uma pasta com o nome especificado, contendo uma estrutura como bin (ou Scripts no Windows) e lib. Dentro dessa estrutura, há um interpretador Python próprio e um diretório para instalar pacotes.

Vamos criar um ambiente virtual chamado venv dentro do diretório do seu projeto:

python -m venv venv

Esse comando cria a pasta venv no diretório atual. Você pode usar qualquer nome, mas é comum usar venv ou .venv para indicar que é um ambiente virtual. A partir daí, você pode ativá-lo para usar o Python e os pacotes desse ambiente.

É importante notar que o venv não é a única ferramenta; existem outras como virtualenv e conda, mas venv é o padrão incluído no Python e suficiente para a maioria dos casos.

Ativando

Ativar um ambiente virtual é o passo que faz com que os comandos python e pip apontem para o ambiente isolado, e não para o Python global. Isso é feito executando um script de ativação específico do seu sistema operacional.

No Linux ou macOS, o comando é:

source venv/bin/activate

No Windows (Prompt de Comando), o comando é:

venv\Scripts\activate.bat

No Windows (PowerShell), o comando é:

venv\Scripts\Activate.ps1

Após a ativação, você verá o nome do ambiente no prompt, geralmente entre parênteses, como (venv) C:\meu_projeto>. Isso indica que o ambiente está ativo. Agora, quando você executar python, usará o interpretador do ambiente, e pip instalará pacotes apenas nesse ambiente.

Para desativar o ambiente, basta executar o comando deactivate. Isso retorna ao Python global.

É importante ativar o ambiente sempre que for trabalhar no projeto. Se você abrir um novo terminal, precisará ativar novamente.

requirements.txt

O arquivo requirements.txt é um arquivo de texto que lista todas as dependências do projeto, geralmente com suas versões. Ele permite que você instale todas as dependências de uma vez com um único comando: pip install -r requirements.txt. Isso é fundamental para compartilhar o projeto e para implantação.

Para gerar o arquivo, você pode usar o comando pip freeze, que lista todos os pacotes instalados no ambiente ativo com suas versões exatas. Redirecione a saída para um arquivo:

pip freeze > requirements.txt

O arquivo gerado terá um formato como:

requests==2.31.0
flask==3.0.0
numpy==1.26.0

Você também pode criar o arquivo manualmente, especificando as versões desejadas. Por exemplo:

requests==2.31.0
flask==3.0.0

Ou usar intervalos de versão, como flask>=2.0, mas é recomendável fixar versões para garantir reprodutibilidade.

Quando outra pessoa clonar seu projeto, ela pode criar um ambiente virtual, ativá-lo e instalar todas as dependências com:

pip install -r requirements.txt

Isso garante que todos usem as mesmas versões.

Boas práticas

Aqui estão algumas boas práticas ao usar ambientes virtuais:

  • Sempre crie um ambiente virtual para cada projeto, mesmo para projetos pequenos.
  • Não inclua a pasta do ambiente virtual no controle de versão (por exemplo, Git). Adicione venv/ ao arquivo .gitignore.
  • Mantenha o arquivo requirements.txt atualizado sempre que adicionar ou remover dependências.
  • Use pip freeze para gerar o arquivo, mas revise-o para remover pacotes desnecessários.
  • Considere usar pip-tools ou poetry para gerenciamento mais avançado, mas venv + requirements.txt é suficiente para muitos casos.

Referências

Exercícios

  1. Crie um ambiente virtual chamado meu_env no diretório do seu projeto.

    ✓ Resposta: 
    python -m venv meu_env

  2. Ative o ambiente virtual no Linux/macOS e no Windows (escolha um e explique).

    ✓ Resposta: No Linux/macOS: source meu_env/bin/activate. No Windows (Prompt de Comando): meu_env\Scripts\activate.bat.

  3. Instale os pacotes requests e flask no ambiente ativo.

    ✓ Resposta: 
    pip install requests flask

  4. Gere o arquivo requirements.txt com as dependências instaladas.

    ✓ Resposta: 
    pip freeze > requirements.txt

  5. Desative o ambiente virtual e explique o que acontece.

    ✓ Resposta: Execute deactivate no terminal. Isso faz com que os comandos python e pip voltem a apontar para o Python global, e o prompt perde o nome do ambiente.