Home

01 Moderne Entwicklungswerkzeuge: Implementierungsfähigkeiten für moderne Softwareentwicklung

October 2025 (6783 Words, 38 Minutes)

lecture python uv implementation modern-development best-practices

I Love Programming

12. Von Skripten zu professioneller Software: Die moderne Implementierungsreise

Willkommen zu Teil 2 unserer ersten Vorlesung! Nachdem Sie Ihre Entwicklungsumgebung mit Git, GitHub, VS Code und Copilot eingerichtet haben, ist es an der Zeit, in das Herzstück der Softwareentwicklung einzutauchen: die Implementierung.

Code zu schreiben ist aufregend – hier werden Ideen zur Realität. Aber es gibt einen großen Unterschied zwischen einem Skript, das auf Ihrem Laptop funktioniert, und professioneller Software, die skaliert, Qualität aufrechterhält und gut mit Teams zusammenarbeitet. Diese Vorlesung zeigt Ihnen diese Reise.

12.1 Was Sie lernen werden

In diesem Teil des Kurses werden wir Folgendes erkunden:

Dies ist ein Teaser für die bevorstehende Reise. In diesem Kurs verfolgen wir einen praxisorientierten, beispielbasierten Ansatz, beginnend mit einfachen Skripten, die wir Schritt für Schritt zu einem vollständig professionellen Python-Projekt mit den Best Practices von 2025 entwickeln.

13. Warum Python? Die unvermeidliche Wahl für moderne Entwickler

Wenn Sie 2025 eine Programmiersprache tiefgehend lernen wollen, sollte es Python sein. Das ist keine subjektive Präferenz – es wird durch überwältigende Beweise aus Industrie und Wissenschaft gestützt.

13.1 Pythons Dominanz: Die Zahlen lügen nicht

Schauen wir uns die quantitativen Beweise an:

13.1.1 Verbreitung in der Industrie

GitHub Statistiken (2024-2025):

Stack Overflow Developer Survey 2024:

TIOBE Index (Oktober 2025):

13.1.2 Akademische Dominanz

Forschung und Bildung:

Scientific Computing:

13.2 Warum Python gewinnt: Technische und praktische Gründe

Die Zahlen zeigen uns dass Python dominiert, aber warum dominiert es?

13.2.1 Lesbarkeit und Produktivität

Pythons Syntax ist so nah an Pseudocode, wie es nur geht:

# Python - liest sich wie Englisch
def calculate_average(numbers):
    """Berechne den Durchschnitt einer Liste von Zahlen."""
    return sum(numbers) / len(numbers)

students = [85, 92, 78, 90, 88]
average = calculate_average(students)
print(f"Durchschnittsnote: {average}")

Vergleichen Sie dies mit äquivalentem Code in anderen Sprachen – Python gewinnt in Klarheit und Entwicklungsgeschwindigkeit.

13.2.2 Vielseitigkeit: Eine Sprache, jede Domäne

Python ist nicht nur für eine Sache – es ist für alles:

Karriere-Auswirkung: Python einmal lernen, in jeder Domäne arbeiten.

13.2.3 Ökosystem: Batterien enthalten und darüber hinaus

Standard-Bibliothek: Python kommt mit 200+ eingebauten Modulen für gängige Aufgaben – Datei-I/O, Netzwerk, Datenstrukturen, Nebenläufigkeit und mehr.

PyPI (Python Package Index):

Beispiel: Müssen Sie mit Daten arbeiten, HTTP-Requests senden, JSON verarbeiten und ein GUI erstellen?

# Alles eingebaut oder einen Befehl entfernt
pip install requests  # Das war's für HTTP
# datetime, json, tkinter - bereits enthalten

13.2.4 Community und Unterstützung

Wenn Sie nicht weiterkommen, gibt es immer Hilfe.

13.2.5 Nachfrage in der Industrie und Karrierewachstum

Arbeitsmarkt (2025):

Unternehmen, die Python nutzen:

13.3 Die KI- und Machine-Learning-Revolution

Wir erleben eine KI-Revolution, und Python ist die Sprache der KI:

Wenn Sie mit hochmoderner KI arbeiten möchten (und Sie sollten – sie transformiert jede Branche), ist Python nicht optional.

13.4 Python für akademischen Erfolg

Im akademischen Kontext bietet Python einzigartige Vorteile:

Forschungsreproduzierbarkeit:

Rapid Prototyping:

Zusammenarbeit:

13.5 Das Fazit

Python ist unvermeidlich für moderne Entwickler, weil:

  1. ✅ Allgegenwärtig: Überall verwendet, von Startups bis zur NASA
  2. ✅ Produktiv: Weniger Code schreiben, mehr erreichen
  3. ✅ Vielseitig: Eine Sprache für Web, Daten, KI, Automatisierung
  4. ✅ Gefragt: Top-Gehalt, die meisten Stellenangebote
  5. ✅ Zukunftssicher: Führende KI/ML-Sprache, ständig weiterentwickelt
  6. ✅ Einsteigerfreundlich: Programmierkonzepte lernen, nicht Syntax-Eigenheiten
  7. ✅ Professional-Grade: Skaliert von Skripten zu Unternehmenssystemen

