Por que e como você usa ambientes virtuais?

Question

Accepted Answer

Um **ambiente virtual** é um ambiente Python isolado com seus próprios pacotes instalados, separado do Python do sistema e de outros projetos. Ele resolve **conflitos de dependência** — diferentes projetos podem usar versões diferentes (até mesmo incompatíveis) do mesmo pacote.

## O problema que ele resolve

```text
Project A needs Django 3.2
Project B needs Django 4.2
→ Installing globally, they CONFLICT — you can't have both versions system-wide.
Virtual environments give each project its OWN isolated set of packages.
```

Sem isolamento, instalar pacotes globalmente leva a conflitos de versão entre projetos e pode quebrar ferramentas do sistema que dependem de versões específicas.

## Criando e usando um (venv integrado)

```bash
# 1. create a virtual environment (a folder named .venv)
python -m venv .venv

# 2. ACTIVATE it (shell-specific)
source .venv/bin/activate      # macOS/Linux
.venv\Scripts\activate         # Windows

# 3. now pip installs go INTO this env, isolated from the system
pip install django requests

# 4. when done
deactivate
```

Uma vez ativado, `python` e `pip` referem-se às cópias isoladas do ambiente — os pacotes são instalados apenas lá, não em todo o sistema.

## Capturando e reproduzindo dependências

```bash
pip freeze > requirements.txt       # record exact installed versions
pip install -r requirements.txt     # recreate the env elsewhere (teammate, CI, prod)
```

Um `requirements.txt` torna o ambiente **reproduzível** — qualquer pessoa pode recriar as mesmas dependências exatas, evitando problemas do tipo "funciona na minha máquina".

## Ferramentas modernas

```text
venv + pip      → built-in, standard, widely used
poetry          → dependency management + lockfile + packaging (popular)
pipenv          → combines pip + venv with a lockfile
uv / pdm        → newer, faster tools
conda           → common in data science (manages Python versions + non-Python deps too)
```

Ferramentas mais recentes (poetry, uv) adicionam arquivos de bloqueio e melhor resolução de dependências, mas o conceito central — ambientes isolados por projeto — é o mesmo.

## Sempre exclua o env do controle de versão

```text
# .gitignore
.venv/        ← don't commit the environment; commit requirements.txt/lockfile instead
```

## Por que isso importa

Ambientes virtuais são essenciais, prática padrão para qualquer projeto Python — eles previnem conflitos de dependência entre projetos e entre projetos e o Python do sistema, e (com `requirements.txt`/lockfiles) tornam os ambientes reproduzíveis em máquinas, colegas de equipe, CI e produção.

Ignorá-los leva a conflitos de versão, ferramentas de sistema quebradas e configurações não reproduzíveis.

Compreender como criar, ativar e capturar dependências — e o panorama de ferramentas modernas (poetry, uv) — é fundamental para o desenvolvimento Python profissional e uma expectativa básica em qualquer projeto real.