Python-Projekt-Setup 2026: UV + Ruff + Ty + Polars

Bild vom Herausgeber

# Einführung

Python Früher bedeutete die Projekteinrichtung, dass Sie ein Dutzend kleiner Entscheidungen treffen mussten, bevor Sie Ihre erste nützliche Codezeile schrieben. Welcher Umweltmanager? Welches Abhängigkeitstool? Welcher Formatierer? Welcher Linter? Welcher Typprüfer? Und wenn Ihr Projekt Daten berührt, sollten Sie damit beginnen? Pandas, DuckDBoder etwas neueres?

Im Jahr 2026 kann diese Einrichtung viel einfacher sein.

Für die meisten neuen Projekte ist der sauberste Standardstapel:

• UV für Python-Set up, Umgebungen, Abhängigkeitsmanagement, Sperren und Befehlsausführung.
• Halskrause zum Flusen und Formatieren.
• Ty zur Typprüfung.
• Polaren für Datenrahmenarbeit.

Dieser Stack ist schnell, fashionable und besonders kohärent. Drei der vier Werkzeuge (UV, Ruff und Ty) stammen tatsächlich von derselben Firma, Astralwas bedeutet, dass sie sich nahtlos untereinander und in Ihre integrieren lassen pyproject.toml.

# Verstehen, warum dieser Stack funktioniert

Ältere Setups sahen oft so aus:

pyenv + pip + venv + pip-tools or Poetry + Black + isort + Flake8 + mypy + pandas

Dies funktionierte, führte jedoch zu erheblichen Überschneidungen, Inkonsistenzen und Wartungsaufwand. Sie verfügten über separate Instruments für die Umgebungseinrichtung, Abhängigkeitssperre, Formatierung, Importsortierung, Linting und Typisierung. Jedes neue Projekt begann mit einer Auswahlexplosion. Der Standardstapel 2026 macht all das zunichte. Das Endergebnis sind weniger Instruments, weniger Konfigurationsdateien und weniger Reibungsverluste beim Onboarding von Mitwirkenden oder bei der Einrichtung der kontinuierlichen Integration (CI). Bevor wir mit der Einrichtung beginnen, werfen wir einen kurzen Blick darauf, was die einzelnen Instruments im 2026-Stack tun:

1. UV: Dies ist die Foundation für Ihr Projekt-Setup. Es erstellt das Projekt, verwaltet Versionen, verwaltet Abhängigkeiten und führt Ihren Code aus. Anstatt virtuelle Umgebungen manuell einzurichten und Pakete zu installieren, übernimmt uv die schwere Arbeit. Es hält Ihre Umgebung mithilfe einer Sperrdatei konsistent und stellt sicher, dass alles korrekt ist, bevor ein Befehl ausgeführt wird.
2. Halskrause: Dies ist Ihr All-in-One-Device für Codequalität. Es ist extrem schnell, prüft auf Probleme, behebt viele davon automatisch und formatiert auch Ihren Code. Sie können es anstelle von Instruments wie Black, isort, Flake8 und anderen verwenden.
3. Ty: Dies ist ein neueres Device zur Typprüfung. Es hilft beim Erkennen von Fehlern, indem es die Typen in Ihrem Code überprüft, und funktioniert mit verschiedenen Editoren. Obwohl neuer als Instruments wie mypy oder PyrrightEs ist für moderne Arbeitsabläufe optimiert.
4. Polaren: Dies ist eine moderne Bibliothek für die Arbeit mit Datenrahmen. Der Schwerpunkt liegt auf der effizienten Datenverarbeitung mittels Lazy Execution, was bedeutet, dass Abfragen vor der Ausführung optimiert werden. Dies macht es schneller und speichereffizienter als Pandas, insbesondere bei großen Datenaufgaben.

# Überprüfung der Voraussetzungen

Die Einrichtung ist recht einfach. Hier sind die wenigen Dinge, die Sie für den Anfang benötigen:

• Terminal: macOS Terminal, Home windows PowerShell oder eine beliebige Linux-Shell.
• Internetverbindung: Erforderlich für das einmalige UV-Installationsprogramm und Paket-Downloads.
• Code-Editor: VS-Code wird empfohlen, da es intestine mit Ruff und Ty funktioniert, aber jeder Editor ist in Ordnung.
• Git: Erforderlich für die Versionskontrolle; Beachten Sie, dass uv a initialisiert Git Repository automatisch.

