Python UV: la guida definitiva al gestore di pacchetti Python più veloce

Che cos'è Python UV?

UV è un gestore e installer di pacchetti Python moderno e ad alte prestazioni, scritto in Rust. Funziona come sostituto immediato degli strumenti tradizionali di gestione dei pacchetti Python come pip, offrendo miglioramenti significativi in termini di velocità, affidabilità e risoluzione delle dipendenze.

Questo strumento rappresenta una nuova generazione di package manager per Python, progettata per affrontare i problemi più comuni nell'ecosistema Python come tempi di installazione lenti, conflitti di dipendenze e complessità nella gestione degli ambienti. UV raggiunge questo obiettivo grazie alla sua architettura innovativa e a un'implementazione efficiente, risultando 10–100 volte più veloce dei gestori tradizionali.

Funzionalità chiave che distinguono UV:

• Installazione dei pacchetti e risoluzione delle dipendenze fulminea
• Compatibile con gli strumenti e i flussi di lavoro Python esistenti
• Gestione degli ambienti virtuali integrata
• Supporto per gli standard di packaging moderni
• Blocco delle dipendenze affidabile e ambienti riproducibili
• Uso della memoria efficiente, soprattutto per progetti di grandi dimensioni

Che tu stia lavorando a piccoli progetti personali o gestendo applicazioni Python su larga scala, UV offre una soluzione robusta ed efficiente per la gestione dei pacchetti. In questo tutorial, tratteremo tutti gli aspetti essenziali di UV così potrai iniziare a usarlo subito.

TL;DR

• UV è un gestore di pacchetti Python basato su Rust che è 10–100x più veloce di pip
• Installa con curl -LsSf https://astral.sh/uv/install.sh | sh
• Inizializza i progetti con uv init e aggiungi dipendenze con uv add package
• Esegui script con uv run script.py—nessuna attivazione manuale dell'ambiente virtuale
• UV sostituisce pip, virtualenv, pyenv e pip-tools in un unico strumento
• I file di lock (uv.lock) garantiscono ambienti riproducibili tra macchine
• Usa uvx per eseguire tool CLI come black e ruff senza installazione permanente

Le differenze tra UV, Poetry, PIP, Conda e virtualenv

La prima domanda che gli sviluppatori spesso fanno prima di passare a un nuovo strumento è: "Come si confronta con quello che sto già usando?". Nell'ambito della gestione delle dipendenze e dei progetti Python, questi quattro strumenti sono già i più comuni:

• PIP
• Poetry
• Conda
• virtualenv

Confrontiamo UV con ciascuno di questi strumenti per aiutarti a decidere se UV è la scelta giusta per le tue esigenze prima di entrare nei dettagli.

UV vs. PIP e virtualenv

PIP e virtualenv sono stati gli strumenti tradizionali per la gestione dei pacchetti Python e la creazione di ambienti virtuali. Pur svolgendo il loro compito, UV offre diversi vantaggi convincenti:

• Velocità: l'implementazione in Rust di UV lo rende significativamente più veloce di PIP per installazione dei pacchetti e risoluzione delle dipendenze, completando spesso in secondi attività che con PIP richiederebbero minuti.
• Gestione dell'ambiente integrata: mentre virtualenv gestisce solo la creazione dell'ambiente e PIP solo la gestione dei pacchetti, UV combina entrambe le funzionalità in un unico strumento, semplificando il flusso di lavoro.

UV mantiene la piena compatibilità con l'ecosistema di PIP affrontandone al contempo le principali limitazioni. Può usare gli stessi file requirements.txt e gli stessi indici di pacchetti, rendendo la migrazione fluida. Le differenze principali sono:

• Prestazioni: i download in parallelo e il risolutore di dipendenze ottimizzato rendono UV 10–100x più veloce di PIP per progetti grandi.
• Uso della memoria: UV usa molta meno memoria rispetto a PIP durante installazione e risoluzione delle dipendenze.
• Gestione degli errori: UV fornisce messaggi di errore più chiari e una migliore risoluzione dei conflitti quando le dipendenze collidono.
• Riproducibilità: l'approccio con file di lock di UV garantisce ambienti coerenti su sistemi diversi, cosa non assicurata dai semplici file requirements.txt.