Ob Sie einen Forschungsprototyp, ein Startup-MVP oder Unternehmenssoftware bauen – Python ist die richtige Wahl.

14. Die bevorstehende Reise: Von Skripten zu professionellen Projekten

In diesem Kurs nehmen wir Sie mit auf eine praktische, hands-on Reise. Wir beginnen mit etwas, das Ihnen vielleicht bereits vertraut ist – einfache Python-Skripte – und entwickeln es Schritt für Schritt zu einem vollständig professionellen Projekt mit den Best Practices von 2025.

15. Von Skript zu Produktion – Die professionelle Lücke

15.1 Die zwei Pythons

Skript-Python (Was Tutorials lehren):

# analysis.py
import pandas as pd

data = pd.read_csv("data.csv")
result = data.describe()
print(result)

python analysis.py  # Funktioniert... vorerst

Produktions-Python (Was Unternehmen brauchen):

Gleiche Funktionalität, professionelle Struktur:

# src/analytics/__init__.py
"""Analytics-Paket für Datenverarbeitung."""
__version__ = "1.2.3"

# src/analytics/pipeline.py
import pandas as pd
from pathlib import Path

def analyze_data(file_path: Path) -> pd.DataFrame:
    """Analysiere Daten aus CSV-Datei und gib Statistiken zurück.
    
    Args:
        file_path: Pfad zur CSV-Datei
        
    Returns:
        DataFrame mit statistischer Zusammenfassung
    """
    data = pd.read_csv(file_path)
    return data.describe()

# src/analytics/cli.py
import typer
from pathlib import Path
from analytics.pipeline import analyze_data

app = typer.Typer()

@app.command()
def analyze(file: Path) -> None:
    """Analysiere Daten aus CSV-Datei."""
    result = analyze_data(file)
    print(result)

if __name__ == "__main__":
    app()

# Moderner uv-Workflow - ordentliches Packaging
uv tool install analytics-platform
analytics-cli analyze data.csv

# Oder direkt ohne Installation ausführen
uv run analytics-cli analyze data.csv

15.2 Was ändert sich im großen Maßstab?

15.2.1 Mehrere Personen, mehrere Monate

15.2.2 Code lebt über Ihren Laptop hinaus

15.2.3 Qualität zählt

15.2.4 Zusammenarbeit im großen Maßstab

15.3 Ihr erstes professionelles Python-Projekt: Road Profile Viewer

Zeit für praktisches Arbeiten! Statt von Grund auf neu zu bauen, beginnen wir mit echtem, funktionierendem Code und transformieren ihn Schritt für Schritt in ein professionelles Python-Projekt.

15.3.1 Schritt 1: Startcode herunterladen

Für Kursteilnehmer:

  1. Gehen Sie zu Canvas: Besuchen Sie die Kursseite
  2. Download: Holen Sie sich die Datei road-profile-viewer.7z
  3. Entpacken: Entpacken Sie das Archiv, um die Code-Struktur zu sehen

Für externe Nutzer ohne Canvas-Zugang:

  1. Gehen Sie zu GitHub: Besuchen Sie das Road Profile Viewer v1.0.0 Release
  2. Download: Holen Sie sich das Quellcode-Archiv (zip oder tar.gz)
  3. Entpacken: Entpacken Sie das Archiv, um die Code-Struktur zu sehen

Was Sie finden werden:

Das ist Skript-Python – die Art von Code, die Tutorials lehren. Unsere Mission: Es in Produktions-Python transformieren.

📦 “Moment, haben wir nicht gerade gesagt, dass Git besser ist als gezippte Dateien?”

Ja! Und Sie haben recht, das zu bemerken. Normalerweise würden Sie ein Repository direkt von GitHub klonen. Aber für diese erste Übung lassen wir Sie bewusst:

  1. Mit einer Zip-Datei starten (der “alte Weg”)
  2. Git selbst initialisieren
  3. Ihr eigenes GitHub-Repository erstellen
  4. Verbinden und pushen

Warum? Weil es einmal selbst zu tun Ihnen beibringt, wie Repositories entstehen. Danach werden Sie immer bestehende Repos klonen—aber Sie werden verstehen, was unter der Haube passiert. Denken Sie daran wie Fahrradfahren lernen mit Stützrädern, bevor Sie bei der Tour de France mitmachen! 🚴

15.3.2 Schritt 2: Ihre lokale Umgebung einrichten

Öffnen Sie Ihr Terminal und erstellen Sie Ihren Projekt-Workspace:

# Erstellen Sie einen dedizierten Ordner für Ihr Projekt
mkdir road-profile-viewer
cd road-profile-viewer

# Kopieren Sie die entpackten Dateien hierher
# (Verwenden Sie Ihren Dateimanager oder Kopierbefehle)

15.3.3 Schritt 3: Projektkonfiguration anpassen

