Python UV: De ultieme gids voor de snelste Python-packagemanager

Wat is Python UV?

UV is een moderne, high-performance Python-packagemanager en -installer, geschreven in Rust. Het is een drop-invervanging voor traditionele tooling zoals pip, met aanzienlijke verbeteringen in snelheid, betrouwbaarheid en dependency-resolutie.

Deze tool vertegenwoordigt een nieuwe generatie Python-packagemanagers, ontworpen om veelvoorkomende pijnpunten in het Python-ecosysteem aan te pakken, zoals trage installaties, dependencyconflicten en complexe omgevingsbeheer. UV bereikt dit met een innovatieve architectuur en efficiënte implementatie, waardoor het 10–100 keer sneller is dan traditionele packagemanagers.

Belangrijke features die UV laten opvallen:

• Bliksemsnelle pakketinstallatie en dependency-resolutie
• Compatibel met bestaande Python-tools en -workflows
• Ingebouwd beheer van virtuele omgevingen
• Ondersteuning voor moderne packaging-standaarden
• Betrouwbare dependency locking en reproduceerbare omgevingen
• Geheugenefficiënte werking, vooral voor grote projecten

Of je nu aan kleine persoonlijke projecten werkt of grootschalige Python-applicaties beheert, UV biedt een robuuste en efficiënte oplossing voor packagemanagement. In deze tutorial behandelen we alle essentiële aspecten van UV, zodat je er direct mee aan de slag kunt.

TL;DR

• UV is een door Rust aangedreven Python-packagemanager die 10–100x sneller is dan pip
• Installeer met curl -LsSf https://astral.sh/uv/install.sh | sh
• Initialiseer projecten met uv init en voeg dependencies toe met uv add package
• Voer scripts uit met uv run script.py—zonder handmatige activatie van een virtuele omgeving
• UV vervangt pip, virtualenv, pyenv en pip-tools in één tool
• Lockbestanden (uv.lock) zorgen voor reproduceerbare omgevingen op verschillende machines
• Gebruik uvx om CLI-tools zoals black en ruff te draaien zonder permanente installatie

Het verschil tussen UV, Poetry, PIP, Conda en virtualenv

De eerste vraag die developers vaak stellen voordat ze overstappen naar een nieuwe tool is: "Hoe verhoudt dit zich tot wat ik al gebruik?" In de wereld van Python-dependency- en projectbeheer zijn deze vier tools al het meest gangbaar:

• PIP
• Poetry
• Conda
• virtualenv

Laten we UV met elk van deze tools vergelijken om je te helpen beslissen of UV voor jouw behoeften de juiste keuze is, voordat we de details induiken.

UV vs. PIP en virtualenv

PIP en virtualenv zijn de traditionele tools voor Python-packagemanagement en het aanmaken van virtuele omgevingen. Hoewel ze het werk doen, biedt UV een aantal overtuigende voordelen:

• Snelheid: dankzij de Rust-implementatie is UV aanzienlijk sneller dan PIP bij pakketinstallatie en dependency-resolutie; taken die met PIP minuten duren, zijn met UV vaak in seconden klaar.
• Geïntegreerd omgevingsbeheer: waar virtualenv alleen omgevingen aanmaakt en PIP alleen pakketten beheert, combineert UV beide in één tool en stroomlijnt zo de workflow.

UV behoudt volledige compatibiliteit met het PIP-ecosysteem en pakt tegelijk de belangrijkste beperkingen aan. Het kan dezelfde requirements.txt-bestanden en package-indexen gebruiken, wat migratie naadloos maakt. De belangrijkste verschillen zijn:

• Performance: parallelle downloads en een geoptimaliseerde dependency-resolver maken UV 10–100x sneller dan PIP voor grote projecten.
• Geheugengebruik: UV gebruikt aanzienlijk minder geheugen dan PIP tijdens installatie en dependency-resolutie.
• Foutafhandeling: UV geeft duidelijkere foutmeldingen en betere conflictoplossing bij botsende dependencies.
• Reproduceerbaarheid: met lockfiles zorgt UV voor consistente omgevingen op verschillende systemen—iets wat met een eenvoudige requirements.txt niet gegarandeerd is.