Sebbene PIP e virtualenv restino opzioni valide, l'architettura moderna e le funzionalità combinate di UV lo rendono un'alternativa interessante per gli sviluppatori che cercano prestazioni migliori e un flusso di lavoro più snello. La possibilità di inserire UV in progetti esistenti senza interrompere processi consolidati lo rende particolarmente attraente per i team che vogliono modernizzare gradualmente la propria toolchain di sviluppo Python.

UV vs. Conda

Chi non usa PIP e virtualenv di solito si rivolge a Conda, e con buone ragioni:

• Conda fornisce una soluzione completa di gestione dei pacchetti che gestisce non solo i pacchetti Python ma anche le dipendenze a livello di sistema
• Eccelle nella gestione di ambienti di calcolo scientifico complessi con pacchetti come NumPy, SciPy e TensorFlow
• Gli ambienti Conda sono più isolati e riproducibili tra sistemi operativi diversi
• Ha supporto integrato per versioni diverse di Python e può passare da una all'altra con facilità
• La distribuzione Anaconda include molti pacchetti scientifici preinstallati, rendendola comoda per i data scientist

Ma anche gli utenti Convinti di Conda dovrebbero considerare di passare a UV per vari motivi. (Per un confronto più ampio degli strumenti di gestione degli ambienti, vedi Anaconda vs Python: Exploring Their Differences.) L'installazione dei pacchetti e la risoluzione delle dipendenze ultraveloci di UV possono velocizzare drasticamente la preparazione dell'ambiente rispetto alle prestazioni a volte lente di Conda. Il suo ingombro minimo di risorse significa meno uso di memoria e avvii più rapidi. UV si integra inoltre senza problemi con gli standard e gli strumenti di packaging Python esistenti, facilitando il lavoro con l'ecosistema più ampio di Python. Per i progetti che non richiedono la gestione di pacchetti non-Python di Conda, UV offre una soluzione più snella ed efficiente che può migliorare sensibilmente i flussi di lavoro di sviluppo.

UV vs. Poetry

Sono stato un utente Conda per quasi tre anni ma dopo aver provato Poetry un paio di volte, non ho più toccato la Conda a passo di tartaruga. Proprio quando stavo prendendo confidenza con Poetry, mi sono imbattuto in UV e offre quasi le stesse capacità di Poetry:

• Gestione delle dipendenze: entrambi gli strumenti gestiscono in modo efficace dipendenze e ambienti virtuali
• Struttura del progetto: entrambi forniscono strumenti per inizializzare e strutturare progetti Python
• File di lock: entrambi generano file di lock per garantire ambienti riproducibili
• Pubblicazione di pacchetti: entrambi supportano la pubblicazione dei pacchetti su PyPI
• Strumenti moderni: entrambi rappresentano approcci moderni alla gestione di progetti Python

Tuttavia, la caratteristica che definisce UV è la sua velocità incredibile e l'uso minimo di risorse. Anche se Poetry è un miglioramento significativo rispetto agli strumenti tradizionali, UV porta le prestazioni a un altro livello grazie alla sua implementazione in Rust. Inoltre, la compatibilità di UV con il packaging Python esistente significa che può funzionare insieme ad altri strumenti come pip, offrendo una flessibilità che a volte manca all'approccio più opinato di Poetry.

Ecco una tabella che riassume le differenze appena discusse: 

Se pensi che valga la pena passare a UV, continua a leggere.

Primi passi con UV per progetti Python

In questa sezione vediamo come iniziare un progetto da zero usando UV. Se prima ti serve aiuto per configurare l'ambiente di sviluppo Python, dai un'occhiata alla nostra guida dedicata. Parleremo di come migrare progetti esistenti a UV in una sezione successiva.

Installare UV

UV può essere installato a livello di sistema usando cURL su macOS e Linux:

$ curl -LsSf https://astral.sh/uv/install.sh | sh

E con Powershell su Windows (assicurati di eseguire Powershell con privilegi di amministratore):

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