Bevor wir den Code committen, machen wir ihn zu Ihrem! Öffnen Sie die pyproject.toml-Datei in VS Code:

# Öffnen Sie das Projekt in VS Code
code .

Bearbeiten Sie pyproject.toml:

  1. Finden Sie den authors-Abschnitt (um Zeile 6)
  2. Ersetzen Sie L3GJ0N mit Ihrem GitHub-Benutzernamen
  3. Ersetzen Sie die E-Mail mit Ihrer eigenen E-Mail-Adresse

Beispiel-Änderung:

# Vorher (was Sie heruntergeladen haben):
authors = [{name = "L3GJ0N", email = "dominik.rother@hs-aalen.de"}]

# Nachher (Ihre Version):
authors = [{name = "IHR_GITHUB_BENUTZERNAME", email = "ihre.email@beispiel.com"}]

💾 Datei speichern (Strg+S oder Cmd+S)

Warum das wichtig ist: Das macht Sie zum offiziellen Autor Ihrer Version des Projekts. Wenn Sie Pakete veröffentlichen oder zu Open Source beitragen, ist ordentliche Zuschreibung entscheidend!

15.3.4 Schritt 4: Git-Repository initialisieren

Lassen Sie uns diesen Code nun in ein ordentliches Git-Repository verwandeln:

# Git in Ihrem Projektordner initialisieren
git init

# Alle Dateien zum Staging hinzufügen
git add .

# Ihren ersten Commit erstellen
# WICHTIG: Verwenden Sie diese exakte Nachricht, damit alle gleich starten
git commit -m "Initial commit: Road profile viewer scripts"

# Ihren Status überprüfen
git status

🎯 Checkpoint: Sie haben jetzt ein lokales Git-Repository mit Ihrem ersten Commit!

15.3.5 Schritt 5: GitHub-Repository erstellen

  1. Gehen Sie zu GitHub: Besuchen Sie github.com und melden Sie sich an
  2. Neues Repository erstellen:
    • Klicken Sie auf den ”+”-Button → “New repository”
    • Repository-Name: road-profile-viewer
    • Beschreibung: Python-Tool zur Visualisierung von Straßenhöhenprofilen
    • Sichtbarkeit: Public (damit Sie Ihre Arbeit präsentieren können!)
    • ⚠️ Wichtig: Initialisieren Sie NICHT mit README, .gitignore oder Lizenz
  3. Klicken Sie auf “Create repository”

15.3.6 Schritt 6: Lokal mit GitHub verbinden

GitHub zeigt Ihnen Anweisungen, aber hier ist genau, was zu tun ist:

# Ihr GitHub-Repository als Remote-Origin hinzufügen
git remote add origin https://github.com/IHR_BENUTZERNAME/road-profile-viewer.git

# Ihren Code zu GitHub pushen
git branch -M main
git push -u origin main

Ersetzen Sie IHR_BENUTZERNAME mit Ihrem tatsächlichen GitHub-Benutzernamen!

15.3.7 Schritt 7: Überprüfen, dass alles funktioniert

  1. Aktualisieren Sie Ihre GitHub-Repository-Seite - Sie sollten Ihren Code sehen!
  2. Überprüfen Sie die Commit-Nachricht - sie sollte “Initial commit: Road profile viewer scripts” sagen
  3. Erkunden Sie die Dateien - klicken Sie herum, um Ihren Code auf GitHub zu sehen

🎉 Erfolg! Sie haben jetzt:

16. Ihre erste moderne Python-Anwendung ausführen

Jetzt lassen Sie uns Ihren Code in Aktion sehen! Wir verwenden uv – das moderne Python-Tooling, das das Ausführen von Projekten mühelos macht.

16.1 Schritt 1: uv installieren

Wählen Sie Ihr Betriebssystem:

Windows (PowerShell):

Öffnen Sie PowerShell und führen Sie aus:

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

⚠️ Wichtig für Windows: Nach der Installation schließen und öffnen Sie Ihr PowerShell/Terminal-Fenster neu, damit die PATH-Änderungen wirksam werden.

Ubuntu/Linux:

Öffnen Sie Ihr Terminal und führen Sie aus:

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

⚠️ Wichtig für Linux: Nach der Installation entweder Terminal neu starten oder ausführen:

source $HOME/.cargo/env

Installation überprüfen:

uv --version

Sie sollten etwas wie uv 0.5.x oder höher sehen.

16.2 Schritt 2: Den Road Profile Viewer ausführen

Navigieren Sie zu Ihrem Projektordner und starten Sie die Anwendung:

# Stellen Sie sicher, dass Sie im Projektverzeichnis sind
cd src/road-profile-viewer

# Die Hauptanwendung ausführen
uv run main.py

Hinweis: Der Befehl run benötigt als Eingabe den Pfad zum entsprechenden Python File. D. h. main.py wird hier automatisch interpretiert als ./main.py.

Das war’s! uv wird automatisch:

16.3 Schritt 3: Ihre Anwendung ansehen

