Python UV: Der ultimative Leitfaden für den schnellsten Python-Paketmanager

Was ist Python UV?

UV ist ein moderner, leistungsstarker Python-Paketmanager und Installer, der in Rust geschrieben wurde. Es ersetzt herkömmliche Python-Paketverwaltungsprogramme wie pip und bietet erhebliche Verbesserungen in Bezug auf Geschwindigkeit, Zuverlässigkeit und Auflösung von Abhängigkeiten.

Dieses Tool repräsentiert eine neue Generation von Python-Paketmanagern, die sich um die häufigsten Probleme im Python-Ökosystem kümmern, wie z. B. langsame Installationszeiten, Abhängigkeitskonflikte und komplexe Umgebungsverwaltung. UV erreicht dies durch seine innovative Architektur und effiziente Implementierung, die es 10-100 Mal schneller macht als herkömmliche Paketmanager.

Die wichtigsten Merkmale, die UV auszeichnen:

Blitzschnelle Paketinstallation und Auflösung von Abhängigkeiten
Kompatibel mit bestehenden Python-Tools und -Workflows
Integrierte Verwaltung der virtuellen Umgebung
Unterstützung für moderne Verpackungsstandards
Zuverlässiges Sperren von Abhängigkeiten und reproduzierbare Umgebungen
Speichereffizienter Betrieb, besonders bei großen Projekten

Egal, ob du an kleinen persönlichen Projekten arbeitest oder große Python-Anwendungen verwaltest, UV ist eine robuste und effiziente Lösung für die Paketverwaltung. In diesem Lernprogramm werden wir alle wichtigen Aspekte von UV behandeln, damit du sofort damit anfangen kannst.

Der Unterschied zwischen UV, Poesie, PIP, Conda und virtualenv

Die erste Frage, die sich Entwickler oft stellen, bevor sie auf ein neues Tool umsteigen, lautet: "Wie schneidet es im Vergleich zu dem Tool ab, das ich bereits verwende?". Im Bereich des Python-Abhängigkeits- und Projektmanagements sind diese vier Tools bereits am weitesten verbreitet:

Vergleichen wir UV mit jedem dieser Tools, um dir bei der Entscheidung zu helfen, ob UV die richtige Wahl für deine Bedürfnisse ist, bevor wir uns mit den Details beschäftigen.

UV vs. PIP und `virtualenv`

PIP und virtualenv sind die traditionellen Werkzeuge für die Verwaltung von Python-Paketen und die Erstellung von virtuellen Umgebungen. Auch wenn sie ihre Aufgabe erfüllen, bietet UV mehrere überzeugende Vorteile:

Geschwindigkeit: Dank der Rust-Implementierung ist UV bei der Paketinstallation und der Auflösung von Abhängigkeiten deutlich schneller als PIP und erledigt oft Aufgaben in Sekunden, für die PIP Minuten brauchen würde.
Integriertes Umweltmanagement: Während virtualenv nur für die Erstellung von Umgebungen und PIP nur für die Verwaltung von Paketen zuständig ist, vereint UV beide Funktionen in einem einzigen Tool und rationalisiert so den Arbeitsablauf.

UV behält die volle Kompatibilität mit dem PIP-Ökosystem bei und behebt gleichzeitig dessen wichtigste Einschränkungen. Sie kann dieselben requirements.txt Dateien und Paketindizes verwenden, was eine nahtlose Migration ermöglicht. Die wichtigsten Unterschiede sind:

Leistung: Durch die parallelen Downloads und die optimierte Abhängigkeitsauflösung ist UV bei großen Projekten 10-100x schneller als PIP.
Speichernutzung: UV benötigt bei der Paketinstallation und der Auflösung von Abhängigkeiten deutlich weniger Speicher als PIP.
Fehlerbehandlung: UV bietet klarere Fehlermeldungen und eine bessere Konfliktlösung, wenn Abhängigkeiten kollidieren.
Reproduzierbarkeit: Der Lockfile-Ansatz von UV gewährleistet konsistente Umgebungen auf verschiedenen Systemen, was bei einfachen requirements.txt Dateien nicht gewährleistet ist.

