uv: il gestore di pacchetti Python che sostituisce pip, pip-tools e venv (Guida 2026)

Se quest'anno hai dedicato del tempo a un progetto Python, probabilmente hai visto uv apparire in un file README o CI. È un gestore di pacchetti scritto da Rust e uno strumento virtualenv di Astral (lo stesso team dietro ruff) — ed è 10-100 volte più veloce della classica combinazione pip / pip-tools / venv.

Questa guida tratta: cosa sostituisce effettivamente uv, i cinque comandi che coprono il 95% di ciò che fai quotidianamente e i due casi in cui dovresti restare con gli strumenti classici.

Cosa sostituisce l'uv

| Strumento classico | equivalente uv | Accelerare |

|---|---|---|

| python -m venv .venv | uv venv | ~5x |

| pip install pkg | uv pip install pkg | ~10-50x |

| pip install -r requisiti.txt | uv pip install -r requisiti.txt | 20-100x nella cache fredda |

| pip-compile (pip-tools) | uv pip compile | ~50x |

| python -m venv + sourceactivate per ogni progetto | uv esegui <cmd> | Salta completamente l'attivazione |

La differenza di velocità è reale. L'installazione di un progetto Django moderato (Django + DRF + celery + redis + boto3 + ~40 deps transitivi) su una cache fredda richiede ~45 secondi con pip e ~2 secondi con uv. Su una cache calda, uv è essenzialmente istantaneo perché utilizza una cache globale con collegamenti fisici invece di copiare i file in ogni venv.

I cinque comandi che utilizzerai effettivamente

1. Installa uv stesso

BASH
# macOS + Linux — one line, no sudo, no Python needed
curl -LsSf https://astral.sh/uv/install.sh | sh

# Windows PowerShell
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

# Or via brew / apt / your package manager (updated frequently)
brew install uv

uv è un singolo binario autonomo: nessun bootstrap Python, nessuna dipendenza propria.

2. Crea un virtualenv

BASH
cd my-project
uv venv                       # creates .venv/ using the current Python
uv venv --python 3.13         # or pin a version — uv will download it if missing

A differenza di python -m venv, uv può recuperare la versione Python richiesta. Niente più "pyenv installa quindi venv quindi attiva" la danza in tre passaggi.

3. Installa i pacchetti

BASH
uv pip install fastapi httpx        # into the current venv
uv pip install -r requirements.txt  # bulk install
uv pip install -e .                 # editable install of current project

La sintassi è intenzionalmente identica a pip: scambia pip con uv pip e tutto funziona. Costo di migrazione: cinque sequenze di tasti.

4. Blocca/compila i requisiti

BASH
# From an installed venv → requirements.txt (like `pip freeze`)
uv pip freeze > requirements.txt

# From a loose requirements.in → fully pinned requirements.txt (like pip-compile)
uv pip compile requirements.in -o requirements.txt

La fase di "compilazione" è deterministica: stesso input, stesso output, byte per byte. Perfetto per CI riproducibile.

5. Eseguire un comando senza attivare il venv

BASH
uv run pytest                    # runs pytest from the current venv
uv run python manage.py migrate  # any command, any script
uv run --with ipython python     # temporarily add ipython for this session

Questa è la caratteristica killer. Non più source .venv/bin/activate prima di ogni comando. Ottimo in CI, ottimo nei Makefile, ottimo negli script di shell.

Migrazione di un progetto esistente (2 minuti)

Supponendo che tu abbia un requirements.txt:

BASH
# 1. Nuke the old venv
rm -rf .venv

# 2. Create the uv venv
uv venv

# 3. Install
uv pip install -r requirements.txt

# 4. Verify
uv run python -c "import fastapi; print(fastapi.__version__)"

Quattro comandi, fatti. Non è necessario che il tuo requirements.txt venga modificato. Non è necessario che il tuo pyproject.toml venga modificato. Il tuo elemento della configurazione non ha quasi bisogno di essere modificato: scambia la fase di installazione e il gioco è fatto.

Il percorso nativo pyproject.toml (progetti uv-first)

Per i progetti che iniziano da zero, utilizza il flusso di lavoro nativo di uv, senza alcun requisito.txt:

BASH
uv init my-project     # generates pyproject.toml + .python-version + .gitignore
cd my-project
uv add fastapi         # adds fastapi to pyproject.toml [dependencies] AND installs
uv add --dev pytest    # adds to dev-dependencies
uv sync                # installs exactly what pyproject.toml says (uses uv.lock)
uv lock --upgrade      # bumps every dependency to its latest compatible version

Ha la stessa forma di "cargo" per Rust o "npm" per Node: un file di configurazione, un file di lock, installazioni deterministiche. Se stai ricominciando da capo nel 2026, questo è il percorso.

Quando utilizzare ancora pip / venv

Due casi:

1. Sistemi CI legacy che non possono installare uv. Se sei bloccato con un agente Jenkins del 2019 senza accesso alla shell, le difficoltà legate all'installazione di uv potrebbero superare il guadagno di velocità. Ogni sistema CI moderno (GitHub Actions, GitLab CI, CircleCI, BuildKite) dispone di un programma di installazione uv a una riga.

2. Ambienti con airgapping con un mirror `pip` bloccato. uv utilizza per impostazione predefinita PyPI ma supporta --index-url: di solito funziona, ma alcuni mirror aziendali hanno comportamenti discreti (intestazioni di autenticazione, API JSON vs API semplice) che uv gestisce in modo diverso. Prova prima di impegnarti.

Questo è tutto. Per ogni altro caso nel 2026 (sviluppo solista, progetti di squadra, open source, CI, Docker) uv è più veloce, più affidabile e richiede meno sovraccarico mentale rispetto allo stack classico.

Lo scambio CI di 30 secondi

Prima (Azioni GitHub):

YAML
- uses: actions/setup-python@v5
  with:
    python-version: '3.13'
- run: pip install -r requirements.txt
- run: pytest

Dopo:

YAML
- uses: astral-sh/setup-uv@v3
- run: uv sync
- run: uv run pytest

Le esecuzioni CI diminuiscono da ~2 minuti a ~15 secondi nella fase di installazione. Se la tua matrice di test viene eseguita 5 volte per PR, si tratta di un vero risparmio cumulativo.

uv è il raro strumento che è sia più veloce che più semplice di quello che sostituisce. Se scrivi Python per vivere nel 2026, dedica 10 minuti a cambiare progetto. L'abitudine porterà ad ogni nuovo progetto che toccherai.

Passaggio successivo: il percorso Python DevOps copre uv, ruff, Docker e il moderno stack di distribuzione Python: 104 lezioni interattive.