Nach ein paar Sekunden sehen Sie Ausgabe in Ihrem Terminal. Die Anwendung startet einen Webserver.

Öffnen Sie Ihren Browser und navigieren Sie zu:

http://127.0.0.1:8050

🎊 Sie sollten das Road Profile Viewer Dashboard sehen!

Wenn alles korrekt funktioniert hat, sollten Sie das interaktive Road Profile Viewer Dashboard in Ihrem Browser sehen:

Road Profile Viewer Dashboard Abbildung 1: Der Road Profile Viewer - Unsere erste Python-Anwendung läuft lokal

Probieren Sie die Visualisierung aus – Sie führen jetzt eine echte Python-Webanwendung aus!

16.4 Was ist gerade passiert?

Mit einem einzigen Befehl (uv run main.py) haben Sie:

Das ist der moderne Python-Workflow – keine manuelle virtuelle Umgebungserstellung, keine Dependency-Installationsprobleme, keine “es funktioniert auf meiner Maschine”-Probleme.

16.5 Die Anwendung stoppen

Um den Server zu stoppen:

17. Was gerade passiert ist verstehen: Python-Umgebungen entmystifiziert

Sie haben gerade uv run main.py ausgeführt und magischerweise hat alles funktioniert. Aber was ist tatsächlich hinter den Kulissen passiert? Das zu verstehen ist entscheidend für professionelle Python-Entwicklung.

17.1 Der magische Befehl: uv run main.py

Als Sie uv run main.py ausgeführt haben, hat uv automatisch mehrere ausgeklügelte Operationen durchgeführt:

  1. ✅ Gelesen pyproject.toml, um Projektanforderungen zu verstehen
  2. ✅ Erstellt eine isolierte virtuelle Umgebung
  3. ✅ Installiert alle Abhängigkeiten (Dash, Plotly, Pandas, etc.)
  4. ✅ Ausgeführt Ihr Python-Skript in dieser isolierten Umgebung

Lassen Sie uns jeden dieser Schritte auspacken, um zu verstehen, was wirklich passiert.

17.2 Was ist eine Python Virtual Environment?

17.2.1 Das Problem: Abhängigkeitschaos

Stellen Sie sich vor, Sie arbeiten an drei verschiedenen Python-Projekten:

Ohne virtuelle Umgebungen geraten Sie in die “Dependency Hell”:

# Pandas für Projekt A installieren
pip install pandas==1.5.0

# Jetzt zu Projekt B wechseln
pip install pandas==2.1.0  # ⚠️ Überschreibt 1.5.0!

# Zurück zu Projekt A
python projectA.py  # ❌ ABSTURZ! Falsche pandas-Version

17.2.2 Die Lösung: Isolierte Umgebungen

Eine virtuelle Umgebung ist wie eine separate Python-Installation für jedes Projekt. Sie erstellt einen isolierten Raum, in dem die Abhängigkeiten Ihres Projekts unabhängig leben von:

Denken Sie daran wie Wohnungen in einem Gebäude:

17.2.3 Was ist tatsächlich in einer virtuellen Umgebung?

Eine virtuelle Umgebung ist nur eine Verzeichnisstruktur, die Folgendes enthält:

.venv/                          # Virtual-Environment-Ordner
├── bin/ (oder Scripts/ unter Windows)
│   ├── python                  # Python-Executable (Kopie oder Symlink)
│   ├── pip                     # Paket-Installer für diese Umgebung
│   └── activate                # Skript zum "Betreten" dieser Umgebung
├── lib/
│   └── python3.12/
│       └── site-packages/      # HIER LEBEN IHRE PAKETE
│           ├── pandas/         # Hier installiert, nicht global!
│           ├── dash/
│           ├── plotly/
│           └── ...
└── pyvenv.cfg                  # Konfigurationsdatei

Wichtige Erkenntnis: Wenn Sie Pakete in einer virtuellen Umgebung installieren, gehen sie in den site-packages/-Ordner dieser Umgebung, nicht in das globale Python Ihres Systems.

17.2.4 Wie Python Pakete findet

Wenn Sie Python ausführen, sucht es in dieser Reihenfolge nach Paketen:

  1. Aktuelles Verzeichnis (wo Sie das Skript ausführen)
  2. site-packages/ der virtuellen Umgebung (wenn aktiv)
  3. site-packages/ des System-Python (globale Installation)
  4. Standard-Bibliothek (eingebaute Module)

Virtuelle Umgebungen funktionieren, indem sie ihre site-packages/ zuerst in den Suchpfad setzen, sodass ihre Pakete vor globalen gefunden werden.

17.3 Der alte Weg: Manuelle virtuelle Umgebungen

Vor uv mussten Sie jedes einzelne Mal dies tun:

# Schritt 1: Virtuelle Umgebung erstellen (langsam!)
python -m venv .venv            # Erstellt .venv/-Ordner

# Schritt 2: Aktivieren (OS-spezifische Befehle!)
# Windows:
.venv\Scripts\activate
# Mac/Linux:
source .venv/bin/activate