Das ist es. Du tust nicht muss Python vorinstalliert sein. Du tust nicht brauche pip, venv, pyenv oder conda. uv übernimmt für Sie die Set up und das Umgebungsmanagement.

# Schritt 1: Set up von UV

uv bietet ein eigenständiges Installationsprogramm, das unter macOS, Linux und Home windows funktioniert, ohne dass Python oder erforderlich ist Rost auf Ihrem Pc vorhanden sein.

macOS und Linux:

curl -LsSf https://astral.sh/uv/set up.sh | sh

Home windows PowerShell:

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

Starten Sie nach der Set up Ihr Terminal neu und überprüfen Sie Folgendes:

Ausgabe:

uv 0.8.0 (Homebrew 2025-07-17)

Diese einzelne Binärdatei ersetzt nun pyenv, pip, venv, pip-tools und die Projektmanagementebene von Poetry.

# Schritt 2: Erstellen eines neuen Projekts

Navigieren Sie zu Ihrem Projektverzeichnis und erstellen Sie ein neues Projekt:

uv init my-project
cd my-project

UV schafft eine saubere Ausgangsstruktur:

my-project/
├── .python-version
├── pyproject.toml
├── README.md
└── primary.py

Forme es in ein um src/ Format, das Importe, Paketierung, Testisolierung und Typprüfkonfiguration verbessert:

mkdir -p src/my_project checks information/uncooked information/processed
mv primary.py src/my_project/primary.py
contact src/my_project/__init__.py checks/test_main.py

Ihre Struktur sollte nun so aussehen:

my-project/
├── .python-version
├── README.md
├── pyproject.toml
├── uv.lock
├── src/
│   └── my_project/
│       ├── __init__.py
│       └── primary.py
├── checks/
│   └── test_main.py
└── information/
    ├── uncooked/
    └── processed/

Wenn Sie eine bestimmte Model benötigen (z. B. 3.12), kann uv diese installieren und anheften:

uv python set up 3.12
uv python pin 3.12

Der pin Der Befehl schreibt die Model in .python-versionum sicherzustellen, dass jedes Teammitglied denselben Dolmetscher verwendet.

# Schritt 3: Abhängigkeiten hinzufügen

Das Hinzufügen von Abhängigkeiten ist ein einzelner Befehl, der gleichzeitig auflöst, installiert und sperrt:

uv erstellt automatisch eine virtuelle Umgebung (.venv/), falls nicht vorhanden, löst den Abhängigkeitsbaum auf, installiert Pakete und Updates uv.lock mit exakten, angepinnten Versionen.

Für Instruments, die nur während der Entwicklung benötigt werden, verwenden Sie die --dev Flagge:

uv add --dev ruff ty pytest

Dadurch werden sie in einem separaten Bereich platziert (dependency-groups) Abschnitt in pyproject.tomlwodurch Produktionsabhängigkeiten schlank bleiben. Du musst nie rennen supply .venv/bin/activate; wenn Sie es verwenden uv runaktiviert es automatisch die richtige Umgebung.

# Schritt 4: Konfigurieren von Ruff (Linting und Formatierung)

Ruff wird direkt in Ihrem konfiguriert pyproject.toml. Fügen Sie die folgenden Abschnitte hinzu:

(software.ruff)
line-length = 100
target-version = "py312"

(software.ruff.lint)
choose = ("E4", "E7", "E9", "F", "B", "I", "UP")

(software.ruff.format)
docstring-code-format = true
quote-style = "double"

Eine Zeilenlänge von 100 Zeichen ist für moderne Bildschirme ein guter Kompromiss. Regelgruppen flake8-bugbear (B), isort (ich) und pyupgrade (UP) einen echten Mehrwert schaffen, ohne ein neues Repository zu überfordern.

Laufkrause:

# Lint your code
uv run ruff test .

# Auto-fix points the place potential
uv run ruff test --fix .

# Format your code
uv run ruff format .

Beachten Sie das Muster: uv run <software> <args>. Sie installieren niemals Instruments world oder aktivieren Umgebungen manuell.

# Schritt 5: Ty für die Typprüfung konfigurieren

Ty ist auch in konfiguriert pyproject.toml. Fügen Sie diese Abschnitte hinzu:

(software.ty.surroundings)
root = ("./src")

(software.ty.guidelines)
all = "warn"

((software.ty.overrides))
embrace = ("src/**")

(software.ty.overrides.guidelines)
possibly-unresolved-reference = "error"

(software.ty.terminal)
error-on-warning = false
output-format = "full"