Hoewel PIP en virtualenv bruikbare opties blijven, maken UV’s moderne architectuur en gecombineerde functionaliteit het een aantrekkelijk alternatief voor developers die betere performance en een gestroomlijnde workflow zoeken. Dat je UV in bestaande projecten kunt inzetten zonder processen te verstoren, maakt het extra interessant voor teams die hun Python-tooling geleidelijk willen moderniseren.

UV vs. Conda

Wie geen PIP en virtualenv gebruikt, komt vaak bij Conda uit, en dat is niet zonder reden:

• Conda biedt een complete packagemanagementoplossing die niet alleen Python-pakketten maar ook systeemafhankelijke libraries beheert
• Het blinkt uit in het beheren van complexe scientific computing-omgevingen met pakketten als NumPy, SciPy en TensorFlow
• Conda-omgevingen zijn beter geïsoleerd en reproduceerbaar over verschillende besturingssystemen
• Het heeft ingebouwde ondersteuning voor verschillende Python-versies en schakelt daar makkelijk tussen
• De Anaconda-distributie wordt geleverd met veel voorgeïnstalleerde wetenschappelijke pakketten, handig voor data scientists

Maar zelfs doorgewinterde Conda-gebruikers zouden UV moeten overwegen, om verschillende redenen. (Voor een bredere vergelijking van omgevingsbeheertools, zie Anaconda vs Python: Exploring Their Differences.) UV’s razendsnelle installatie en dependency-resolutie kunnen het opzetten van omgevingen drastisch versnellen ten opzichte van Conda’s soms trage performance. Dankzij de minimale resourcefootprint gebruikt het minder geheugen en start het sneller op. UV integreert ook naadloos met bestaande Python-packagingstandaarden en -tools, waardoor werken met het bredere Python-ecosysteem eenvoudiger wordt. Voor projecten die Conda’s non-Python-packages niet nodig hebben, biedt UV een gestroomlijnde, efficiënte oplossing die de ontwikkelworkflow aanzienlijk kan verbeteren.

UV vs. Poetry

Ik gebruikte bijna drie jaar Conda, maar nadat ik Poetry een paar keer had geprobeerd, raakte ik turtle-slow Conda niet meer aan. Net toen ik me prettig begon te voelen bij Poetry, kwam ik UV tegen—en dat biedt bijna dezelfde mogelijkheden als Poetry:

• Dependencybeheer: beide tools beheren pakketafhankelijkheden en virtuele omgevingen effectief
• Projectstructuur: beide bieden tooling voor het initialiseren en structureren van Python-projecten
• Lockfiles: beide genereren lockfiles voor reproduceerbare omgevingen
• Pakketpublicatie: beide ondersteunen publiceren naar PyPI
• Moderne tooling: beide vertegenwoordigen een moderne aanpak van Python-projectbeheer

Het onderscheidende kenmerk van UV is echter de extreem hoge snelheid en het minimale resourcegebruik. Hoewel Poetry een grote stap vooruit is ten opzichte van traditionele tools, tilt UV de performance naar een hoger niveau dankzij de Rust-implementatie. Bovendien kan UV, dankzij compatibiliteit met bestaande Python-packaging, samenwerken met andere tools zoals pip—die flexibiliteit ontbreekt soms bij Poetry’s meer uitgesproken aanpak.

Hier is een tabel die de verschillen samenvat die we net hebben besproken: 

Denk je dat UV het waard is om naar over te stappen? Lees dan verder.

Aan de slag met UV voor Python-projecten

In deze sectie behandelen we hoe je vanaf nul een project start met UV. Heb je eerst hulp nodig bij het inrichten van je Python-ontwikkelomgeving? Bekijk dan onze aparte gids. We bespreken later hoe je bestaande projecten naar UV migreert.

UV installeren

UV kan systeemwijd worden geïnstalleerd met cURL op macOS en Linux:

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

En met Powershell op Windows (zorg dat je Powershell met administratorrechten draait):

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

UV is ook beschikbaar via Homebrew:

$ brew install uv

