pip É Lento, Poetry Complexo: UV Chegou Resolvendo o Python
Introdução#
Se você já trabalhou com Python por mais de cinco minutos, provavelmente já viveu esse ritual: criar um ambiente virtual com venv, instalar pacotes com pip, descobrir que precisa do pip-tools para gerar um lockfile, usar pyenv para trocar de versão do Python, considerar o Poetry mas desistir da complexidade, e eventualmente aceitar que o gerenciamento de dependências em Python é um exercício de paciência.
O ecossistema Python sempre foi assim — poderoso, mas fragmentado. Cada ferramenta resolve um pedaço do problema. Nenhuma resolve tudo. E o desenvolvedor fica no meio, colando peças como um quebra-cabeça infinito.
Isso mudou. Em fevereiro de 2024, a Astral — a mesma empresa por trás do Ruff, o linter Python mais rápido do mundo — lançou o UV: um gerenciador de pacotes, ambientes virtuais e versões do Python escrito em Rust, até 100 vezes mais rápido que o pip. E ele não veio para ser mais uma peça do quebra-cabeça. Ele veio para ser o quebra-cabeça inteiro.
Neste artigo, vamos explorar:
- A história do Python — quem criou, quando, e quem mantém hoje
- Por que Python ganhou tanta notoriedade nos últimos anos
- O problema de fragmentação que o UV resolve
- O que é o UV, quem criou, e como usá-lo na prática
- E a pergunta que não cala: em aplicações complexas, com padrões arquiteturais e modularidade, Python compete com C#?
Se você já usa Python ou está avaliando se deve usá-lo, este artigo é para você.
Python: Uma Breve História#
Origens#
O Python foi criado por Guido van Rossum, um programador holandês que trabalhava no CWI (Centrum Wiskunde & Informatica) em Amsterdã. O desenvolvimento começou no final de 1989, e a primeira versão pública — Python 0.9.0 — foi lançada em fevereiro de 1991.
O nome não tem nada a ver com cobras. Guido era fã do grupo de comédia britânico Monty Python, e queria um nome curto, misterioso e levemente irreverente. Funcionou.
Filosofia#
Desde o início, Python foi projetado com uma filosofia clara: legibilidade acima de tudo. Onde outras linguagens usam chaves {} e ponto-e-vírgula ;, Python usa indentação. A ideia era que o código deveria ser tão fácil de ler quanto de escrever.
Essa filosofia foi formalizada no Zen of Python (PEP 20), que você pode ver rodando import this no interpretador:
import this
Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Readability counts.
There should be one -- and preferably only one -- obvious way to do it.
💡 O Zen of Python não é apenas poesia — ele guia decisões de design da linguagem até hoje.
Guido e o BDFL#
Por quase três décadas, Guido atuou como BDFL — Benevolent Dictator For Life (Ditador Benevolente Vitalício). Ele tinha a palavra final sobre qualquer decisão de design da linguagem.
Isso mudou em julho de 2018, quando a controversa PEP 572 (que introduziu o operador :=, apelidado de walrus operator) gerou debates tão intensos na comunidade que Guido decidiu se afastar. Ele renunciou ao título de BDFL e se aposentou da liderança direta.
Quem mantém Python hoje#
Desde 2019, Python é governado por um Steering Council — um comitê eleito de cinco membros que toma as decisões de design e direção da linguagem. O conselho é eleito pela comunidade de core developers a cada release. Por trás do Steering Council está a Python Software Foundation (PSF), uma organização sem fins lucrativos que cuida da infraestrutura, eventos, financiamento e proteção da marca Python.
ℹ️ Guido van Rossum trabalhou na Dropbox (2013–2019) e depois na Microsoft (2020–2023), onde contribuiu significativamente para a performance do CPython (o interpretador padrão). Hoje segue como core developer emeritus, mas sem poder de veto.
Versões marcantes#
| Ano | Versão | Marco |
|---|---|---|
| 1991 | 0.9.0 | Primeira versão pública |
| 2000 | 2.0 | List comprehensions, garbage collector |
| 2008 | 3.0 | Quebra de compatibilidade com Python 2 (migração dolorosa que durou mais de uma década) |
| 2015 | 3.5 | async/await nativo, type hints (PEP 484) |
| 2016 | 3.6 | f-strings (f"Hello {name}") — mudou a forma de formatar strings para sempre |
| 2020 | 3.9 | Merge de dicionários com |
| 2022 | 3.11 | Melhorias de performance de 10-60% (projeto Faster CPython de Guido na Microsoft) |
| 2023 | 3.12 | Per-interpreter GIL (início do caminho para remover o GIL) |
| 2024 | 3.13 | Free-threaded mode experimental (sem GIL) |
⚠️ A migração de Python 2 para Python 3 foi uma das mais dolorosas da história da computação. Levou mais de 12 anos — Python 2 só teve seu EOL (End of Life) em janeiro de 2020. Essa experiência traumática moldou a comunidade: desde então, Python evita quebras de compatibilidade a todo custo.
Por Que Python Ganhou Tanta Notoriedade#
Se em 2010 alguém te dissesse que Python seria a linguagem mais popular do mundo em poucos anos, você provavelmente duvidaria. Naquela época, o reinado era de Java, C e C++. Python era visto como linguagem de script, boa para automação e pouco mais. O que mudou?
A revolução dos dados e da IA#
A ascensão da ciência de dados, do machine learning e da inteligência artificial colocou Python no centro do mapa. Não porque Python fosse a linguagem mais rápida ou mais robusta — mas porque o ecossistema se formou ao redor dela:
| Área | Bibliotecas Python dominantes |
|---|---|
| Computação numérica | NumPy, SciPy |
| Análise de dados | Pandas, Polars |
| Machine Learning | scikit-learn, XGBoost, LightGBM |
| Deep Learning | TensorFlow, PyTorch, Keras |
| IA Generativa | LangChain, Hugging Face Transformers, OpenAI SDK |
| Visualização | Matplotlib, Seaborn, Plotly |
| Notebooks | Jupyter, Google Colab |
Quando TensorFlow (Google, 2015) e PyTorch (Meta, 2016) escolheram Python como interface principal, o destino estava selado. Pesquisadores, cientistas de dados e engenheiros de ML se concentraram em Python, e o efeito de rede fez o resto.
Adoção acadêmica#
Universidades no mundo inteiro passaram a ensinar programação com Python em vez de Java ou C. O MIT trocou seu curso introdutório para Python em 2009. Stanford seguiu. A consequência: uma geração inteira de desenvolvedores cresceu com Python como primeira linguagem.
Versatilidade#
Python não é apenas para IA. Ele tem presença relevante em:
- Web: Django (full-stack), FastAPI (APIs modernas), Flask (microframework)
- Automação e DevOps: Ansible, scripts de infraestrutura, CI/CD
- Scripting: substituição de Bash para tarefas complexas
- APIs e microsserviços: com FastAPI + Pydantic
- Educação: pela sintaxe limpa e barreira de entrada baixa
Python em números (2025–2026)#
| Indicador | Posição / Métrica |
|---|---|
| TIOBE Index | #1 (líder desde 2021) |
| Stack Overflow Survey 2025 | Top 3 linguagens mais usadas |
| GitHub Octoverse 2025 | #1 em novos repositórios |
| PyPI (repositório oficial) | 600.000+ pacotes publicados |
| Downloads mensais (PyPI) | 15+ bilhões |
💡 Python não é necessariamente a melhor linguagem para cada problema. Mas é a linguagem com o menor atrito para começar — e isso conta muito quando o objetivo é validar ideias, prototipar ou iterar rapidamente.
O Problema Que UV Resolve#
Agora que entendemos por que Python é tão popular, vamos ao ponto que todo desenvolvedor Python conhece bem: o caos do gerenciamento de pacotes e ambientes.
O ecossistema antes do UV#
A história do gerenciamento de dependências em Python é uma história de fragmentação. Cada ferramenta resolve um pedaço do problema, mas nenhuma resolve tudo:
| Ferramenta | O que faz | O que NÃO faz | Problema |
|---|---|---|---|
| pip | Instala pacotes | Não gerencia ambientes, não faz lockfile nativo | Lento (resolução em Python puro), sem reprodutibilidade |
| virtualenv / venv | Cria ambientes virtuais | Não instala pacotes, não gerencia versões do Python | É apenas uma peça do quebra-cabeça |
| pip-tools | Gera lockfile (requirements.txt pinado) | Não gerencia ambientes nem versões do Python | Exige combinação manual com pip + venv |
| Pipenv | Combina pip + virtualenv + lockfile | Performance ruim, manutenção instável | Praticamente abandonado pela comunidade |
| Poetry | Gerencia pacotes, venv, lockfile, build | Não gerencia versões do Python | Complexo, lento, resolve tudo mas com custo |
| Conda | Gerencia pacotes + ambientes + Python + C/Fortran | Mundo paralelo ao PyPI | Conflitos com pip, ecossistema isolado |
| pyenv | Gerencia versões do Python | Não instala pacotes, não gerencia ambientes | Mais uma ferramenta para aprender |
| pipx | Executa ferramentas Python isoladas | Não é para projetos | Escopo limitado |
O fluxo típico antes do UV#
Para montar um projeto Python “direito” antes do UV, o desenvolvedor precisava combinara múltiplas ferramentas:
# ❌ Fluxo fragmentado (antes do UV)
# 1. Instalar a versão certa do Python
pyenv install 3.12.1
pyenv local 3.12.1
# 2. Criar ambiente virtual
python -m venv .venv
source .venv/bin/activate # Linux/macOS
# .venv\Scripts\Activate.ps1 # Windows
# 3. Instalar dependências
pip install fastapi uvicorn
# 4. Gerar lockfile (se usando pip-tools)
pip install pip-tools
pip-compile requirements.in -o requirements.txt
# 5. Executar ferramentas de linting (se usando pipx)
pipx install ruff
ruff check .
Cinco ferramentas diferentes. Cinco comandos de instalação. Cinco coisas para documentar e explicar para quem chega no projeto. Esse é o problema que o UV resolve.
⚠️ O Poetry tentou unificar parte desse fluxo, e para muitos projetos funciona bem. Mas a resolução de dependências é lenta (escrita em Python), o
pyproject.tomltem convenções próprias que divergem dos padrões PEP, e ele ainda exigepyenvseparado para gerenciar versões do Python.
UV: O Que É e Quem Criou#
A Astral e Charlie Marsh#
O UV foi criado pela Astral, uma empresa fundada por Charlie Marsh em 2023. Charlie é um engenheiro de software americano que antes de fundar a Astral trabalhava com infraestrutura Python e percebeu que as ferramentas fundamentais do ecossistema estavam décadas atrás do que outras linguagens ofereciam.
A Astral já era conhecida pelo Ruff — um linter e formatter para Python escrito em Rust que é 100 a 300 vezes mais rápido que ferramentas equivalentes como Flake8 e Black. O sucesso do Ruff provou que reescrever tooling Python em Rust gerava ganhos reais e imensos.
Em fevereiro de 2024, a Astral lançou o UV com a mesma premissa: pegar o que o ecossistema Python fazia de forma lenta e fragmentada e reescrever em Rust, rápido e unificado.
💡 A Astral recebeu investimento de US$ 4 milhões da Accel para desenvolver o UV e o Ruff. Charlie Marsh é ex-engenheiro do Spring Health e do Khan Academy.
O que o UV faz#
O UV é um toolkit unificado para Python, escrito em Rust. Ele substitui — sozinho — as seguintes ferramentas:
┌─────────────────────────────────────────────────────────┐
│ UV │
│ │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ Gerenciador │ │ Ambientes │ │ Versões do │ │
│ │ de pacotes │ │ virtuais │ │ Python │ │
│ │ (pip, │ │ (virtualenv, │ │ (pyenv) │ │
│ │ pip-tools) │ │ venv) │ │ │ │
│ └──────────────┘ └──────────────┘ └──────────────┘ │
│ │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ Gerenciador │ │ Execução │ │ Lockfile │ │
│ │ de projetos │ │ de scripts │ │ nativo │ │
│ │ (poetry) │ │ e tools │ │ (uv.lock) │ │
│ │ │ │ (pipx) │ │ │ │
│ └──────────────┘ └──────────────┘ └──────────────┘ │
│ │
└─────────────────────────────────────────────────────────┘
Em termos concretos:
| Capacidade | Ferramenta que substitui | Comando UV |
|---|---|---|
| Instalar pacotes | pip install | uv add / uv pip install |
| Criar ambiente virtual | python -m venv | uv venv (automático) |
| Gerar lockfile | pip-compile (pip-tools) | uv lock (automático) |
| Gerenciar versões do Python | pyenv install | uv python install |
| Criar projeto | poetry init | uv init |
| Executar ferramentas | pipx run | uvx |
| Executar scripts | python script.py | uv run script.py |
Velocidade#
A diferença de velocidade não é incremental — é de outra ordem de grandeza:
| Operação | pip | UV | Fator |
|---|---|---|---|
| Instalar dependências (cache frio) | ~22s | ~1.2s | 18x mais rápido |
| Instalar dependências (cache quente) | ~5s | ~0.06s | 80x mais rápido |
| Resolução de dependências | segundos a minutos | milissegundos | 10-100x mais rápido |
| Criar ambiente virtual | ~1.5s | ~0.01s | 150x mais rápido |
📌 Esses números variam conforme o projeto e o ambiente, mas a ordem de grandeza é consistente. O UV faz em milissegundos o que o pip faz em segundos — e em segundos o que o pip faz em minutos.
Essa velocidade não é acidente. O UV é escrito em Rust, com resolução de dependências implementada em um solver SAT otimizado (PubGrub), cache agressivo, downloads paralelos e zero overhead de interpretador Python.
UV na Prática#
Chega de teoria. Vamos ver o UV funcionando.
Instalação#
# Windows (PowerShell)
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
# Linux / macOS
curl -LsSf https://astral.sh/uv/install.sh | sh
# Via pip (se preferir — mas perde parte da graça)
pip install uv
# Via Homebrew (macOS)
brew install uv
Após instalar, verifique:
uv --version
uv 0.6.x
Criar um projeto novo#
uv init meu-projeto-api
cd meu-projeto-api
O UV gera a seguinte estrutura:
meu-projeto-api/
├── .python-version # Versão do Python fixada
├── pyproject.toml # Metadados e dependências do projeto
├── README.md
└── main.py # Entrypoint básico
O pyproject.toml gerado segue os padrões PEP (621, 517):
[project]
name = "meu-projeto-api"
version = "0.1.0"
description = "Add your description here"
readme = "README.md"
requires-python = ">=3.12"
dependencies = []
💡 Diferente do Poetry, que usa chaves proprietárias como
[tool.poetry], o UV segue os padrões PEP oficiais. Isso significa que seupyproject.tomlé compatível com qualquer ferramenta que siga as PEPs.
Adicionar dependências#
# Adicionar dependências de produção
uv add fastapi uvicorn[standard]
# Adicionar dependências de desenvolvimento
uv add --dev pytest ruff mypy
O que acontece por baixo:
- O UV atualiza o
pyproject.tomlcom as novas dependências - Resolve todas as dependências (em milissegundos)
- Gera/atualiza o
uv.lock— um lockfile com hashes e versões exatas - Cria o ambiente virtual (
.venv/) automaticamente, se não existir - Instala tudo no ambiente virtual
Tudo em um único comando. Em menos de dois segundos.
Executar o projeto#
# Executar diretamente (UV ativa o venv automaticamente)
uv run uvicorn main:app --reload
# Ou executar qualquer script Python
uv run python main.py
💡 Não precisa ativar o ambiente virtual manualmente. O
uv runfaz isso por você. Acabou osource .venv/bin/activate.
Gerenciar versões do Python#
# Listar versões disponíveis
uv python list
# Instalar uma versão específica
uv python install 3.12
# Fixar a versão do projeto
uv python pin 3.12
O UV baixa e gerencia as versões do Python sem precisar do pyenv. Funciona em Windows, Linux e macOS.
Executar ferramentas sem instalar#
# Executar o Ruff sem instalar no projeto
uvx ruff check .
# Executar o Black sem instalar
uvx black --check .
# Executar qualquer ferramenta do PyPI
uvx httpie https://api.github.com
O uvx é equivalente ao npx do Node.js — executa ferramentas Python em ambientes temporários, sem poluir seu projeto.
Fluxo completo com UV#
Lembra do fluxo fragmentado com cinco ferramentas? Agora com UV:
# ✅ Fluxo unificado com UV
# 1. Criar projeto (já fixa a versão do Python)
uv init meu-projeto
cd meu-projeto
# 2. Instalar dependências (cria venv + lockfile automaticamente)
uv add fastapi uvicorn[standard]
uv add --dev pytest ruff
# 3. Executar (ativa venv automaticamente)
uv run uvicorn main:app --reload
# 4. Rodar testes
uv run pytest
# 5. Linting (sem instalar no projeto)
uvx ruff check .
Uma ferramenta. Cinco linhas. Zero fricção.
📖 Artigo completo com exemplos de código: pip É Lento, Poetry Complexo: UV Chegou Resolvendo o Python