UV è disponibile anche tramite Homebrew:

$ brew install uv

È supportata anche l'installazione con PIP, ma non è consigliata:

$ pip install uv  # Assicurati di aver attivato un ambiente virtuale

Dopodiché, puoi verificare l'installazione eseguendo uv version:

$ uv version
uv 0.6.14 (2026-03-13)

Aggiornare UV

UV può aggiornare sé stesso quando è installato tramite l'installer standalone:

$ uv self update

Se hai installato UV via Homebrew, usa invece brew upgrade uv. Puoi anche abilitare l'autocompletamento della shell per i comandi UV:

$ echo 'eval "$(uv generate-shell-completion zsh)"' >> ~/.zshrc  # Per Zsh
$ echo 'eval "$(uv generate-shell-completion bash)"' >> ~/.bashrc  # Per Bash

Inizializzare un nuovo progetto

Lavorare sui progetti è il cuore dell'esperienza UV. Si parte inizializzando un progetto vuoto con il comando uv init:

$ uv init explore-uv
Initialized project explore-uv at /Users/bexgboost/projects/explore-uv

Il comando creerà immediatamente una nuova directory explore-uv con il seguente contenuto:

$ cd explore-uv
$ tree -a
.
├── .gitignore
├── .python-version
├── README.md
├── hello.py
└── pyproject.toml

Git viene inizializzato automaticamente e vengono generati i principali file correlati a git come .gitignore e un README.md vuoto. Il file .python-version contiene la versione di Python usata per il progetto, mentre pyproject.toml funge da file di configurazione principale per i metadati del progetto e le dipendenze. Viene creato anche un file di esempio hello.py per aiutarti a iniziare rapidamente.

Puoi approfondire la creazione di progetti nella documentazione di UV.

Aggiungere le dipendenze iniziali al progetto

UV combina la creazione dell'ambiente e l'installazione delle dipendenze in un unico comando: uv add:

$ uv add scikit-learn xgboost
Using CPython 3.9.20 interpreter at: /opt/homebrew/opt/python@3.9/bin/python3.9
Creating virtual environment at: .venv
Resolved 6 packages in 1.78s
⠧ Preparing packages... (2/5)
Prepared 5 packages in 1m 23s
Installed 5 packages in 45ms
 + joblib==1.4.2
 + numpy==2.0.2
 + scikit-learn==1.5.2
 ...

La prima volta che esegui il comando add, UV crea un nuovo ambiente virtuale nella directory di lavoro corrente e installa le dipendenze specificate. Nelle esecuzioni successive, UV riutilizzerà l'ambiente virtuale esistente e installerà o aggiornerà solo i pacchetti appena richiesti, garantendo una gestione delle dipendenze efficiente.

Un altro processo importante che avviene a ogni comando add è la risoluzione delle dipendenze. UV usa un risolutore di dipendenze moderno che analizza l'intero grafo delle dipendenze per trovare un set compatibile di versioni dei pacchetti che soddisfi tutti i requisiti. Questo aiuta a prevenire conflitti di versione e a garantire ambienti riproducibili. Il risolutore considera fattori come i vincoli di versione, la compatibilità con la versione di Python e i requisiti specifici della piattaforma per determinare il set ottimale di pacchetti da installare.

UV aggiorna anche i file pyproject.toml e uv.lock dopo ogni comando add. Ecco come appare il file TOML dopo aver installato Scikit-learn e XGBoost:

$ cat pyproject.toml
[project]
name = "explore-uv"
version = "0.1.0"
description = "Add your description here"
readme = "README.md"
requires-python = ">=3.9"
dependencies = [
    "scikit-learn>=1.5.2",
    "xgboost>=2.0.3",
]

Per rimuovere una dipendenza dall'ambiente e dal file pyproject.toml, puoi usare il comando uv remove. Disinstallerà il pacchetto e tutte le sue dipendenze figlie:

$ uv remove scikit-learn

Parleremo della gestione delle dipendenze più in dettaglio in una sezione successiva.

Eseguire script Python con UV