# Schritt 3: pip upgraden (weil es immer veraltet ist)
pip install --upgrade pip

# Schritt 4: Abhängigkeiten installieren (einzeln oder aus requirements.txt)
pip install dash plotly pandas numpy

# Schritt 5: Endlich Ihren Code ausführen
python main.py

# Schritt 6: Sich daran erinnern, zu deaktivieren, wenn fertig
deactivate

Probleme mit diesem Workflow:

17.4 Der neue Weg: uv macht alles

Mit uv kollabieren all diese Schritte zu einem Befehl:

uv run main.py  # Das war's. Ernsthaft.

Was uv automatisch macht:

# Hinter den Kulissen (Sie sehen dies nicht):
[1] pyproject.toml lesen
    ↓
[2] .venv/ überprüfen
    ├─ Nein? Erstellen (in Millisekunden!)
    └─ Ja? Überprüfen, ob korrekt
    ↓
[3] Abhängigkeiten sperren (Versionen auflösen)
    ↓
[4] Nur Fehlendes installieren (gecacht!)
    ↓
[5] Ihr Skript in der virtuellen Umgebung ausführen

Warum das revolutionär ist:

✅ Schnell: Virtual-Environment-Erstellung in <100ms (nicht 5-30 Sekunden)
✅ Automatisch: Keine Aktivierung, keine manuellen Schritte
✅ Reproduzierbar: Exakt gleiche Versionen für alle
✅ Smart: Installiert nur, was fehlt
✅ Gecacht: Verwendet Pakete projektübergreifend wieder
✅ Sicher: Prüft Abhängigkeitskompatibilität vor Installation

17.5 pyproject.toml verstehen: Der Blueprint Ihres Projekts

Die pyproject.toml-Datei ist die einzige Quelle der Wahrheit für Ihr Python-Projekt. Öffnen wir sie und sehen, was sie enthält:

# Öffnen Sie pyproject.toml Ihres Projekts
code pyproject.toml

17.5.1 Anatomie von pyproject.toml

Das werden Sie sehen (mit Erklärungen):

[build-system]
# Wie Ihr Projekt gebaut/verpackt wird
requires = ["hatchling"]
build-backend = "hatchling.build"

[project]
# Projekt-Metadaten
name = "road-profile-viewer"
version = "0.1.0"
description = "Python-Tool zur Visualisierung von Straßenhöhenprofilen"
authors = [{name = "IHR_BENUTZERNAME", email = "ihre.email@beispiel.com"}]
readme = "README.md"
requires-python = ">=3.10"  # Minimale Python-Version

# Abhängigkeiten: Welche Pakete dieses Projekt braucht
dependencies = [
    "dash>=2.14.0",          # Web-Framework
    "plotly>=5.18.0",        # Interaktive Visualisierungen
    "pandas>=2.1.0",         # Datenmanipulation
    "numpy>=1.24.0",         # Numerische Operationen
]

[project.optional-dependencies]
# Optionale Abhängigkeiten (z.B. für Entwicklung)
dev = [
    "pytest>=7.4.0",         # Test-Framework
    "ruff>=0.1.0",           # Linter
]

[tool.uv]
# uv-spezifische Einstellungen
dev-dependencies = [
    "pytest>=7.4.0",
]

17.5.2 Warum pyproject.toml besser ist als alte Ansätze

Alter Ansatz: requirements.txt

# requirements.txt - nur eine Liste
dash==2.14.0
plotly==5.18.0
pandas==2.1.0
numpy==1.24.0

Probleme:

Moderner Ansatz: pyproject.toml

17.5.3 Versionsbezeichner erklärt

dependencies = [
    "dash>=2.14.0",      # Jede Version 2.14.0 oder höher
    "plotly~=5.18.0",    # Nur 5.18.x (Patch-Updates OK)
    "pandas>=2.1,<3.0",  # 2.1+ aber nicht 3.x (Major-Version gesperrt)
    "numpy==1.24.0",     # Exakte Version (meist zu streng!)
]

Best Practice: Verwenden Sie >= für die meisten Abhängigkeiten, lassen Sie uv kompatible Versionen auflösen.

17.6 Warum uv ein Game-Changer ist: Die technische Evolution

Vergleichen wir die Tools, um zu verstehen, warum uv einen großen Sprung nach vorn darstellt:

17.6.1 Die Evolution des Python-Paketmanagements

1️⃣ Antike Zeiten: pip + venv (2013-2023)

python -m venv .venv         # Umgebung erstellen (langsam)
source .venv/bin/activate    # Aktivieren (manuell)
pip install -r requirements.txt  # Installieren (langsam, keine Konfliktprüfung)

Probleme:

2️⃣ Mittelalter: Poetry / Pipenv (2018-2024)

poetry install               # Besser, aber immer noch langsam

Verbesserungen:

Verbleibende Probleme:

3️⃣ Moderne Ära: uv (2024-2025)

uv run main.py              # Alles, sofort

Revolutionäre Verbesserungen:

🚀 Geschwindigkeit: In Rust geschrieben

