Lernpfad
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 sh
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"
UV ist auch über Homebrew verfügbar:
$ brew install uv
Eine PIP-Installation ist möglich, wird aber nicht empfohlen:
$ pip install uv # Make sure you have a virtual environment activated
Danach kannst du die Installation überprüfen, indem du uv version
aufrufst:
$ uv version
uv 0.4.25 (97eb6ab4a 2024-10-21)
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-uv
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.toml
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/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
...
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",
]
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-learn
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.py
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/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
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"
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 .
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 Linux
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.py
2. Benutze den kürzeren und bequemeren Befehl uvx
:
$ uvx black hello.py
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.txt
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 requests
2. Installiere eine bestimmte Version:
$ uv add requests=2.1.2
3. Ändere die Grenzen der Beschränkungen eines Pakets:
$ uv add 'requests<3.0.0'
4. Mache eine Abhängigkeit plattformspezifisch:
$ uv add 'requests; sys_platform="linux"'
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 pandas
Dann fügst du die optionalen Abhängigkeiten hinzu:
$ uv add pandas --optional plot excel
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",
...
]
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_name
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.txt
Erstelle dann ein neues UV-Projekt im selben Verzeichnis:
$ uv init .
Zum Schluss installierst du die Abhängigkeiten aus deiner Anforderungsdatei:
$ uv pip install -r requirements.txt
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 |
|
|
|
|
|
|
|
|
|
|
|
|
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 Tutorial für Anfänger
- PIP Python Tutorial: Definitiver Leitfaden
- Entwicklung von Python-Paketen Kurs
- Die 9 besten Anaconda-Alternativen für die Python-Umgebungsverwaltung
- Data Scientist in Python | Python für Data Science lernen
- Python Poetry: Modernes und effizientes Python-Umgebungs- und Abhängigkeitsmanagement
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.

Ich bin ein Data Science Content Creator mit über 2 Jahren Erfahrung und einem der größten Follower auf Medium. Ich schreibe gerne ausführliche Artikel über KI und ML mit einem etwas sarkastischen Stil, denn man muss etwas tun, damit sie nicht so langweilig sind. Ich habe mehr als 130 Artikel verfasst und einen DataCamp-Kurs gemacht, ein weiterer ist in Vorbereitung. Meine Inhalte wurden von über 5 Millionen Augenpaaren gesehen, von denen 20.000 zu Followern auf Medium und LinkedIn wurden.
Top DataCamp Kurse
Kurs
Intermediate Python
Kurs
Developing Python Packages
Der Blog
Die 20 besten Snowflake-Interview-Fragen für alle Niveaus

Nisha Arya Ahmed
20 Min.
Der Blog
Die 32 besten AWS-Interview-Fragen und Antworten für 2024
Der Blog
Top 30 Generative KI Interview Fragen und Antworten für 2024

Hesam Sheikh Hassani
15 Min.
Der Blog
2022-2023 DataCamp Classrooms Jahresbericht
Der Blog