Una volta installate le dipendenze necessarie, puoi iniziare a lavorare sui tuoi script Python come al solito. Se usi VS Code, dai un'occhiata alla nostra guida sulla configurazione di VS Code per Python. UV offre alcuni modi diversi per eseguire codice Python:

Per eseguire direttamente uno script Python, puoi usare il comando uv run seguito dal nome del tuo script invece della solita sintassi python script.py:

$ uv run hello.py

Il comando run garantisce che lo script venga eseguito all'interno dell'ambiente virtuale creato da UV per il progetto.

Eseguire script con dipendenze inline (PEP 723)

UV supporta i metadati inline degli script secondo la PEP 723, che ti permette di dichiarare le dipendenze direttamente dentro uno script Python. È utile per script standalone che hanno bisogno di pacchetti senza configurare un progetto completo:

# /// script
# requires-python = ">=3.11"
# dependencies = [
#     "requests",
#     "rich",
# ]
# ///

import requests
from rich.console import Console

console = Console()
response = requests.get("https://api.github.com")
console.print(f"GitHub API status: [bold green]{response.status_code}[/bold green]")

Esegui lo script con uv run e UV creerà automaticamente un ambiente isolato con le dipendenze dichiarate:

$ uv run script.py
GitHub API status: 200

È particolarmente utile per condividere script riproducibili con colleghi: chiunque abbia UV installato può eseguire lo script senza installare manualmente le dipendenze.

Gestire le versioni di Python in UV

La gestione delle versioni di Python è una parte fondamentale della gestione delle dipendenze. UV fornisce comandi semplici per controllare quale versione di Python usare. Vediamo come utilizzare il comando uv python.

Installare versioni di Python con UV

UV può installare e gestire direttamente le versioni di Python, sostituendo la necessità di strumenti come pyenv:

$ uv python install 3.12
$ uv python install 3.11 3.13  # Installa più versioni in una volta

Le installazioni di Python sono archiviate in ~/.local/share/uv/python/ e non interferiscono con il Python di sistema. Puoi anche fissare un progetto a una versione specifica di Python:

$ uv python pin 3.12

Questo aggiorna il file .python-version nella directory del progetto. UV userà poi questa versione per tutte le operazioni del progetto.

Elencare le versioni di Python esistenti

Poiché è comune che i sistemi abbiano già Python installato, UV può individuare queste installazioni esistenti di default. Ad esempio, per elencare tutte le versioni di Python che UV rileva sul tuo sistema, esegui il seguente comando:

$ uv python list --only-installed
cpython-3.13.0-macos-aarch64-none     /opt/homebrew/opt/python@3.13/bin/python3.13 -> ../Frameworks/Python.framework/Versions/3.13/bin/python3.13
cpython-3.12.7-macos-aarch64-none     /opt/homebrew/opt/python@3.12/bin/python3.12 -> ../Frameworks/Python.framework/Versions/3.12/bin/python3.12
cpython-3.12.5-macos-aarch64-none     /Users/bexgboost/miniforge3/bin/python3.12
cpython-3.12.5-macos-aarch64-none     /Users/bexgboost/miniforge3/bin/python3 -> python3.12
cpython-3.12.5-macos-aarch64-none     /Users/bexgboost/miniforge3/bin/python -> python3.12
cpython-3.11.10-macos-aarch64-none    /opt/homebrew/opt/python@3.11/bin/python3.11 -> ../Frameworks/Python.framework/Versions/3.11/bin/python3.11
cpython-3.11.7-macos-aarch64-none     /Users/bexgboost/.local/share/uv/python/cpython-3.11.7-macos-aarch64-none/bin/python3 -> python3.11
cpython-3.10.15-macos-aarch64-none    /opt/homebrew/opt/python@3.10/bin/python3.10 -> ../Frameworks/Python.framework/Versions/3.10/bin/python3.10
cpython-3.9.20-macos-aarch64-none     /opt/homebrew/opt/python@3.9/bin/python3.9 -> ../Frameworks/Python.framework/Versions/3.9/bin/python3.9
cpython-3.9.6-macos-aarch64-none      /Library/Developer/CommandLineTools/usr/bin/python3 -> ../../Library/Frameworks/Python3.framework/Versions/3.9/bin/python3