PIP und virtualenv sind zwar weiterhin praktikable Optionen, aber die moderne Architektur und die kombinierten Funktionen von UV machen es zu einer attraktiven Alternative für Entwickler, die eine bessere Leistung und einen schlankeren Arbeitsablauf suchen. Die Möglichkeit, UV in bestehende Projekte einzubinden, ohne die etablierten Prozesse zu unterbrechen, macht es besonders attraktiv für Teams, die ihre Python-Entwicklungsumgebung schrittweise modernisieren wollen.

UV vs. Conda

Menschen, die PIP und virtualenv nicht nutzen, wenden sich in der Regel an Conda und sie haben gute Gründe dafür:

Conda bietet eine komplette Paketverwaltungslösung, die nicht nur Python-Pakete, sondern auch Abhängigkeiten auf Systemebene verwaltet
Es eignet sich hervorragend für die Verwaltung komplexer wissenschaftlicher Berechnungsumgebungen mit Paketen wie NumPy, SciPy und TensorFlow
Conda-Umgebungen sind besser isoliert und über verschiedene Betriebssysteme hinweg reproduzierbar
Es unterstützt verschiedene Python-Versionen und kann leicht zwischen ihnen wechseln.
Die Anaconda-Distribution wird mit vielen vorinstallierten wissenschaftlichen Paketen geliefert, die es für Datenwissenschaftler bequem machen

Aber auch eingefleischte Conda-Nutzer/innen sollten aus verschiedenen Gründen einen Wechsel zu UV in Betracht ziehen. Die blitzschnelle Paketinstallation und Abhängigkeitsauflösung von UV kann die Einrichtung von Umgebungen im Vergleich zur manchmal trägen Leistung von Conda drastisch beschleunigen. Sein minimaler Ressourcenbedarf bedeutet weniger Speicherbedarf und schnellere Starts. UV fügt sich außerdem nahtlos in bestehende Python-Paketierungsstandards und -Werkzeuge ein und erleichtert so die Zusammenarbeit mit dem gesamten Python-Ökosystem. Für Projekte, die die Conda-Paketverwaltung für Nicht-Python-Pakete nicht benötigen, bietet UV eine schlankere, effizientere Lösung, die die Entwicklungsabläufe deutlich verbessern kann.

UV vs. Poesie

Ich war fast drei Jahre lang Conda-Benutzer, aber nachdem ich Poetry ein paar Mal ausprobiert hatte, habe ich Conda in Schildkrötengeschwindigkeit nie wieder angerührt. Gerade als ich mich mit der Poesie anfreunden konnte, stieß ich auf UV und es scheint fast das Gleiche zu versprechen wie die Poesie:

Abhängigkeitsmanagement: Beide Tools handhaben Paketabhängigkeiten und virtuelle Umgebungen effektiv
Projektstruktur: Beide bieten Werkzeuge für die Initialisierung und Strukturierung von Python-Projekten
Dateien sperren: Beide erzeugen Sperrdateien, um reproduzierbare Umgebungen zu gewährleisten
Paketveröffentlichung: Beide unterstützen die Veröffentlichung von Paketen bei PyPI
Moderner Werkzeugbau: Beide stellen moderne Ansätze für das Python-Projektmanagement dar

Das entscheidende Merkmal von UV ist jedoch seine blitzschnelle Geschwindigkeit und sein minimaler Ressourcenverbrauch. Während Poetry eine deutliche Verbesserung gegenüber herkömmlichen Tools darstellt, hebt UV die Leistung aufgrund seiner Rust-Implementierung auf eine andere Ebene. Die Kompatibilität von UV mit bestehenden Python-Paketen bedeutet auch, dass es mit anderen Tools wie pip zusammenarbeiten kann und damit eine Flexibilität bietet, die dem eher eigenwilligen Ansatz von Python manchmal fehlt.

Hier ist eine Tabelle, die die Unterschiede zusammenfasst, die wir gerade behandelt haben:

Feature	UV	PIP + virtualenv	Conda	Poesie
Umsetzung	Rost	Python	Python	Python
Geschwindigkeit	10-100x schneller als Pip	Basislinie	Langsamer als Pip	Schneller als Pip
Speichernutzung	Sehr effizient	Höher	Hoch	Mäßig
Umweltmanagement	Eingebaut	Separate Werkzeuge erforderlich	Eingebaut	Eingebaut
Auflösung von Abhängigkeiten	Schneller, moderner Resolver	Basic	Umfassend	Moderner Resolver
Nicht-Python Pakete	Nein	Nein	Ja	Nein
Dateien sperren	Ja	Nein (basic requirements.txt)	Ja	Ja
Projektstruktur	Ja	Nein	Nein	Ja
Paket Veröffentlichung	Ja	Ja (mit Schnur)	Ja	Ja
Kompatibilität	Arbeitet mit dem bestehenden Pip-Ökosystem	Standard-Python-Werkzeug	Eigenes Ökosystem	Mehr Meinungsfreiheit
Fehlerbehandlung	Fehlermeldungen löschen	Basic	Gut	Gut
Ressourcen-Fußabdruck	Minimal	Mäßig	Schwer	Mäßig
Schwerpunkt Wissenschaftliches Rechnen	Nein	Nein	Ja	Nein
Plattformübergreifende Konsistenz	Ja	Begrenzt	Ausgezeichnet	Gut

Wenn du denkst, dass UV einen Wechsel wert ist, dann lies weiter.

Erste Schritte mit UV für Python-Projekte

In diesem Abschnitt erfahren wir, wie du ein Projekt mit UV von Grund auf neu startest. Wie du von bestehenden Projekten zu UV migrierst, besprechen wir in einem späteren Abschnitt.

Installation von UV

UV kann mit cURL auf macOS und Linux systemweit installiert werden:

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

Und mit Powershell unter Windows (stelle sicher, dass du Powershell mit Administratorrechten ausführst):

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

UV ist auch über Homebrew verfügbar:

$ brew install uvBereitgestellt von

Eine PIP-Installation ist möglich, wird aber nicht empfohlen:

$ pip install uv  # Make sure you have a virtual environment activatedBereitgestellt von

Danach kannst du die Installation überprüfen, indem du uv version aufrufst:

$ uv version
uv 0.4.25 (97eb6ab4a 2024-10-21)Bereitgestellt von

Initialisierung eines neuen Projekts

Die Arbeit an Projekten ist der wichtigste Teil der UV-Erfahrung. Du beginnst damit, ein leeres Projekt mit dem Befehl uv init zu initialisieren:

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

Der Befehl erstellt sofort ein neues Verzeichnis explore-uv mit dem folgenden Inhalt:

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

Git wird automatisch initialisiert und die wichtigsten Git-bezogenen Dateien wie .gitignore und eine leere README.md werden erstellt. Die Datei .python-version enthält die für das Projekt verwendete Python-Version, während pyproject.toml als Hauptkonfigurationsdatei für Projektmetadaten und Abhängigkeiten dient. Es wird auch eine Beispieldatei hello.py erstellt, damit du schnell loslegen kannst.

Mehr über die Erstellung von Projekten erfährst du in der UV-Dokumentation.

Hinzufügen der ersten Abhängigkeiten zum Projekt

UV kombiniert die Erstellung der Umgebung und die Installation der Abhängigkeiten in einem einzigen Befehl - uv add:

$ uv add scikit-learn xgboost
Using CPython 3.9.20 interpreter at: /opt/homebrew/opt/[email protected]/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
 ...Bereitgestellt von

Wenn du den Befehl add zum ersten Mal ausführst, erstellt UV eine neue virtuelle Umgebung im aktuellen Arbeitsverzeichnis und installiert die angegebenen Abhängigkeiten. Bei späteren Durchläufen verwendet UV die bestehende virtuelle Umgebung wieder und installiert oder aktualisiert nur die neu angeforderten Pakete, um ein effizientes Abhängigkeitsmanagement zu gewährleisten.

Ein weiterer wichtiger Prozess, der bei jedem add Befehl stattfindet, ist das Auflösen von Abhängigkeiten. UV verwendet einen modernen Dependency Resolver, der den gesamten Abhängigkeitsgraphen analysiert, um eine kompatible Menge von Paketversionen zu finden, die alle Anforderungen erfüllen. Das hilft, Versionskonflikte zu vermeiden und sorgt für reproduzierbare Umgebungen. Der Resolver berücksichtigt Faktoren wie Versionseinschränkungen, Kompatibilität mit Python-Versionen und plattformspezifische Anforderungen, um die optimale Menge an zu installierenden Paketen zu bestimmen.

UV aktualisiert auch die Dateien pyproject.toml und uv.lock nach jedem Add-Befehl. Hier siehst du, wie die TOML-Datei nach der Installation von Scikit-learn und XGBoost aussieht:

$ 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",
]Bereitgestellt von

Um eine Abhängigkeit aus der Umgebung und der Datei pyproject.toml zu entfernen, kannst du den Befehl uv remove verwenden. Es deinstalliert das Paket und alle seine untergeordneten Abhängigkeiten:

$ uv remove scikit-learnBereitgestellt von

Wir werden das Abhängigkeitsmanagement in einem späteren Abschnitt ausführlicher behandeln.

Python-Skripte mit UV ausführen

Sobald du die notwendigen Abhängigkeiten installiert hast, kannst du wie gewohnt an deinen Python-Skripten arbeiten. UV bietet verschiedene Möglichkeiten, Python-Code auszuführen:

Um ein Python-Skript direkt auszuführen, kannst du den Befehl uv run gefolgt von deinem Skriptnamen anstelle der üblichen python script.py Syntax verwenden:

$ uv run hello.pyBereitgestellt von

Der Befehl run stellt sicher, dass das Skript innerhalb der virtuellen Umgebung UV ausgeführt wird, die für das Projekt erstellt wurde.

Python-Versionen in UV verwalten

Die Verwaltung von Python-Versionen ist ein wichtiger Teil des Abhängigkeitsmanagements. UV bietet einfache Befehle, um zu steuern, welche Python-Version du verwendest. Sehen wir uns an, wie du den Befehl uv python verwenden kannst.

Auflistung vorhandener Python-Versionen

Da Python auf vielen Systemen bereits installiert ist, kann UV diese vorhandenen Installationen standardmäßig erkennen. Um zum Beispiel alle Python-Versionen aufzulisten, die UV auf deinem System erkennt, führe den folgenden Befehl aus:

$ uv python list --only-installed
cpython-3.13.0-macos-aarch64-none     /opt/homebrew/opt/[email protected]/bin/python3.13 -> ../Frameworks/Python.framework/Versions/3.13/bin/python3.13
cpython-3.12.7-macos-aarch64-none     /opt/homebrew/opt/[email protected]/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/[email protected]/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/[email protected]/bin/python3.10 -> ../Frameworks/Python.framework/Versions/3.10/bin/python3.10
cpython-3.9.20-macos-aarch64-none     /opt/homebrew/opt/[email protected]/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/python3Bereitgestellt von

Der Befehl hat meine Conda- und Brew-Versionen korrekt erkannt.

Ändern von Python-Versionen für das aktuelle Projekt

Du kannst die Python-Version für dein aktuelles UV-Projekt jederzeit wechseln, solange die neue Version den Spezifikationen in deiner pyproject.toml Datei entspricht. Die folgende Datei erfordert zum Beispiel Python 3.9 und höher:

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

Das bedeutet, dass du die Python-Version in der Datei .python-version auf eine beliebige höhere Version, wie z.B. 3.11.7, ändern kannst. Rufe danach uv sync an.

Der Befehl prüft zunächst die vorhandenen Python-Installationen. Wenn die gewünschte Version nicht gefunden wird, lädt UV sie herunter und installiert sie im Pfad /Users/username/.local/share/uv/python. UV erstellt außerdem eine neue virtuelle Umgebung innerhalb des Projektverzeichnisses, die die alte ersetzt.

Diese neue Umgebung verfügt nicht über die Abhängigkeiten, die in deiner pyproject.toml Datei aufgeführt sind, also musst du sie mit dem folgenden Befehl installieren:

$ uv pip install -e .Bereitgestellt von

Beachte, dass uv Befehle manchmal Permission Denied Fehler auslösen können. In diesen Fällen musst du den Befehl sudo verwenden, wenn du unter macOS oder Linux arbeitest, oder die Eingabeaufforderung mit Administratorrechten ausführen, wenn du unter Windows arbeitest. Eine noch bessere Lösung wäre es, den Eigentümer des UV-Home-Verzeichnisses auf den Benutzer zu ändern:

$ sudo chown -R $USER ~/.local/share/uv  # macOS or LinuxBereitgestellt von

Wenn du mehr über die Verwaltung von Python-Versionen mit UV erfahren möchtest, schau in die Dokumentation.

Was sind UV-Tools und wie benutzt man sie?

Einige Python-Pakete sind als Kommandozeilen-Tools verfügbar, z. B. black für die Code-Formatierung, flake8 für das Linting, pytest für das Testen, mypy für die Typüberprüfung usw. UV bietet zwei spezielle Schnittstellen, um diese Pakete zu verwalten:

1. uv tool run verwenden:

$ uv tool run black hello.pyBereitgestellt von

2. Benutze den kürzeren und bequemeren Befehl uvx:

$ uvx black hello.pyBereitgestellt von

Wenn diese Befehle ausgeführt werden, erstellt UV eine temporäre virtuelle Umgebung in seinem Cache. Von dort aus wird das gewünschte Tool installiert und ausgeführt. Mit anderen Worten: Du kannst Kommandozeilen-Tools verwenden, ohne sie in der virtuellen Umgebung des Projekts zu installieren, was zu einer schnelleren Ausführung und saubereren Projektabhängigkeiten führt.

Die wichtigsten Punkte zu den Schnittstellen der Tools:

Funktioniert mit jedem Python-Paket, das Kommandozeilen-Tools wie flake8, mypy, black oder pytest bereitstellt
Zwischengespeicherte Umgebungen werden automatisch bereinigt, wenn du den Cache von UV leerst.
Neue Cache-Umgebungen werden bei Bedarf erstellt
Perfekt für den gelegentlichen Einsatz von Entwicklungswerkzeugen

Lies den Abschnitt UV Tools in der Dokumentation, um mehr über diese Schnittstellen zu erfahren.

Was sind Sperrdateien in UV?

Sperrdateien (uv.lock) sind ein wesentlicher Bestandteil des Abhängigkeitsmanagements in UV. Wenn du uv add Befehle ausführst, um Abhängigkeiten zu installieren, erstellt und aktualisiert UV automatisch eine uv.lock Datei. Diese Sperrdatei dient mehreren wichtigen Zwecken:

Sie zeichnet die genauen Versionen aller Abhängigkeiten und ihrer Unterabhängigkeiten auf, die installiert wurden.
Es sorgt für reproduzierbare Builds, indem es die Versionen der Abhängigkeiten über verschiedene Umgebungen hinweg "sperrt".
Es hilft, die "Abhängigkeitshölle" zu vermeiden, indem es konsistente Paketversionen beibehält.
Das beschleunigt die Installation, da UV die gesperrten Versionen verwenden kann, anstatt die Abhängigkeiten erneut aufzulösen.

UV verwaltet die Sperrdatei automatisch - du musst sie nicht manuell bearbeiten. Die Lock-Datei sollte in die Versionskontrolle übertragen werden, um sicherzustellen, dass alle Entwickler die gleichen Versionen der Abhängigkeiten verwenden.

Der Unterschied zwischen Sperrdateien und `requirements.txt`

Obwohl sowohl Lock-Dateien als auch requirements.txt dazu dienen, Abhängigkeiten zu verfolgen, haben sie unterschiedliche Zwecke und Anwendungsfälle. Lock-Dateien enthalten detaillierte Informationen über die genauen Paketversionen und ihren kompletten Abhängigkeitsbaum, um konsistente Entwicklungsumgebungen zu gewährleisten. Requirements.txt-Dateien sind einfacher und enthalten in der Regel nur direkte Abhängigkeiten und werden von vielen Python-Tools unterstützt.

Lock-Dateien sind für die Entwicklung wichtig, um reproduzierbare Builds zu erhalten und Abhängigkeitskonflikte zu vermeiden. Requirements.txt-Dateien eignen sich besser für Einsatzszenarien oder wenn du den Code mit Benutzern teilst, die UV vielleicht nicht verwenden. Sie sind auch für die Kompatibilität mit Tools und Diensten notwendig, die das UV-Lock-Dateiformat nicht unterstützen.

Du kannst beide Dateien beibehalten, indem du die Sperrdatei von UV für die Entwicklung verwendest und eine requirements.txt für die Bereitstellung erstellst. Um eine requirements.txt aus einer UV-Lock-Datei zu erstellen, verwende den folgenden Befehl:

$ uv export -o requirements.txtBereitgestellt von

Dadurch wird eine Textdatei mit angehefteten Versionen erstellt, die auf deiner Lock-Datei basiert. So kannst du die Abhängigkeiten deines Projekts in einem Standardformat weitergeben und gleichzeitig von der fortschrittlichen Abhängigkeitsverwaltung von UV während der Entwicklung profitieren.