Installatie via PIP wordt ondersteund maar niet aanbevolen:

$ pip install uv  # Zorg dat je een virtuele omgeving geactiveerd hebt

Daarna kun je de installatie verifiëren met uv version:

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

UV updaten

UV kan zichzelf updaten als het via de standalone-installer is geïnstalleerd:

$ uv self update

Als je UV via Homebrew hebt geïnstalleerd, gebruik dan brew upgrade uv. Je kunt ook shell-autocompletion inschakelen voor UV-commando’s:

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

Een nieuw project initialiseren

Werken aan projecten is de kern van de UV-ervaring. Je begint met het initialiseren van een leeg project met het commando uv init:

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

Het commando maakt direct een nieuwe map explore-uv aan met de volgende inhoud:

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

Git wordt automatisch geïnitialiseerd en belangrijke gitbestanden zoals .gitignore en een lege README.md worden gegenereerd. Het bestand .python-version bevat de Python-versie die voor het project wordt gebruikt, en pyproject.toml is het hoofdconfiguratiebestand voor projectmetadata en dependencies. Er wordt ook een voorbeeldbestand hello.py aangemaakt om je snel op weg te helpen.

Je kunt meer lezen over het maken van projecten in de UV-documentatie.

Initiële dependencies aan het project toevoegen

UV combineert het aanmaken van een omgeving en het installeren van dependencies in één commando: 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
 ...

De eerste keer dat je het commando add uitvoert, maakt UV een nieuwe virtuele omgeving aan in de huidige werkmap en installeert daar de opgegeven dependencies. Bij volgende runs hergebruikt UV de bestaande virtuele omgeving en installeert of update het alleen de nieuw gevraagde pakketten. Zo blijft dependencybeheer efficiënt.

Een ander belangrijk proces bij elk add-commando is het resolven van dependencies. UV gebruikt een moderne dependency-resolver die de volledige dependencygraaf analyseert om een compatibele set pakketversies te vinden die aan alle eisen voldoen. Dit helpt versieconflicten te voorkomen en zorgt voor reproduceerbare omgevingen. De resolver houdt rekening met zaken als versieconstraints, Python-versiecompatibiliteit en platformspecifieke vereisten om de optimale set pakketten te bepalen.

UV werkt na elk add-commando ook de bestanden pyproject.toml en uv.lock bij. Zo ziet het TOML-bestand eruit na het installeren van Scikit-learn en 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",
]

Om een dependency uit de omgeving en uit pyproject.toml te verwijderen, kun je het commando uv remove gebruiken. Dit deïnstalleert het pakket en al zijn subdependencies:

$ uv remove scikit-learn

We gaan later dieper in op dependencybeheer.

Python-scripts uitvoeren met UV

Zodra je de benodigde dependencies hebt geïnstalleerd, kun je zoals gebruikelijk aan je Python-scripts werken. Gebruik je VS Code? Bekijk dan onze gids voor het instellen van VS Code voor Python. UV biedt een paar verschillende manieren om Python-code uit te voeren:

Om een Pythonscript direct te draaien, kun je het commando uv run gebruiken gevolgd door de naam van je script, in plaats van de gebruikelijke python script.py-syntaxis:

$ uv run hello.py

Het commando run zorgt ervoor dat het script wordt uitgevoerd binnen de virtuele omgeving die UV voor het project heeft aangemaakt.

Scripts draaien met inline dependencies (PEP 723)

UV ondersteunt PEP 723 inline scriptmetadata, waarmee je dependencies rechtstreeks in een Pythonscript kunt declareren. Dit is handig voor losstaande scripts die pakketten nodig hebben zonder een volledig project op te zetten:

# /// 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]")

Voer het script uit met uv run; UV maakt automatisch een geïsoleerde omgeving aan met de gedeclareerde dependencies:

$ uv run script.py
GitHub API status: 200

Dit is vooral krachtig om reproduceerbare scripts met collega’s te delen—iedereen met UV geïnstalleerd kan het script draaien zonder handmatig dependencies te installeren.

Python-versies beheren in UV