Il comando ha rilevato correttamente le mie versioni di Python installate con Conda e Brew.

Cambiare versione di Python per il progetto corrente 

Puoi passare a versioni diverse di Python per il tuo progetto UV in qualsiasi momento, purché la nuova versione soddisfi le specifiche nel tuo file pyproject.toml. Ad esempio, il seguente file richiede versioni di Python dalla 3.9 in su:

...
requires-python = ">=3.9"

Questo significa che puoi cambiare la versione di Python nel file .python-version a qualsiasi versione superiore, come la 3.11.7. Dopodiché, esegui uv sync.

Il comando prima controlla le installazioni di Python esistenti. Se la versione richiesta non viene trovata, UV la scarica e la installa nel percorso /Users/username/.local/share/uv/python. UV crea anche un nuovo ambiente virtuale all'interno della directory del progetto, sostituendo quello vecchio. 

Il comando uv sync gestisce tutto automaticamente: crea il nuovo ambiente virtuale e reinstalla tutte le dipendenze dai file pyproject.toml e uv.lock. Non serve alcun passaggio di installazione aggiuntivo.

Nota che a volte i comandi uv possono generare errori di Permission Denied. In questi casi, assicurati di usare il comando sudo se sei su macOS o Linux oppure esegui il prompt dei comandi con privilegi di amministratore se sei su Windows. Una soluzione ancora migliore è cambiare la proprietà della directory home di UV all'utente:

$ sudo chown -R $USER ~/.local/share/uv  # macOS o Linux

Per saperne di più sulla gestione delle versioni di Python con UV, fai riferimento alla documentazione. 

Cosa sono gli UV Tools e come usarli?

Alcuni pacchetti Python sono esposti come strumenti da riga di comando, come black per il formatting del codice, flake8 per il linting, pytest per i test, mypy per il type checking, ecc. UV fornisce due interfacce speciali per gestire questi pacchetti:

1. Usando uv tool run:

$ uv tool run black hello.py

2. Usando il comando più corto e comodo uvx:

$ uvx black hello.py

Quando questi comandi vengono eseguiti, UV crea un ambiente virtuale temporaneo nella sua cache. Lo strumento richiesto viene installato ed eseguito da lì. In altre parole, puoi usare strumenti da riga di comando senza installarli nell'ambiente virtuale del progetto, ottenendo esecuzioni più rapide e dipendenze di progetto più pulite.

Punti chiave sulle interfacce per eseguire i tool:

• Funziona con qualsiasi pacchetto Python che fornisce strumenti da riga di comando come flake8, mypy, black o pytest
• Gli ambienti in cache vengono puliti automaticamente quando si svuota la cache di UV
• Nuovi ambienti in cache vengono creati on-demand quando necessari
• Perfetto per l'uso occasionale di tool di sviluppo
• Per gli strumenti che usi spesso, installali in modo permanente con uv tool install:

$ uv tool install ruff
$ uv tool install black
$ ruff check .  # Ora disponibile direttamente nel PATH

Gli strumenti installati in modo permanente sono disponibili globalmente tramite il tuo PATH, senza inquinare l'ambiente virtuale di alcun progetto. Puoi aggiornarli con uv tool upgrade ruff ed elencare tutti gli strumenti installati con uv tool list.

Leggi la sezione UV Tools della documentazione per saperne di più su queste interfacce.

Cosa sono i file di lock in UV?

I file di lock (uv.lock) sono una parte essenziale della gestione delle dipendenze in UV. Quando esegui comandi uv add per installare dipendenze, UV genera e aggiorna automaticamente un file uv.lock. Questo file di lock svolge diversi ruoli critici:

• Registra le versioni esatte di tutte le dipendenze e delle loro sotto-dipendenze che sono state installate.
• Garantisce build riproducibili "bloccando" le versioni delle dipendenze in ambienti diversi.
• Aiuta a prevenire l'"inferno delle dipendenze" mantenendo versioni coerenti dei pacchetti.
• Accelera le installazioni perché UV può usare le versioni bloccate invece di risolvere nuovamente le dipendenze.