Benchmarks (venv erstellen + 10 Pakete installieren):

🎯 Einheitliches Tool

🔒 Reproduzierbarkeit

🧠 Smartes Caching

✅ Sicherheit

17.6.2 Was macht uv so schnell?

Traditionelle Python-Tools (pip, poetry):

uv (in Rust geschrieben):

Real-World-Auswirkung:

# Traditioneller Workflow: Django + deps installieren
time pip install django
# ⏱️ ~15 Sekunden

# Moderner Workflow mit uv
time uv pip install django
# ⏱️ ~1 Sekunde ⚡

17.7 Alles zusammenfügen: Ihr Entwicklungs-Workflow

Jetzt verstehen Sie das vollständige Bild:

Sie tippen: uv run main.py
         ↓
    [uv liest pyproject.toml]
         ↓
    "Dieses Projekt braucht:
     - Python 3.10+
     - dash>=2.14.0
     - plotly>=5.18.0
     - pandas>=2.1.0
     - numpy>=1.24.0"
         ↓
    [uv prüft .venv/]
         ↓
    Kein .venv? → Erstellen (100ms)
    .venv existiert? → Überprüfen, ob korrekt
         ↓
    [uv löst Abhängigkeiten auf]
         ↓
    "Kompatibilität prüfen...
     dash 2.14.0 braucht plotly 5.x ✓
     pandas 2.1.0 braucht numpy 1.24+ ✓
     Alle kompatibel!"
         ↓
    [uv installiert Pakete]
         ↓
    Cache prüfen → Haben wir plotly 5.18.0 schon? Wiederverwenden!
    pandas fehlt? → Herunterladen + installieren (schnell!)
         ↓
    [uv führt Ihr Skript aus]
         ↓
    python .venv/bin/python main.py
         ↓
    🎉 Ihre App läuft!

Die Schönheit: All diese Komplexität ist verborgen. Sie tippen einfach uv run main.py und es funktioniert.

17.8 Wichtigste Erkenntnisse

1. Virtuelle Umgebungen:

2. pyproject.toml:

3. Warum uv wichtig ist:

4. Professioneller Workflow:

# Das war's. Ein Befehl.
uv run main.py

# Vergleichen Sie mit dem alten Weg:
python -m venv .venv
source .venv/bin/activate  # oder .\venv\Scripts\activate unter Windows
pip install --upgrade pip
pip install -r requirements.txt
python main.py
deactivate

Die Zukunft der Python-Entwicklung ist hier, und sie ist schnell.

18. Über die Grundlagen hinaus: Weitere uv-Workflows

Jetzt, da Sie verstehen, was hinter den Kulissen passiert, lassen Sie uns zusätzliche Wege erkunden, mit uv zu arbeiten. Es gibt mehr als eine Möglichkeit, Ihre Python-Anwendungen auszuführen!

18.1 Drei Wege, Ihre Anwendung auszuführen

18.1.1 Methode 1: uv run (Was Sie gerade gelernt haben) ⚡ Am schnellsten für Entwicklung

uv run main.py

Vorteile:

Wann zu verwenden: Tägliche Entwicklung, Testen, schnelle Ausführungen

18.1.2 Methode 2: Manuelle virtuelle Umgebung 🔧 Mehr Kontrolle

Manchmal möchten Sie mehr Kontrolle über die Umgebung. So erstellen und verwalten Sie sie manuell mit uv:

Schritt 1: Die virtuelle Umgebung erstellen

# uv erstellt venvs VIEL schneller als python -m venv
uv venv

Dies erstellt den .venv/-Ordner in Ihrem Projekt (genau wie python -m venv .venv, aber 10-100x schneller!)

Schritt 2: Die Umgebung aktivieren

Windows (PowerShell):

.venv\Scripts\Activate.ps1

Ubuntu/Linux/Mac:

source .venv/bin/activate

Sie werden (.venv) in Ihrem Terminal-Prompt sehen, was anzeigt, dass die Umgebung aktiv ist.

Schritt 3: Ihre Projektabhängigkeiten synchronisieren

# Moderner uv-Weg: Umgebung mit pyproject.toml synchronisieren
uv sync

Dies installiert alle in Ihrer pyproject.toml aufgelisteten Abhängigkeiten in die aktive virtuelle Umgebung.

Schritt 4: Ihre Anwendung ausführen

# Jetzt können Sie einfach python direkt ausführen
python main.py

Schritt 5: Deaktivieren, wenn fertig

deactivate

Vorteile:

Nachteile:

Wann zu verwenden:

18.1.3 Methode 3: Benannte Skripte 🎯 Am professionellsten

Hier glänzen Python-Projekte wirklich! Sie können benannte Befehle in pyproject.toml definieren, die Ihre Anwendung ausführen. Richten wir das ein!

18.2 Hands-On-Aufgabe: Ein benanntes Skript hinzufügen

Schritt 1: pyproject.toml öffnen

code pyproject.toml

Schritt 2: Einen Scripts-Abschnitt hinzufügen