Het beheren van Python-versies is een belangrijk onderdeel van dependencybeheer. UV biedt eenvoudige commando’s om te bepalen welke Python-versie je gebruikt. Laten we het commando uv python verkennen.

Python-versies installeren met UV

UV kan Python-versies direct installeren en beheren, waardoor tools zoals pyenv overbodig worden:

$ uv python install 3.12
$ uv python install 3.11 3.13  # Installeer meerdere versies tegelijk

Python-installaties worden opgeslagen in ~/.local/share/uv/python/ en beïnvloeden je systeem-Python niet. Je kunt een project ook vastzetten op een specifieke Python-versie:

$ uv python pin 3.12

Dit werkt het bestand .python-version in je projectmap bij. UV gebruikt deze versie vervolgens voor alle projecthandelingen.

Bestaande Python-versies weergeven

Omdat systemen vaak al Python geïnstalleerd hebben, kan UV deze installaties standaard detecteren. Om bijvoorbeeld alle door UV gedetecteerde Python-versies op je systeem te tonen, gebruik je:

$ 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

Het commando detecteerde correct mijn via Conda en Brew geïnstalleerde Python-versies.

Python-versies wijzigen voor het huidige project 

Je kunt op elk moment van Python-versie wisselen voor je huidige UV-project, zolang de nieuwe versie voldoet aan de specificaties in je pyproject.toml-bestand. Het volgende bestand vereist bijvoorbeeld Python 3.9 en hoger:

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

Dit betekent dat je de Python-versie in het bestand .python-version mag wijzigen naar elke versie daarboven, zoals 3.11.7. Roep daarna uv sync aan.

Het commando controleert eerst bestaande Python-installaties. Als de gevraagde versie niet wordt gevonden, downloadt en installeert UV deze in het pad /Users/username/.local/share/uv/python. UV maakt ook een nieuwe virtuele omgeving in de projectmap en vervangt de oude. 

Het commando uv sync regelt alles automatisch—het maakt de nieuwe virtuele omgeving aan en installeert alle dependencies opnieuw vanuit je pyproject.toml en uv.lock. Een extra installatiestap is niet nodig.

Let op: soms kunnen uv-commando’s Permission Denied-fouten geven. Gebruik in die gevallen sudo op macOS of Linux, of start je opdrachtprompt met administratorrechten op Windows. Een nog betere oplossing is het eigenaarschap van de UV-thuismap aan de gebruiker toe te wijzen:

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

Wil je meer weten over het beheren van Python-versies met UV? Raadpleeg dan de documentatie. 

Wat zijn UV Tools en hoe gebruik je ze?

Sommige Python-pakketten worden blootgesteld als commandlinetools, zoals black voor codeformattering, flake8 voor linting, pytest voor testen, mypy voor typechecking, enzovoort. UV biedt twee speciale interfaces om deze pakketten te beheren:

1. Met uv tool run:

$ uv tool run black hello.py

2. Met het kortere en handigere uvx-commando:

$ uvx black hello.py

Wanneer je deze commando’s draait, maakt UV een tijdelijke virtuele omgeving in zijn cache. De gevraagde tool wordt daar geïnstalleerd en uitgevoerd. Met andere woorden: je kunt commandlinetools gebruiken zonder ze in de virtuele omgeving van het project te installeren—dat zorgt voor snellere executie en schonere projectdependencies.

Belangrijke punten over de tool-runinterfaces:

• Werkt met elk Python-pakket dat commandlinetools biedt, zoals flake8, mypy, black of pytest
• Gecachte omgevingen worden automatisch opgeschoond bij het legen van de UV-cache
• Nieuwe gecachte omgevingen worden on-demand aangemaakt wanneer nodig
• Perfect voor incidenteel gebruik van developmenttools
• Voor tools die je vaak gebruikt, installeer je ze permanent met uv tool install:

$ uv tool install ruff
$ uv tool install black
$ ruff check .  # Nu direct beschikbaar in PATH

Permanent geïnstalleerde tools zijn globaal beschikbaar via je PATH, zonder een projectomgeving te vervuilen. Je kunt ze updaten met uv tool upgrade ruff en een lijst opvragen met uv tool list.