UV gestisce automaticamente il file di lock: non devi modificarlo manualmente. Il file di lock andrebbe aggiunto al controllo versione per garantire che tutti gli sviluppatori usino le stesse versioni delle dipendenze.

La differenza tra i file di lock e requirements.txt

Sebbene sia i file di lock sia i requirements.txt servano a tracciare le dipendenze, hanno scopi e casi d'uso distinti. I file di lock contengono informazioni dettagliate sulle versioni esatte dei pacchetti e sul loro albero completo di dipendenze, garantendo ambienti coerenti nello sviluppo. I file requirements.txt sono più semplici, in genere elencano solo le dipendenze dirette e sono ampiamente supportati dagli strumenti Python.

I file di lock sono essenziali in fase di sviluppo per mantenere build riproducibili e prevenire conflitti di dipendenze. I file requirements.txt sono più adatti agli scenari di deployment o quando si condivide codice con utenti che potrebbero non usare UV. Sono anche necessari per la compatibilità con strumenti e servizi che non supportano il formato del file di lock di UV.

Puoi mantenere entrambi i file usando il file di lock di UV per lo sviluppo e generando un requirements.txt per il deployment. Per generare un requirements.txt da un file di lock UV, usa il seguente comando:

$ uv export -o requirements.txt

Questo crea il file di testo con versioni bloccate basate sul tuo file di lock, semplificando la condivisione delle dipendenze del progetto in un formato standard pur beneficiando della gestione avanzata delle dipendenze di UV durante lo sviluppo.

Puoi saperne di più sulla gestione dei file di lock dalla documentazione. 

Gestione avanzata delle dipendenze con UV

In questa sezione esploreremo metodi più sofisticati per gestire le dipendenze in UV. Impareremo come aggiornare le dipendenze, renderle opzionali o inserirle in un gruppo di dipendenze.

Aggiornare le dipendenze

Nei progetti di lungo periodo è comune aggiornare i pacchetti che stai usando per portare in dote le funzionalità più recenti. Oppure, a volte, un pacchetto introduce breaking changes e vuoi assicurarti che quella versione non venga installata per errore nel tuo ambiente. Il comando add può essere usato di nuovo in questi e in qualunque altro scenario in cui devi modificare i vincoli o le versioni delle dipendenze esistenti.

1. Installare l'ultima versione di un pacchetto:

$ uv add requests

2. Installare una versione specifica:

$ uv add "requests==2.1.2"

3. Modificare i limiti dei vincoli di un pacchetto:

$ uv add 'requests<3.0.0'

4. Rendere una dipendenza specifica per piattaforma:

$ uv add 'requests; sys_platform="linux"' 

Aggiungere dipendenze opzionali

Le dipendenze opzionali sono pacchetti non necessari per la funzionalità core del progetto ma utili per funzionalità specifiche. Ad esempio, Pandas ha un extra excel e un extra plot per evitare l'installazione dei parser Excel e di matplotlib a meno che non siano richiesti esplicitamente. Gli optional di solito si installano con la sintassi pip install pandas[plot, excel]. 

Con UV, la sintassi è leggermente diversa. Per prima cosa, assicurati che il pacchetto principale Pandas sia installato:

$ uv add pandas

Poi, installalo con i suoi extra opzionali usando la notazione tra parentesi quadre:

$ uv add "pandas[plot,excel]"

Una volta risolte, verranno elencate nel tuo pyproject.toml nel seguente formato:

[project]
name = "explore-uv"
version = "0.1.0"
description = "Add your description here"
readme = "README.md"
requires-python = ">=3.9"
dependencies = [
    "pandas[plot,excel]>=2.2.3",
    "requests>=2.32.3",
]

Gruppi di dipendenze

I gruppi di dipendenze ti permettono di organizzare le dipendenze in gruppi logici, come dipendenze di sviluppo, di test o per la documentazione. È utile per tenere separate le dipendenze di produzione da quelle di sviluppo.

Per aggiungere una dipendenza a un gruppo specifico, usa il flag --group:

$ uv add --group group_name package_name

Successivamente, gli utenti potranno controllare quali gruppi installare usando i tag --group, --only-group e --no-group.

