uv: Managerul de pachete Python care înlocuiește pip, pip-tools și venv (Ghid 2026)

Dacă ați petrecut ceva timp într-un proiect Python anul acesta, probabil că ați văzut uv să apară într-un fișier README sau CI. Este un manager de pachete scris de Rust și un instrument virtualenv de la Astral (aceeași echipă din spatele lui ruff) - și este de 10-100 de ori mai rapid decât clasicul combo pip/pip-tools/venv.

Acest ghid acoperă: ceea ce înlocuiește de fapt UV, cele cinci comenzi care acoperă 95% din ceea ce faceți zilnic și cele două cazuri în care ar trebui să rămâneți cu instrumentele clasice.

Ce înlocuiește UV

| Instrument clasic | echivalent UV | Accelerare |

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

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

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

| pip install -r requirements.txt | uv pip install -r requirements.txt | 20-100x pe cache rece |

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

| python -m venv + source activate pentru fiecare proiect | uv run <cmd> | Omite complet activarea |

Diferența de viteză este reală. Instalarea unui proiect Django moderat (Django + DRF + țelină + redis + boto3 + ~40 de dep-uri tranzitive) pe un cache rece durează ~45 de secunde cu pip și ~2 secunde cu uv. Pe un cache cald, uv este în esență instantaneu, deoarece folosește un cache global hard-linked în loc să copieze fișiere în fiecare venv.

Cele cinci comenzi pe care le vei folosi de fapt

1. Instalați UV propriu-zis

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 este un singur binar autonom - fără bootstrap Python, fără dependențe proprii.

2. Creați 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

Spre deosebire de python -m venv, uv poate prelua versiunea Python pe care ați cerut-o. Gata cu „pyenv install then venv then activate” dans în trei pași.

3. Instalați pachete

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

Sintaxa este identică în mod intenționat cu pip — schimbă pip cu uv pip și totul funcționează. Costul migrației: cinci apăsări de taste.

4. Cerințele de înghețare / compilare

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

Pasul compilare este determinist - aceeași intrare, aceeași ieșire, octet pentru octet. Perfect pentru CI reproductibilă.

5. Rulați o comandă fără a activa 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

Aceasta este caracteristica ucigașă. Gata cu source .venv/bin/activate înainte de fiecare comandă. Excelent în CI, grozav în Makefiles, grozav în scripturile shell.

Migrarea unui proiect existent (2 minute)

Presupunând că aveți 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__)"

Patru comenzi, gata. requirements.txt nu trebuie schimbat. pyproject.toml dvs. nu trebuie schimbat. CI abia trebuie să se schimbe — schimbați pasul de instalare și ați terminat.

Calea nativă pyproject.toml (proiecte uv-first)

Pentru proiectele care pornesc de la zero, utilizați fluxul de lucru nativ al uv - fără cerințe.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

Aceasta este aceeași formă ca cargo pentru Rust sau npm pentru Node - un fișier de configurare, un fișier de blocare, instalări deterministe. Dacă începeți din nou în 2026, aceasta este calea.

Când să mai folosești pip / venv

Doua cazuri:

1. Sisteme CI moștenite care nu pot instala UV. Dacă sunteți blocat cu un agent Jenkins din 2019 fără acces la shell, frecarea instalării UV poate depăși creșterea vitezei. Fiecare sistem CI modern (GitHub Actions, GitLab CI, CircleCI, BuildKite) are un instalator UV cu o singură linie.

2. Medii airgapped cu o oglindă `pip` blocată. uv este implicit PyPI, dar acceptă --index-url — de obicei funcționează, dar unele oglinzi corporative au comportamente subtile (anteturi de autorizare, API JSON vs API simple) pe care uv le gestionează diferit. Testează înainte să te angajezi.

Asta este. Pentru fiecare alt caz din 2026 - dev solo, proiecte în echipă, sursă deschisă, CI, Docker - uv este mai rapid, mai fiabil și necesită mai puțină suprasarcină mentală decât stiva clasică.

Schimbarea CI de 30 de secunde

Înainte (Acțiuni GitHub):

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

Dupa:

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

Circuitele CI scad de la ~2 minute la ~15 secunde în pasul de instalare. Dacă matricea dvs. de testare rulează de 5 ori per PR, aceasta este o adevărată economie cumulativă.

UV este instrumentul rar care este atât mai rapid ȘI mai simplu decât ceea ce îl înlocuiește. Dacă scrieți Python pentru a trăi în 2026, petreceți 10 minute schimbând un proiect. Obiceiul se va aplica la fiecare proiect nou pe care îl atingeți.

Pasul următor: Python DevOps track acoperă uv, ruff, Docker și stiva modernă de implementare Python - 104 de lecții interactive.