Lees de UV Tools-sectie van de documentatie voor meer informatie over deze interfaces.

Wat zijn lockbestanden in UV?

Lockbestanden (uv.lock) zijn een essentieel onderdeel van dependencybeheer in UV. Wanneer je uv add-commando’s uitvoert om dependencies te installeren, genereert en update UV automatisch een uv.lock-bestand. Dit lockbestand heeft meerdere cruciale doelen:

• Het legt de exacte versies vast van alle dependencies en subdependencies die zijn geïnstalleerd.
• Het zorgt voor reproduceerbare builds door dependencyversies te “locken” over verschillende omgevingen.
• Het helpt “dependency hell” te voorkomen door consistente pakketversies te behouden.
• Het versnelt installaties, omdat UV de gelockte versies kan gebruiken in plaats van dependencies opnieuw te resolven.

UV beheert het lockbestand automatisch—je hoeft het niet handmatig aan te passen. Het lockbestand moet je committen in versiebeheer, zodat alle developers dezelfde dependencyversies gebruiken.

Het verschil tussen lockbestanden en requirements.txt

Hoewel zowel lockbestanden als requirements.txt dienen om dependencies vast te leggen, hebben ze verschillende doelen en use-cases. Lockbestanden bevatten gedetailleerde informatie over exacte pakketversies en de volledige dependencyboom, zodat omgevingen consistent blijven tijdens development. Requirements.txt-bestanden zijn eenvoudiger en vermelden meestal alleen directe dependencies; ze worden breed ondersteund door Python-tools.

Lockbestanden zijn essentieel tijdens development om reproduceerbare builds te behouden en dependencyconflicten te voorkomen. Requirements.txt-bestanden zijn geschikter voor deployment-scenario’s of wanneer je code deelt met gebruikers die mogelijk geen UV gebruiken. Ze zijn ook nodig voor compatibiliteit met tools en services die UV’s lockformaat niet ondersteunen.

Je kunt beide bestanden aanhouden door UV’s lockbestand te gebruiken voor development en een requirements.txt te genereren voor deployment. Om een requirements.txt te genereren op basis van een UV-lockbestand, gebruik je het volgende commando:

$ uv export -o requirements.txt

Hiermee maak je een tekstbestand met gepinde versies op basis van je lockbestand. Zo kun je dependencies van je project in een standaardformaat delen, terwijl je tijdens development profiteert van UV’s geavanceerde dependencybeheer.

Lees meer over het beheren van lockbestanden in de documentatie. 

Geavanceerd dependencybeheer met UV

In deze sectie verkennen we meer geavanceerde methoden om dependencies te beheren in UV. We leren hoe je dependencies bijwerkt, optioneel maakt of in een dependencygroep plaatst.

Dependencies updaten

In langlopende projecten is het gebruikelijk om gebruikte pakketten te updaten om de meest recente features te krijgen. Soms introduceert een pakket breaking changes en wil je voorkomen dat die versie per ongeluk wordt geïnstalleerd. Het commando add kan opnieuw worden gebruikt in deze en andere scenario’s waarin je constraints of versies van bestaande dependencies wilt wijzigen.

1. De nieuwste versie van een pakket installeren:

$ uv add requests

2. Een specifieke versie installeren:

$ uv add "requests==2.1.2"

3. De grenzen van de constraints van een pakket aanpassen:

$ uv add 'requests<3.0.0'

4. Een dependency platformspecifiek maken:

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

Optionele dependencies toevoegen

Optionele dependencies zijn pakketten die niet vereist zijn voor de kernfunctionaliteit van je project, maar wel nodig kunnen zijn voor specifieke features. Zo heeft Pandas een excel-extra en een plot-extra om te voorkomen dat Excel-parsers en matplotlib worden geïnstalleerd, tenzij iemand ze expliciet nodig heeft. Optionals installeer je meestal met de syntaxis pip install pandas[plot, excel]. 

Met UV is die syntaxis net iets anders. Zorg eerst dat het kernpakket Pandas is geïnstalleerd:

$ uv add pandas

Installeer het daarna met de optionele extras via de blokhaaknotatie:

$ uv add "pandas[plot,excel]"