Diese Konfiguration startet Ty im Warnmodus, was splendid für die Übernahme ist. Sie beheben zunächst offensichtliche Probleme und stufen Regeln dann nach und nach in Fehler um. Behalten information/** Ausgeschlossen verhindert Typprüfungsrauschen aus Nicht-Code-Verzeichnissen.

# Schritt 6: Pytest konfigurieren

Fügen Sie einen Abschnitt für Pytest hinzu:

(software.pytest.ini_options)
testpaths = ("checks")

Führen Sie Ihre Testsuite aus mit:

# Schritt 7: Untersuchen der vollständigen pyproject.toml

So sieht Ihre endgültige Konfiguration aus, wenn alles verkabelt ist – eine Datei, jedes Device konfiguriert, ohne verstreute Konfigurationsdateien:

(venture)
identify = "my-project"
model = "0.1.0"
description = "Fashionable Python venture with uv, Ruff, Ty, and Polars"
readme = "README.md"
requires-python = ">=3.13"
dependencies = (
    "polars>=1.39.3",
)

(dependency-groups)
dev = (
    "pytest>=9.0.2",
    "ruff>=0.15.8",
    "ty>=0.0.26",
)

(software.ruff)
line-length = 100
target-version = "py312"

(software.ruff.lint)
choose = ("E4", "E7", "E9", "F", "B", "I", "UP")

(software.ruff.format)
docstring-code-format = true
quote-style = "double"

(software.ty.surroundings)
root = ("./src")

(software.ty.guidelines)
all = "warn"

((software.ty.overrides))
embrace = ("src/**")

(software.ty.overrides.guidelines)
possibly-unresolved-reference = "error"

(software.ty.terminal)
error-on-warning = false
output-format = "full"

(software.pytest.ini_options)
testpaths = ("checks")

# Schritt 8: Code mit Polaren schreiben

Ersetzen Sie den Inhalt von src/my_project/primary.py mit Code, der die Polars-Seite des Stapels ausübt:

"""Pattern information evaluation with Polars."""

import polars as pl

def build_report(path: str) -> pl.DataFrame:
    """Construct a income abstract from uncooked information utilizing the lazy API."""
    q = (
        pl.scan_csv(path)
        .filter(pl.col("standing") == "energetic")
        .with_columns(
            revenue_per_user=(pl.col("income") / pl.col("customers")).alias("rpu")
        )
        .group_by("section")
        .agg(
            pl.len().alias("rows"),
            pl.col("income").sum().alias("income"),
            pl.col("rpu").imply().alias("avg_rpu"),
        )
        .kind("income", descending=True)
    )
    return q.accumulate()

def primary() -> None:
    """Entry level with pattern in-memory information."""
    df = pl.DataFrame(
        {
            "section": ("Enterprise", "SMB", "Enterprise", "SMB", "Enterprise"),
            "standing": ("energetic", "energetic", "churned", "energetic", "energetic"),
            "income": (12000, 3500, 8000, 4200, 15000),
            "customers": (120, 70, 80, 84, 150),
        }
    )

    abstract = (
        df.lazy()
        .filter(pl.col("standing") == "energetic")
        .with_columns(
            (pl.col("income") / pl.col("customers")).spherical(2).alias("rpu")
        )
        .group_by("section")
        .agg(
            pl.len().alias("rows"),
            pl.col("income").sum().alias("total_revenue"),
            pl.col("rpu").imply().spherical(2).alias("avg_rpu"),
        )
        .kind("total_revenue", descending=True)
        .accumulate()
    )

    print("Income Abstract:")
    print(abstract)

if __name__ == "__main__":
    primary()

Vor dem Ausführen benötigen Sie ein Construct-System pyproject.toml Daher installiert UV Ihr Projekt als Paket. Wir werden verwenden Jungtier:

cat >> pyproject.toml << 'EOF'

(build-system)
requires = ("hatchling")
build-backend = "hatchling.construct"

(software.hatch.construct.targets.wheel)
packages = ("src/my_project")
EOF

Dann synchronisieren und ausführen:

uv sync
uv run python -m my_project.primary

Sie sollten eine formatierte Polartabelle sehen:

Income Abstract:
form: (2, 4)
┌────────────┬──────┬───────────────┬─────────┐
│ section    ┆ rows ┆ total_revenue ┆ avg_rpu │
│ ---        ┆ ---  ┆ ---           ┆ ---     │
│ str        ┆ u32  ┆ i64           ┆ f64     │
╞════════════╪══════╪═══════════════╪═════════╡
│ Enterprise ┆ 2    ┆ 27000         ┆ 100.0   │
│ SMB        ┆ 2    ┆ 7700          ┆ 50.0    │
└────────────┴──────┴───────────────┴─────────┘

# Verwalten des täglichen Arbeitsablaufs

Sobald das Projekt eingerichtet ist, ist der Tagesablauf unkompliziert:

# Pull newest, sync dependencies
git pull
uv sync

# Write code...

# Earlier than committing: lint, format, type-check, check
uv run ruff test --fix .
uv run ruff format .
uv run ty test
uv run pytest

# Commit
git add .
git commit -m "feat: add income report module"

# Ändern Sie die Artwork und Weise, wie Sie Python mit Polaren schreiben

Der größte Denkwandel in diesem Stack findet auf der Datenseite statt. Bei Polars sollten Ihre Standardeinstellungen sein:

• Ausdrücke über zeilenweise Operationen. Mit Polarausdrücken kann die Engine Vorgänge vektorisieren und parallelisieren. Vermeiden Sie benutzerdefinierte Funktionen (UDFs), es sei denn, es gibt keine native Various, da UDFs deutlich langsamer sind.
• Faule Ausführung statt eifrigem Laden. Verwenden scan_csv() anstatt read_csv(). Dadurch entsteht ein LazyFrame Dadurch wird ein Abfrageplan erstellt, der es dem Optimierer ermöglicht, Filter nach unten zu verschieben und nicht verwendete Spalten zu entfernen.
• Parquet-First-Workflows über CSV-lastige Pipelines. Ein gutes Muster für die interne Datenaufbereitung sieht so aus.

# Bewerten, wann dieses Setup nicht die beste Lösung ist

Möglicherweise möchten Sie eine andere Wahl, wenn:

• Ihr Workforce verfügt über einen ausgereiften Poetry- oder Mypy-Workflow, der intestine funktioniert.
• Ihre Codebasis hängt stark von Pandas-spezifischen APIs oder Ökosystembibliotheken ab.
• Ihre Organisation ist auf Pyright standardisiert.
• Sie arbeiten in einem alten Repository, in dem ein Wechsel der Instruments eher Störungen als Nutzen mit sich bringen würde.

# Profi-Tipps umsetzen

1. Aktivieren Sie virtuelle Umgebungen niemals manuell. Verwenden uv run für alles, um sicherzustellen, dass Sie die richtige Umgebung verwenden.
2. Verpflichten Sie sich immer uv.lock zur Versionskontrolle. Dadurch wird sichergestellt, dass das Projekt auf jeder Maschine identisch läuft.
3. Verwenden --frozen im CI. Dadurch werden Abhängigkeiten von der Sperrdatei installiert, um schnellere und zuverlässigere Builds zu ermöglichen.
4. Verwenden uvx für Einzelwerkzeuge. Führen Sie Instruments aus, ohne sie in Ihrem Projekt zu installieren.
5. Benutze Ruff’s --fix großzügig markieren. Es kann nicht verwendete Importe, veraltete Syntax und mehr automatisch reparieren.
6. Bevorzugen Sie standardmäßig die Lazy-API. Verwenden scan_csv() und nur anrufen .accumulate() Am Ende.
7. Zentralisieren Sie die Konfiguration. Verwenden pyproject.toml als einzige Quelle der Wahrheit für alle Instruments.

# Abschließende Gedanken

Der Python-Standardstack 2026 reduziert den Einrichtungsaufwand und fördert bessere Vorgehensweisen: gesperrte Umgebungen, eine einzige Konfigurationsdatei, schnelles Suggestions und optimierte Datenpipelines. Probieren Sie es aus; Sobald Sie die umgebungsunabhängige Ausführung erleben, werden Sie verstehen, warum Entwickler wechseln.

Kanwal Mehreen ist ein Ingenieur für maschinelles Lernen und ein technischer Redakteur mit einer großen Leidenschaft für Datenwissenschaft und die Schnittstelle zwischen KI und Medizin. Sie ist Mitautorin des E-Books „Maximizing Productiveness with ChatGPT“. Als Google Era Scholar 2022 für APAC setzt sie sich für Vielfalt und akademische Exzellenz ein. Sie ist außerdem als Teradata Variety in Tech Scholar, Mitacs Globalink Analysis Scholar und Harvard WeCode Scholar anerkannt. Kanwal ist ein leidenschaftlicher Verfechter von Veränderungen und hat FEMCodes gegründet, um Frauen in MINT-Bereichen zu stärken.