--- title: "UV: O Gerenciador de Pacotes Python Mais Rápido — 2026 | Python Brasil" url: "https://python.dev.br/blog/uv-gerenciador-pacotes-python/" markdown_url: "https://python.dev.br/blog/uv-gerenciador-pacotes-python.MD" description: "Conheça o UV, gerenciador de pacotes Python escrito em Rust que substitui pip e Poetry. Instalação, comandos e exemplos práticos." date: "2026-03-19" author: "Equipe Python Brasil" --- # UV: O Gerenciador de Pacotes Python Mais Rápido — 2026 | Python Brasil Conheça o UV, gerenciador de pacotes Python escrito em Rust que substitui pip e Poetry. Instalação, comandos e exemplos práticos. Se você trabalha com Python, já sabe que gerenciar pacotes e ambientes virtuais pode ser uma dor de cabeça. O pip é lento, o Poetry às vezes trava em resoluções de dependência, e o Conda é pesado demais para projetos simples. É aí que entra o **UV** — uma ferramenta criada pela [Astral](https://astral.sh/), a mesma equipe por trás do Ruff, que está revolucionando o ecossistema Python. O UV é um gerenciador de pacotes e ambientes virtuais escrito em Rust, projetado para ser **10 a 100 vezes mais rápido** que o pip. Neste artigo, vamos explorar tudo que você precisa saber para começar a usar o UV nos seus projetos. ## O que é o UV e por que ele importa? O UV é uma ferramenta unificada que substitui várias ferramentas do ecossistema Python de uma só vez: - **pip** — instalação de pacotes - **pip-tools** — compilação de requirements - **virtualenv/venv** — criação de ambientes virtuais - **Poetry/Pipenv** — gerenciamento de projetos e lockfiles - **pyenv** — gerenciamento de versões do Python Tudo isso em um único binário, sem dependências externas, e com uma velocidade absurda graças ao Rust. O UV usa um resolvedor de dependências paralelo e cache agressivo, o que significa que reinstalar pacotes que já foram baixados é praticamente instantâneo. ### Benchmarks reais Para dar uma ideia concreta da diferença de performance: | Operação | pip | UV | |----------|-----|-----| | Instalar Django | ~8s | ~0.3s | | Instalar requirements (100 pacotes) | ~45s | ~2s | | Criar virtualenv | ~3s | ~0.01s | | Resolver dependências (projeto grande) | ~30s | ~1s | Esses números variam conforme a máquina e a rede, mas a magnitude da diferença é consistente. ## Instalação do UV A instalação é simples e não requer Python previamente instalado: ```bash # No Linux e macOS curl -LsSf https://astral.sh/uv/install.sh | sh # No Windows (PowerShell) powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex" # Via pip (se preferir) pip install uv # Via Homebrew (macOS) brew install uv ``` Após a instalação, verifique se está funcionando: ```bash uv --version # uv 0.6.x ``` ## Gerenciando ambientes virtuais Uma das funcionalidades mais usadas do UV é a criação de ambientes virtuais: ```bash # Criar um ambiente virtual (padrão: .venv) uv venv # Criar com uma versão específica do Python uv venv --python 3.13 # Criar com nome personalizado uv venv meu-ambiente # Ativar o ambiente (mesmo processo de sempre) source .venv/bin/activate # Linux/macOS .venv\Scripts\activate # Windows ``` A criação de ambientes virtuais com UV é praticamente instantânea — o que antes levava alguns segundos com `python -m venv` agora leva milissegundos. ## Instalando pacotes O UV é compatível com a interface do pip, então a migração é simples: ```bash # Instalar pacotes uv pip install requests uv pip install "django>=5.0" uv pip install pandas numpy matplotlib # Instalar a partir de requirements.txt uv pip install -r requirements.txt # Atualizar um pacote uv pip install --upgrade requests # Desinstalar uv pip uninstall requests # Listar pacotes instalados uv pip list # Compilar requirements (equivalente ao pip-compile) uv pip compile requirements.in -o requirements.txt ``` ## Gerenciamento de projetos com `uv init` O UV também funciona como gerenciador de projetos completo, similar ao Poetry: ```bash # Iniciar um novo projeto uv init meu-projeto cd meu-projeto ``` Isso cria a seguinte estrutura: ``` meu-projeto/ ├── pyproject.toml ├── README.md ├── hello.py └── .python-version ``` O `pyproject.toml` gerado é limpo e direto: ```toml [project] name = "meu-projeto" version = "0.1.0" description = "Adicione sua descrição aqui" readme = "README.md" requires-python = ">=3.13" dependencies = [] ``` ### Adicionando dependências ao projeto ```bash # Adicionar dependência uv add requests uv add "fastapi>=0.110" # Adicionar dependência de desenvolvimento uv add --dev pytest ruff mypy # Remover dependência uv remove requests ``` Quando você usa `uv add`, o UV automaticamente: 1. Atualiza o `pyproject.toml` 2. Resolve todas as dependências 3. Gera/atualiza o `uv.lock` (lockfile) 4. Instala os pacotes no ambiente virtual ### O lockfile do UV O arquivo `uv.lock` é gerado automaticamente e garante reprodutibilidade: ```bash # Gerar/atualizar o lockfile uv lock # Instalar exatamente o que está no lockfile uv sync # Atualizar todas as dependências para as últimas versões compatíveis uv lock --upgrade ``` O lockfile do UV é cross-platform por padrão, o que significa que o mesmo arquivo funciona em Linux, macOS e Windows — algo que o Poetry não faz nativamente. ## Executando scripts e comandos O comando `uv run` é uma das funcionalidades mais práticas: ```bash # Executar um script Python uv run hello.py # Executar um módulo uv run -m pytest # Executar com dependência temporária (sem instalar no projeto) uv run --with rich python -c "from rich import print; print('[bold green]Funciona![/]')" ``` O `uv run` automaticamente cria o ambiente virtual se necessário, instala as dependências e executa o comando — tudo em um único passo. ### Scripts inline com dependências O UV suporta um recurso interessante: scripts Python com dependências declaradas inline: ```python # /// script # requires-python = ">=3.12" # dependencies = [ # "requests", # "rich", # ] # /// import requests from rich import print response = requests.get("https://api.github.com/repos/astral-sh/uv") data = response.json() print(f"[bold]UV tem {data['stargazers_count']:,} estrelas no GitHub![/]") ``` Salve isso como `exemplo.py` e execute com `uv run exemplo.py`. O UV vai instalar as dependências automaticamente antes de executar o script, sem precisar de um projeto ou ambiente virtual manual. ## Gerenciando versões do Python O UV também substitui o pyenv para gerenciar múltiplas versões do Python: ```bash # Listar versões disponíveis uv python list # Instalar uma versão específica uv python install 3.13 uv python install 3.12 3.11 # Fixar a versão do projeto uv python pin 3.13 # Ver qual versão está sendo usada uv python find ``` ## UV vs pip vs Poetry: comparação prática Vamos comparar um fluxo de trabalho típico nas três ferramentas: ### Criando um projeto e instalando dependências **Com pip:** ```bash python -m venv .venv source .venv/bin/activate pip install flask sqlalchemy alembic pip freeze > requirements.txt ``` **Com Poetry:** ```bash poetry new meu-projeto cd meu-projeto poetry add flask sqlalchemy alembic ``` **Com UV:** ```bash uv init meu-projeto cd meu-projeto uv add flask sqlalchemy alembic ``` O resultado é similar entre Poetry e UV, mas o UV completa a operação em uma fração do tempo. E diferente do pip, tanto o Poetry quanto o UV geram lockfiles para garantir reprodutibilidade. ### Quando usar cada ferramenta | Cenário | Recomendação | |---------|-------------| | Projetos novos | **UV** — mais rápido e moderno | | Projetos legados com requirements.txt | **UV** (`uv pip install -r`) — compatível | | Ciência de dados com pacotes C | **Conda** — ainda melhor para pacotes nativos complexos | | CI/CD pipelines | **UV** — velocidade faz diferença real | | Equipe que já usa Poetry | **UV** — migração é simples e vale a pena | ## Migrando de pip ou Poetry para UV ### De pip Se você tem um projeto com `requirements.txt`, a migração é instantânea: ```bash # Instalar UV curl -LsSf https://astral.sh/uv/install.sh | sh # Usar diretamente no lugar do pip uv pip install -r requirements.txt # Ou converter para projeto UV uv init uv add $(cat requirements.txt | grep -v '^#' | tr '\n' ' ') ``` ### De Poetry Se você usa Poetry com `pyproject.toml`, o UV já lê o mesmo formato: ```bash # Na maioria dos casos, basta: uv sync # Se precisar gerar o lockfile do UV: uv lock ``` O UV é compatível com o formato de dependências do `pyproject.toml` usado pelo Poetry, então a migração costuma ser transparente. ## Usando UV no CI/CD O UV brilha especialmente em pipelines de CI/CD, onde cada segundo conta: ```yaml # Exemplo com GitHub Actions / Gitea Actions - name: Instalar UV uses: astral-sh/setup-uv@v5 - name: Instalar dependências run: uv sync --frozen - name: Rodar testes run: uv run pytest ``` Com UV, pipelines que levavam 2 minutos para instalar dependências agora completam em 5-10 segundos. ## Conclusão O UV representa uma mudança de paradigma no ecossistema Python. Ele unifica ferramentas que antes eram separadas (pip, virtualenv, Poetry, pyenv) em uma única ferramenta ultrarrápida, sem sacrificar funcionalidade ou compatibilidade. Se você ainda está usando pip puro com `requirements.txt`, ou se o Poetry está te deixando na mão com resoluções lentas, vale muito a pena experimentar o UV. A curva de aprendizado é mínima — os comandos são intuitivos e a documentação é excelente. Para se aprofundar em gerenciamento de pacotes Python, confira nosso comparativo atualizado de [pip vs uv vs Poetry vs Conda](/blog/gerenciadores-de-pacotes-python/) e nosso guia sobre [ambientes virtuais](/blog/virtual-environments-python/). Se você está começando com Python, nosso [guia para iniciantes](/blog/como-comecar-com-python/) é o ponto de partida ideal. O futuro do gerenciamento de pacotes Python é rápido, e o UV está liderando essa revolução.