Passare da PIP e Virtualenv a UV

Migrare da PIP e virtualenv a UV è semplice poiché UV mantiene la compatibilità con gli standard di packaging Python esistenti. Ecco una guida passo passo per rendere la transizione fluida:

1. Convertire un progetto virtualenv esistente

Se hai un progetto esistente che usa virtualenv e pip, inizia generando un file requirements.txt dal tuo ambiente corrente se non l'hai già fatto:

$ pip freeze > requirements.txt

Poi, crea un nuovo progetto UV nella stessa directory:

$ uv init .

Infine, installa le dipendenze dal tuo file requirements:

$ uv pip install -r requirements.txt

2. Sostituire i comandi comuni di pip/virtualenv

Ecco un rapido riferimento per sostituire i comandi comuni di pip e virtualenv con gli equivalenti in UV:

Dopo la migrazione, puoi tranquillamente rimuovere la tua vecchia directory virtualenv e iniziare a usare la gestione degli ambienti virtuali di UV. La transizione è in genere senza intoppi, e all'occorrenza puoi sempre tornare ai comandi pip tramite il layer di compatibilità pip di UV.

Usare UV in CI/CD e Docker

La velocità di UV lo rende particolarmente prezioso nelle pipeline CI/CD, dove l'installazione delle dipendenze avviene a ogni build. Ecco un esempio di workflow GitHub Actions che usa UV:

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Install uv
        uses: astral-sh/setup-uv@v3
      - name: Set up Python
        run: uv python install 3.12
      - name: Install dependencies
        run: uv sync --frozen --dev
      - name: Run tests
        run: uv run pytest tests/

Il flag --frozen assicura che la CI usi esattamente le versioni nel tuo file di lock, fallendo se il file di lock non è aggiornato. Questo garantisce build riproducibili.

Integrazione con Docker

UV può anche velocizzare sensibilmente la build delle immagini Docker:

FROM python:3.12-slim

# Install uv
COPY --from=ghcr.io/astral-sh/uv:latest /uv /uvx /bin/

WORKDIR /app
COPY pyproject.toml uv.lock ./
RUN uv sync --frozen --no-dev --no-editable

COPY . .
CMD ["uv", "run", "python", "app.py"]

Copiando prima i file delle dipendenze e installandoli prima di copiare il codice sorgente, sfrutti appieno la cache dei layer Docker. L'installazione delle dipendenze viene rieseguita solo quando cambiano pyproject.toml o uv.lock.

Conclusione

UV rappresenta un progresso significativo nella gestione dei pacchetti Python, offrendo un'alternativa moderna, veloce ed efficiente agli strumenti tradizionali. I suoi vantaggi chiave includono:

• Prestazioni fulminee con miglioramenti di velocità 10–100x rispetto a pip
• Integrazione senza soluzione di continuità con gli standard di packaging Python esistenti
• Gestione degli ambienti virtuali integrata
• Risoluzione efficiente delle dipendenze e supporto ai file di lock
• Basso consumo di memoria e di risorse

Che tu stia iniziando un nuovo progetto o migrandone uno esistente, UV offre una soluzione robusta che può migliorare sensibilmente il tuo flusso di lavoro di sviluppo in Python. La sua compatibilità con gli strumenti esistenti lo rende una scelta semplice per chi vuole modernizzare la propria toolchain senza stravolgere i processi attuali.

Man mano che l'ecosistema Python evolve, strumenti come UV dimostrano come tecnologie moderne come Rust possano migliorare l'esperienza di sviluppo mantenendo al contempo la semplicità e l'accessibilità che gli sviluppatori Python apprezzano.

Se vuoi approfondire la gestione delle dipendenze o Python in generale, consulta queste risorse aggiuntive:

• Tutorial Python per Principianti
• Tutorial PIP Python: Guida definitiva
• Corso: Sviluppare pacchetti Python
• Le 9 migliori alternative ad Anaconda per la gestione degli ambienti Python
• Data Scientist in Python | Impara Python per la Data Science
• Python Poetry: gestione moderna ed efficiente di ambienti e dipendenze Python