Du kannst mehr über die Verwaltung von Sperrdateien in der Dokumentation erfahren.

Fortgeschrittenes Abhängigkeitsmanagement mit UV

In diesem Abschnitt werden wir anspruchsvollere Methoden zur Verwaltung von Abhängigkeiten in UV erkunden. Wir werden lernen, wie man Abhängigkeiten aktualisiert, sie optional macht oder sie in eine Abhängigkeitsgruppe einbindet.

Abhängigkeiten aktualisieren

Bei langfristigen Projekten ist es üblich, die verwendeten Pakete zu aktualisieren, um die neuesten Funktionen in die Tabelle aufzunehmen. Oder manchmal führt ein Paket, das du verwendest, bahnbrechende Änderungen ein und du möchtest sicherstellen, dass diese Version nicht versehentlich in deiner Umgebung installiert wird. Der Befehl add kann in diesen und allen anderen Szenarien, in denen du die Einschränkungen oder Versionen bestehender Abhängigkeiten ändern musst, erneut verwendet werden.

1. Installiere die neueste Version eines Pakets:

$ uv add requestsBereitgestellt von

2. Installiere eine bestimmte Version:

$ uv add requests=2.1.2Bereitgestellt von

3. Ändere die Grenzen der Beschränkungen eines Pakets:

$ uv add 'requests<3.0.0'Bereitgestellt von

4. Mache eine Abhängigkeit plattformspezifisch:

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

Hinzufügen optionaler Abhängigkeiten

Optionale Abhängigkeiten sind Pakete, die für die Kernfunktionalität deines Projekts nicht erforderlich sind, aber für bestimmte Funktionen benötigt werden können. Pandas hat zum Beispiel ein excel extra und ein plot extra, um die Installation von Excel-Parsern und matplotlib zu vermeiden, es sei denn, jemand benötigt sie ausdrücklich. Optionals werden normalerweise mit der pip install pandas[plot, excel] Syntax installiert.

Bei UV ist die Syntax etwas anders. Stelle zunächst sicher, dass das Kernpaket von Pandas installiert ist:

$ uv add pandasBereitgestellt von

Dann fügst du die optionalen Abhängigkeiten hinzu:

$ uv add pandas --optional plot excelBereitgestellt von

Sobald sie gelöst sind, werden sie in deinem pyproject.toml in folgendem Format aufgelistet:

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

Abhängigkeitsgruppen

Mit Hilfe von Abhängigkeitsgruppen kannst du deine Abhängigkeiten in logische Gruppen einteilen, z. B. Entwicklungsabhängigkeiten, Testabhängigkeiten oder Dokumentationsabhängigkeiten. Dies ist nützlich, um deine Produktionsabhängigkeiten von deinen Entwicklungsabhängigkeiten zu trennen.

Um eine Abhängigkeit zu einer bestimmten Gruppe hinzuzufügen, verwendest du das Flag --group:

$ uv add --group group_name package_nameBereitgestellt von

Dann können die Nutzer/innen mit den Tags --group, --only-group und --no-group bestimmen, welche Gruppen installiert werden sollen.

Umstellung von PIP und Virtualenv auf UV

Der Umstieg von PIP und virtualenv auf UV ist einfach, da UV die Kompatibilität mit den bestehenden Python-Paketierungsstandards beibehält. Hier ist eine Schritt-für-Schritt-Anleitung, damit der Übergang reibungslos verläuft:

1. Ein bestehendes virtualenv-Projekt konvertieren

Wenn du ein bestehendes Projekt hast, das virtualenv und pip verwendet, beginne damit, eine requirements.txt Datei aus deiner aktuellen Umgebung zu erstellen, falls du das noch nicht getan hast:

$ pip freeze > requirements.txtBereitgestellt von

Erstelle dann ein neues UV-Projekt im selben Verzeichnis:

$ uv init .Bereitgestellt von

Zum Schluss installierst du die Abhängigkeiten aus deiner Anforderungsdatei:

$ uv pip install -r requirements.txtBereitgestellt von

2. Gemeinsame pip/virtualenv-Befehle ersetzen

Hier findest du eine Kurzanleitung, um gängige pip- und virtualenv-Befehle durch ihre UV-Entsprechungen zu ersetzen:

pip/virtualenv Befehl	UV-Äquivalent
`python -m venv .venv`	`uv venv`
`pip install package`	`uv add package`
`pip install -r requirements.txt`	`uv pip install -r requirements.txt`
`pip uninstall package`	`uv remove package`
`pip freeze`	`uv pip freeze`
`pip list`	`uv pip list`

Nach der Migration kannst du dein altes virtualenv-Verzeichnis sicher entfernen und mit der Verwaltung der virtuellen Umgebung von UV beginnen. Der Übergang ist in der Regel nahtlos, und du kannst bei Bedarf jederzeit über die UV-Kompatibilitätsebene pip auf die Befehle von pip zurückgreifen.

Fazit

UV stellt einen bedeutenden Fortschritt in der Python-Paketverwaltung dar und bietet eine moderne, schnelle und effiziente Alternative zu herkömmlichen Tools. Seine wichtigsten Vorteile sind:

Rasend schnelle Leistung mit 10-100-facher Geschwindigkeitssteigerung gegenüber Pip
Nahtlose Integration in bestehende Python-Paketierungsstandards
Integrierte Verwaltung der virtuellen Umgebung
Effiziente Auflösung von Abhängigkeiten und Unterstützung von Sperrdateien
Geringer Speicherbedarf und Ressourcenverbrauch

Ganz gleich, ob du ein neues Projekt beginnst oder ein bestehendes migrierst, UV bietet eine robuste Lösung, die deinen Python-Entwicklungsworkflow erheblich verbessern kann. Seine Kompatibilität mit bestehenden Tools macht es zu einer einfachen Wahl für Entwickler, die ihre Toolchain modernisieren wollen, ohne ihre aktuellen Prozesse zu unterbrechen.

Während sich das Python-Ökosystem weiterentwickelt, zeigen Werkzeuge wie UV, wie moderne Technologien wie Rust die Entwicklungserfahrung verbessern und gleichzeitig die Einfachheit und Zugänglichkeit bewahren können, die Python-Entwickler schätzen.

Wenn du mehr über die Verwaltung von Abhängigkeiten oder Python im Allgemeinen erfahren möchtest, kannst du diese zusätzlichen Quellen nutzen:

Python UV FAQs

Ist UV schneller als pip für die Python-Paketverwaltung?

Ja, UV ist deutlich schneller als pip und bietet eine 10-100fache Geschwindigkeitssteigerung bei der Paketinstallation und der Auflösung von Abhängigkeiten. Diese Leistungssteigerung wird durch die Rust-Implementierung von UV und die optimierten parallelen Download-Funktionen erreicht. Besonders bei großen Projekten können Aufgaben, die mit Pip Minuten dauern, mit UV in Sekunden erledigt werden.

Kann ich UV mit bestehenden pip requirements.txt Dateien verwenden?

Ja, UV ist vollständig kompatibel mit bestehenden pip requirements.txt Dateien und kann sie direkt mit dem Befehl uv pip install -r requirements.txt importieren. UV behält die Kompatibilität mit dem Python-Packaging-Ökosystem bei und bietet gleichzeitig eine bessere Leistung und Funktionen zur Verwaltung von Abhängigkeiten.

Was sind die Vorteile von UV gegenüber Poesie und Conda?

UV bietet mehrere Vorteile gegenüber Poetry und Conda:

Schnellere Leistung durch die Implementierung von Rust
Geringerer Speicherbedarf und geringerer Ressourcenverbrauch
Bessere Kompatibilität mit bestehenden Python-Werkzeugen
Einfacherer Arbeitsablauf im Vergleich zu Conda
Flexiblerer Ansatz im Vergleich zur rechthaberischen Struktur der Poesie

Während Conda sich hervorragend für die Verwaltung von Nicht-Python-Paketen eignet und Poetry ein robustes Projektmanagement bietet, bietet UV die beste Balance aus Geschwindigkeit und Kompatibilität.

Unterstützt UV virtuelle Umgebungen?

Ja, UV enthält eine integrierte Verwaltung der virtuellen Umgebung. Wenn du uv add zum ersten Mal in einem Projekt ausführst, erstellt es automatisch eine virtuelle Umgebung und verwaltet sie für dich. UV vereint die Erstellung von Umgebungen und die Verwaltung von Paketen in einem einzigen Tool und vereinfacht so den Arbeitsablauf bei der Python-Entwicklung im Vergleich zur Verwendung separater Tools wie pip und virtualenv.

Themen

Python