Finden Sie den [project]-Abschnitt und fügen Sie dies am Ende hinzu (vor [tool.uv], falls vorhanden):

[project.scripts]
# Befehlsname = "modul:funktion"
road-viewer = "main:main"

Was das bedeutet:

Schritt 3: Ihre main.py aktualisieren, um eine main()-Funktion zu haben

Öffnen Sie main.py und umschließen Sie den Hauptcode in einer Funktion:

# main.py
import dash
from dash import dcc, html
import plotly.graph_objects as go
# ... andere Imports ...

def main():
    """Haupt-Einstiegspunkt für die Road Profile Viewer-Anwendung."""
    # Ihr bestehender Code, der die App erstellt und ausführt
    app = dash.Dash(__name__)
    
    # ... Rest Ihres App-Codes ...
    
    app.run_server(debug=True, host='127.0.0.1', port=8050)

# Dies erlaubt das Ausführen als Skript ODER als installierter Befehl
if __name__ == "__main__":
    main()

Schritt 4: Ihr Projekt synchronisieren, um das Skript zu registrieren

# Sync installiert Abhängigkeiten und registriert Skripte aus pyproject.toml
uv sync

Dies wird:

Schritt 5: Mit dem benannten Befehl ausführen!

# Jetzt können Sie Ihre App mit einem sauberen, professionellen Befehl ausführen
road-viewer

Oder noch besser, verwenden Sie uv run mit dem Skriptnamen:

uv run road-viewer

🎉 Sie haben gerade einen professionellen CLI-Befehl erstellt!

18.3 Warum benannte Skripte professionell sind

Statt:

python main.py                    # ❌ Nicht sehr professionell
python src/road_profile/main.py   # ❌ Schwer zu merkende Pfade
cd /pfad/zum/projekt && python main.py  # ❌ Erfordert Navigation

Bekommen Sie:

road-viewer                       # ✅ Sauberer, einprägsamer Befehl

Real-World-Beispiele:

Diese sind alle Python-Pakete mit benannten Skripten in pyproject.toml!

18.4 Die drei Methoden vergleichen

Methode Befehl Setup erforderlich Geschwindigkeit Anwendungsfall
uv run uv run main.py Keines ⚡ Sofort Schnelle Entwicklung
Manuelle venv python main.py Erstellen + aktivieren 🔧 Kontrolliert Debugging, IDE-Setup
Benanntes Skript road-viewer Zur toml hinzufügen + installieren 🎯 Professionell Produktion, Verteilung

18.5 Erweitert: Mehrere Skripte

Sie können mehrere Befehle in einem Projekt definieren:

[project.scripts]
# Hauptanwendung
road-viewer = "main:main"

# Datenverarbeitungs-Utilities
process-data = "scripts.process:main"
export-report = "scripts.export:generate_report"

# Entwicklungs-Tools
dev-server = "main:run_dev_mode"

Dann verwenden Sie sie wie:

uv run road-viewer          # Viewer starten
uv run process-data input.csv    # Daten verarbeiten
uv run export-report --format pdf  # Bericht exportieren

18.6 Was Sie als Nächstes tun sollten

Für diesen Kurs empfehlen wir:

  1. Während der Entwicklung: Verwenden Sie uv run main.py - es ist am schnellsten und einfachsten
  2. Für diese Aufgabe: Fügen Sie das benannte Skript road-viewer zu Ihrer pyproject.toml hinzu
  3. Committen Sie Ihre Änderungen: 
    git add pyproject.toml main.py
git commit -m "Add professional CLI command for road viewer"
git push

Vorteile, das Skript jetzt hinzuzufügen:

18.7 Schnellreferenz: uv-Befehle, die Sie kennen sollten

# Umgebungs-Management
uv venv                    # Virtuelle Umgebung erstellen (schnell!)
uv venv --python 3.12      # Mit spezifischer Python-Version erstellen

# Paket-Management (moderner uv-Weg)
uv add package             # Paket zu pyproject.toml hinzufügen und installieren
uv add package --dev       # Als Entwicklungsabhängigkeit hinzufügen
uv remove package          # Paket aus Projekt entfernen
uv sync                    # Umgebung mit pyproject.toml synchronisieren
uv lock                    # uv.lock-Datei erstellen/aktualisieren

# Tools global installieren (wie pytest, black, ruff)
uv tool install ruff       # Ein Tool global installieren
uv tool install pytest     # Überall verfügbar, nicht nur in diesem Projekt
uv tool list               # Global installierte Tools auflisten
uv tool uninstall ruff     # Ein globales Tool entfernen

# Code ausführen
uv run script.py           # Ein Python-Skript ausführen
uv run command             # Ein benanntes Skript aus pyproject.toml ausführen
uv run --with package script.py  # Mit temporärer Abhängigkeit ausführen
uv run python              # Python-REPL mit Projektabhängigkeiten starten

# Projekt-Initialisierung
uv init                    # Neues Python-Projekt mit pyproject.toml erstellen
uv init --app              # Anwendungsprojekt erstellen
uv init --lib              # Bibliotheksprojekt erstellen