Zodra ze zijn geresolved, worden ze in je pyproject.toml als volgt vermeld:

[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",
]

Dependencygroepen

Met dependencygroepen kun je dependencies organiseren in logische groepen, zoals ontwikkeldependencies, testdependencies of documentatiedependencies. Dit is handig om productiondependencies gescheiden te houden van ontwikkeldependencies.

Om een dependency aan een specifieke groep toe te voegen, gebruik je de vlag --group:

$ uv add --group group_name package_name

Gebruikers kunnen vervolgens bepalen welke groepen ze willen installeren met de tags --group, --only-group en --no-group.

Overstappen van PIP en Virtualenv naar UV

Migreren van PIP en virtualenv naar UV is eenvoudig, omdat UV compatibel is met bestaande Python-packagingstandaarden. Hier is een stapsgewijze gids om de overgang soepel te laten verlopen:

1. Een bestaand virtualenv-project omzetten

Heb je een bestaand project met virtualenv en pip? Begin dan met het genereren van een requirements.txt uit je huidige omgeving, als je dat nog niet hebt gedaan:

$ pip freeze > requirements.txt

Maak daarna een nieuw UV-project in dezelfde map:

$ uv init .

Installeer tot slot de dependencies uit je requirementsbestand:

$ uv pip install -r requirements.txt

2. Veelgebruikte pip/virtualenv-commando’s vervangen

Hier is een snel naslagwerk om veelgebruikte pip- en virtualenv-commando’s te vervangen door hun UV-equivalenten:

Na de migratie kun je je oude virtualenv-map veilig verwijderen en UV’s omgevingsbeheer gaan gebruiken. De overgang verloopt doorgaans naadloos, en je kunt desgewenst altijd terugvallen op pip-commando’s via UV’s pip-compatibiliteitslaag.

UV gebruiken in CI/CD en Docker

De snelheid van UV is vooral waardevol in CI/CD-pipelines, waar bij elke build dependencies worden geïnstalleerd. Hier is een voorbeeldworkflow voor GitHub Actions met 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/

De vlag --frozen zorgt ervoor dat de CI exact de versies uit je lockbestand gebruikt, en faalt als het lockbestand verouderd is. Dit garandeert reproduceerbare builds.

Docker-integratie

UV kan ook Docker-imagebuilds aanzienlijk versnellen:

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"]

Door eerst de dependencybestanden te kopiëren en te installeren vóór je de broncode kopieert, profiteer je maximaal van Docker-layercaching. Installatie van dependencies draait alleen opnieuw als pyproject.toml of uv.lock verandert.

Conclusie

UV is een grote stap vooruit in Python-packagemanagement: modern, snel en efficiënt, en een volwaardig alternatief voor traditionele tools. De belangrijkste voordelen zijn:

• Bloedssnelle performance met 10–100x snelheidswinst ten opzichte van pip
• Naadloze integratie met bestaande Python-packagingstandaarden
• Ingebouwd beheer van virtuele omgevingen
• Efficiënte dependency-resolutie en lockfiles
• Lage geheugen- en resourcefootprint

Of je nu een nieuw project start of een bestaand project migreert, UV biedt een robuuste oplossing die je Python-ontwikkelworkflow aanzienlijk kan verbeteren. Door de compatibiliteit met bestaande tools is het een logische keuze voor developers die hun toolchain willen moderniseren zonder hun huidige processen te verstoren.

Terwijl het Python-ecosysteem zich blijft ontwikkelen, laten tools zoals UV zien hoe moderne technologieën zoals Rust de ontwikkelervaring kunnen verbeteren, terwijl de eenvoud en toegankelijkheid waar Python-ontwikkelaars van houden behouden blijven.

Wil je meer leren over dependencybeheer of Python in het algemeen? Bekijk dan deze extra bronnen:

• Python-tutorial voor beginners
• PIP Python-tutorial: definitieve gids
• Cursus Developing Python Packages
• Top 9 Anaconda-alternatieven voor Python-omgevingsbeheer
• Data Scientist in Python | Leer Python voor data science
• Python Poetry: moderne en efficiënte omgeving en dependencybeheer