Direkt zum Inhalt

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

Lerne, wie du UV, den schnellsten Python-Paketmanager aus dem Jahr 2025, nutzen kannst. Entdecke 10x schnelleres Abhängigkeitsmanagement, virtuelle Umgebungen und eine nahtlose Migration von pip, Poetry und Conda.
Aktualisierte 9. Jan. 2025  · 11 Min. Lesezeit

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

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.


Bex Tuychiev's photo
Author
Bex Tuychiev
LinkedIn

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. 

Themen

Top DataCamp Kurse

Lernpfad

Python Data Fundamentals

30hrs hr
Grow your data skills, discover how to manipulate and visualize data, and apply advanced analytics to make data-driven decisions.
Siehe DetailsRight Arrow
Kurs starten
Mehr anzeigenRight Arrow
Verwandt

Der Blog

Die 20 besten Snowflake-Interview-Fragen für alle Niveaus

Bist du gerade auf der Suche nach einem Job, der Snowflake nutzt? Bereite dich mit diesen 20 besten Snowflake-Interview-Fragen vor, damit du den Job bekommst!
Nisha Arya Ahmed's photo

Nisha Arya Ahmed

20 Min.

Der Blog

Die 32 besten AWS-Interview-Fragen und Antworten für 2024

Ein kompletter Leitfaden zur Erkundung der grundlegenden, mittleren und fortgeschrittenen AWS-Interview-Fragen, zusammen mit Fragen, die auf realen Situationen basieren. Es deckt alle Bereiche ab und sorgt so für eine abgerundete Vorbereitungsstrategie.
Zoumana Keita 's photo

Zoumana Keita

30 Min.

Der Blog

Top 30 Generative KI Interview Fragen und Antworten für 2024

Dieser Blog bietet eine umfassende Sammlung von Fragen und Antworten zu generativen KI-Interviews, die von grundlegenden Konzepten bis hin zu fortgeschrittenen Themen reichen.
Hesam Sheikh Hassani's photo

Hesam Sheikh Hassani

15 Min.

Der Blog

2022-2023 DataCamp Classrooms Jahresbericht

Zu Beginn des neuen Schuljahres ist DataCamp Classrooms motivierter denn je, das Lernen mit Daten zu demokratisieren. In den letzten 12 Monaten sind über 7.650 neue Klassenzimmer hinzugekommen.
Nathaniel Taylor-Leach's photo

Nathaniel Taylor-Leach

8 Min.

Der Blog

Q2 2023 DataCamp Donates Digest

DataCamp Donates hat im zweiten Quartal 2023 über 20.000 Stipendien an unsere gemeinnützigen Partner vergeben. Erfahre, wie fleißige benachteiligte Lernende diese Chancen in lebensverändernde berufliche Erfolge verwandelt haben.
Nathaniel Taylor-Leach's photo

Nathaniel Taylor-Leach

Mehr anzeigenMehr anzeigen