# Python-Versions-Management
uv python install 3.12     # Python 3.12 installieren
uv python list             # Verfügbare Python-Versionen auflisten
uv python pin 3.12         # Projekt auf Python 3.12 festlegen

💡 Wichtiger Unterschied:

Warum uv add besser ist:

19. Quiz zur Vorlesung: Testen Sie Ihr Verständnis

Nachdem Sie nun Kapitel 01 (Moderne Python-Entwicklung) abgeschlossen haben, ist es an der Zeit, Ihr Verständnis moderner Python-Entwicklungspraktiken zu überprüfen. Dieses Quiz erfüllt mehrere wichtige Zwecke:

19.1 Warum sollten Sie dieses Quiz machen?

Für Ihr Lernen:

Für die Kursverbesserung:

19.2 Quiz-Details

19.3 Wie Sie dieses Quiz effektiv nutzen

  1. Schließen Sie zuerst die Vorlesung ab: Stellen Sie sicher, dass Sie alle Abschnitte gelesen haben, besonders die technischen Tiefenanalysen
  2. Nehmen Sie es ernst: Behandeln Sie es wie eine Übungsprüfung
  3. Beeilen Sie sich nicht: Denken Sie sorgfältig über jede Frage nach - sie testen konzeptionelles Verständnis, nicht Auswendiglernen
  4. Überprüfen Sie falsche Antworten: Achten Sie besonders auf die Erklärungen für Fragen, die Sie verfehlt haben
  5. Wiederholen Sie bei Bedarf: Wenn Sie unter 16/20 (80%) punkten, überprüfen Sie das Material und versuchen Sie es erneut

19.4 Wichtige Hinweise

📋 Bereit, Ihr Wissen über moderne Python-Entwicklung zu testen?

Nehmen Sie am Quiz zu Kapitel 01 (Moderne Python-Entwicklung) teil

Nach Abschluss des Quiz haben Sie ein klares Bild von Ihrer Beherrschung des Inhalts dieser Vorlesung. Denken Sie daran: Das Ziel ist nicht, Zahlen oder bestimmte Befehle auswendig zu lernen, sondern das Warum hinter modernen Python-Entwicklungspraktiken zu verstehen. Mit einigen Fragen zu kämpfen ist normal und zu erwarten - so lernt man!

20. Referenzen

[1] GitHub Search - Python Repositories. https://github.com/search?q=language%3Apython&type=repositories

[2] GitHub Octoverse 2024 - The State of Open Source. https://octoverse.github.com/

[3] RedMonk Programming Language Rankings (2024). https://redmonk.com/sogrady/category/programming-languages/

[4] Stack Overflow Developer Survey 2024. https://survey.stackoverflow.co/2024/

[5] TIOBE Index (Oktober 2025). https://www.tiobe.com/tiobe-index/

[6] IEEE Spectrum Top Programming Languages 2024. https://spectrum.ieee.org/top-programming-languages-2024

[7] Papers With Code - Python Usage in ML Research. https://paperswithcode.com/

[8] arXiv.org - AI/ML Code Repository Analysis. https://arxiv.org/

[9] Google Scholar - Programming Language Citations (2020-2025). https://scholar.google.com/

[10] NumPy, SciPy, Pandas Official Documentation and Usage Statistics. https://numpy.org/, https://scipy.org/, https://pandas.pydata.org/

[11] Jupyter Project - Notebook Statistics. https://jupyter.org/, GitHub Search: https://github.com/search?q=extension%3Aipynb

[12] Nature and Science Journal Computational Methods Surveys (2024). Analysis of programming language mentions in computational biology and scientific computing papers.

[13] PyPI Statistics - Python Package Index. https://pypi.org/, https://pypistats.org/

[14] Stack Overflow Python Tag Statistics. https://stackoverflow.com/questions/tagged/python

[15] Stack Overflow Developer Survey 2024 - Salary Insights & Indeed Salary Survey 2025. https://survey.stackoverflow.co/2024/#salary, https://www.indeed.com/career/python-developer/salaries

[16] LinkedIn Jobs - Python Skills Demand (Oktober 2025). https://www.linkedin.com/jobs/search/?keywords=python

[17] Public company engineering blogs and official technology stack announcements:

[18] PyTorch and TensorFlow Official Documentation and GitHub Statistics:

[19] Hugging Face Model Hub Statistics. https://huggingface.co/

[20] LangChain and LlamaIndex Documentation:

[21] OpenAI Platform and Anthropic API Documentation:

Hinweis: Statistiken und Marktdaten spiegeln Informationen wider, die bis Oktober 2025 verfügbar sind. Arbeitsmarkt-Zahlen und Gehaltsdaten variieren nach Region, Erfahrungslevel und spezifischen Rollenanforderungen. Links zu Umfragen und Indizes werden jährlich oder vierteljährlich aktualisiert.

© 2026 Dominik Mueller   •  Powered by Soopr   •  Theme  Moonwalk