Tag 5 Abhängigkeiten, venv, Clean Code, Jupyter Notebooks

Tag 5 Abhängigkeiten, `venv`, Clean Code, Jupyter Notebooks#

Gestern wurde der Debugger gezähmt, Klassen eingeführt, Fehlerquellen und deren Behandlungen diskutiert sowie Ein- und Ausgaben behandelt. Welche Fragen sind aufgekommen und noch offen? –> Fragen stellen

Heute ist nach ein klein wenig Input noch viel Zeit, mit den Aufgaben weiter zu machen, Fragen zu stellen und Lösungswege zu diskutieren. Auch die Abschlussaufgabe wird heute noch vorgestellt und die Bewertungskriterien erläutert.

Abhängigkeiten und Pakete#

Wie schon bei der Einführung der Standardbibliothek Python-Standardbibliothek kurz erläutert, gibt es weit mehr Funktionalität in Python, die nicht standardmäßig abrufbar ist. Diese Funktionalität steht in importierbaren Paketen (zusammengefasste Pythondateien) und ihren Modulen (eine datei.py) bereit. Um auf diese Funktionen und Klassen in Ihrem Code zu greifen zu können, muss das entsprechende Paket (oder auch nur Modul) mit dem import-Statement importiert werden. Beispiele wären import math, import random oder import os. Dies sollte immer gebündelt in den ersten Zeilen des Programmes passieren.

Die Standardbibliothek ist hier einfach zu nutzen, da sie mit der Installation von Python schon mit dabei ist, und also nur noch importiert werden muss. Andere Pakete, die beispielsweise geographische Verarbeitungen erlauben und vereinfachen, müssen jedoch zusätzlich heruntergeladen und installiert werden. Dies passiert mit Hilfe von sogenannten Paketmanagern. Der standardmäßig installierte Paketmanager ist pip. Daneben gibt es bspw. noch uv, anaconda oder poetry. (Mehr Infos zu Paketen).

Aufgrund der Fülle von möglichen Zusatzpaketen (Tausende) kann es zu Abhängigkeitskonflikten o.ä. zwischen diesen Paketen und deren Funktionalitäten kommen. Daher ist es ratsam für jedes Projekt eine eigene Entwicklungsumgebung (environment) einzurichten.

Virtuelle Umgebungen - `venv`#

Eine Python-Umgebung, auch als virtuelle Umgebung (oder virtual environment)bekannt, ist eine isolierte Umgebung, in der Python-Installationen, Pakete und Abhängigkeiten für ein Projekt gehalten werden können. Dies ermöglicht es, Projektabhängigkeiten zu verwalten und Konflikte zwischen verschiedenen Projekten zu vermeiden. Python-Umgebungen werden häufig mit dem eingebauten Tool venv oder mit externen Tools wie virtualenv, uv, anaconda oder pipenv erstellt.

Umgebungen sind nützlich, wenn Sie mehrere Projekte haben, die unterschiedliche Versionen von Python oder unterschiedliche Versionen von Paketen benötigen. Sie können auch dazu beitragen, die Systeminstallation von Python sauber zu halten und die Installation von Paketen auf Systemebene zu vermeiden. Systemweite Paket-Installationen sollten umbedingt vermieden werden!

tl;dr:
Ein Paket ist eine Sammlung von Modulen, die in einem Verzeichnis organisiert sind, während Module einzelne Dateien mit Python-Code sind. Umgebungen bieten eine isolierte Umgebung für die Verwaltung von Python-Installationen und Abhängigkeiten.

How to venv#

Um eine virtuelle Umgebung in Python zu erstellen und zu verwenden, können Sie die folgenden Schritte mit dem venv-Modul, das in der Python-Standardbibliothek enthalten ist, befolgen:

Navigieren zum Projektverzeichnis:
Öffnen Sie Ihr Terminal oder die Eingabeaufforderung und navigieren Sie zum Verzeichnis, in dem Sie die virtuelle Umgebung erstellen möchten. Verwenden Sie das cd-Kommando, um die Verzeichnisse zu wechseln.
Erstellen einer virtuellen Umgebung:
Führen Sie den folgenden Befehl aus, um eine virtuelle Umgebung zu erstellen. Ersetzen Sie umg durch den Namen, den Sie Ihrer virtuellen Umgebung geben möchten.
```
python3 -m venv umg
```
Dieser Befehl erstellt ein neues Verzeichnis namens umg, das die virtuelle Umgebung enthält.
Aktivieren der virtuellen Umgebung:
Sie müssen die virtuelle Umgebung aktivieren, bevor Sie sie verwenden können. Führen Sie den entsprechenden Befehl für Ihr Betriebssystem aus:
- Unter Windows: umg\Scripts\activate
- Unter Linux oder MacOS: source umg/bin/activate Nach der Aktivierung sehen Sie den Namen der virtuellen Umgebung (umg) im Terminal.
Installieren von Abhängigkeiten (Paketen):
Sobald die virtuelle Umgebung aktiviert ist, können Sie Python-Pakete und Abhängigkeiten mit pip installieren:
```
pip install paketname
```
Deaktivieren der virtuellen Umgebung:
Um die virtuelle Umgebung zu deaktivieren und zur globalen Python-Umgebung zurückzukehren, führen Sie folgendes aus:
```
deactivate
```

Durch diese Schritte können Sie virtuelle Umgebungen in Python mit venv erstellen und verwalten. Dadurch werden Ihre Projektabhängigkeiten von anderen Projekten und der globalen Python-Installation isoliert. Mit anderen Tools sind die Befehle anders, das grundlegende Prozedere allerdings gleich.

Bonusinhalt: Transkription

Nehmen Sie eine kurze Sprachnachricht auf, etwa mit der Diktifunktion Ihres Telefons.
Importieren Sie diese Datei auf Ihren PC in ihr aktuelles Verzeichnis. Aus python können Sie mit os.getcwd() prüfen in welchem Verzeichnis Sie arbeiten.
Erstellen Sie ein neues Python-Environment.
Installieren Sie das Modul whisper. Schauen Sie sich hierzu das Github Repository an.
Öffnen Sie nun Ihre Sprachnachricht und transkribieren Sie diese mit whisper. Geben Sie die Transkription zunächst nur auf Ihrer Commandline aus.
Speichern Sie nun das Ergebnis in einer Textdatei ab.

Alternative Datenquelle

Verwenden Sie alternativ folgende Audiodatei: mp3-datei

```{admonition} load_module-Fehler :class: dropdown, tip Wenn Sie den fehler bekommen, dass Whisper kein ‘load_module’ hat, schauen Sie mal hier nach: openai/whisper#251

Jupyter Notebook & JupyterLab#

Klassische Jupyter Notebooks sind interaktive Dokumente, die sowohl Code als auch Text enthalten können. Sie sind in Zellen unterteilt, in denen Code ausgeführt und Ergebnisse direkt angezeigt werden können. In Bereichen wie Datenanalyse, maschinelles Lernen und wissenschaftliches Rechnen sind diese Notebooks besonders beliebt, da sie eine einfache, schnelle Möglichkeit bieten, Code zu schreiben, zu dokumentieren und zu visualisieren.

JupyterLab ist eine Weiterentwicklung von Jupyter Notebooks, die eine umfangreichere Benutzeroberfläche und mehr Funktionalitäten bietet. JupyterLab ermöglicht nicht nur die Verwendung von Notebooks, sondern auch die gleichzeitige Bearbeitung von Textdateien, interaktiven Visualisierungen, Terminalfenstern und vielem mehr in einer einzigen Benutzeroberfläche.

Verwendung von JupyterLab im Terminal#

Um Jupyter Notebooks im Terminal zu verwenden, müssen Sie sicherstellen, dass Sie die Jupyter-Bibliothek installiert haben (pip install notebook oder pip install jupyterlab). Dann können Sie den Befehl jupyter notebook oder jupyter lab ausführen, um den Jupyter-Server zu starten. Sie erhalten eine URL, die Sie in Ihrem Webbrowser öffnen können, um die Jupyter-Benutzeroberfläche zu verwenden und neue Notebooks zu erstellen oder vorhandene zu öffnen.

Schritt für Schritt Anleitung

Good & Clean Code#

Clean Code bezieht sich auf die Praxis des Schreibens von Code in einer klaren, verständlichen und leicht wartbaren Weise. Die Prinzipien des Clean Code betonen Lesbarkeit, Klarheit und Einfachheit. Hier sind einige wichtige Pragmatismen von Clean Code:

Aussagekräftige Namen verwenden:
Verwenden Sie aussagekräftige Variablen-, Funktions- und Klassennamen, um den Code verständlicher zu machen.
Eine Aufgabe = eine Funktionen:
Funktionen sollten kurz sein und genau eine Aufgabe erledigen. Lange Funktionen sollten in kleinere Funktionen aufgeteilt werden.
Vermeidung von überflüssigem Code:
Entfernen Sie unnötigen Code und Kommentare Das verbessert die Lesbarkeit und vermeidet Redundanz.
Regelmäßige Formatierung:
Halten Sie sich an eine konsistente Formatierung des Codes. Auch das macht Code leichter lesbar. In Python hält man sich dabei am besten an PEP 8.
Kommentare, wo nötig:
Kommentieren Sie Ihren Code, um komplexe Teile zu erklären oder wichtige Informationen zu liefern. Vermeiden Sie unnötige Kommentare. Leitlinie: So viel wie nötig, so wenig wie möglich.

Beispiele:#

Die folgenden Beispiele zeigen exemplarisch, wie schlechter Code aussehen kann und wie man ihn besser machen könnte. Versuchen Sie gerne selber - vor Betrachtung der Lösung - den entsprechenden Code klarer zu machen. Vergleichen Sie dann Ihre Lösung mit den “besseren” Beispielen.

Schlechte Praxis: Unklare, generische Namen

def do_stuff(a, b, c):
    return a * b - c

Bessere Praxis: Namen klären Funktion

def gesamtpreis(einzelpreis, anzahl, rabatt):
    return (einzelpreis * anzahl) - rabatt

Schlechte Praxis: Eine (Funktion) für Alle(s)

def process_data(data):
    # Filter data
    data = [x for x in data if x > 0]

    # Calculate average
    average = sum(data) / len(data)

    # Print results
    print(f"Average: {average}")
    return data

Bessere Praxis: Klar enkapsuliert, keine Kommentare

def filter_positive_data(data):
    data = [x for x in data if x > 0]
    return(data)

def calculate_average(data)
    average = sum(data) / len(data)
    return average

def print_result(average}
    print(f"Average: {average}")

clean_data = filter_positive_data(raw_data)
average = calculate_average(clean_data)
print_result(average)

Schlechte Praxis: Unnötiger Code, Funktion in Schleife, Name doppelt?

filter = []
for x in range(len(data)):
    def is_too_big(x):
        if x > 10:
            return true
        else:
            return false

    if is_too_big(data[x]):
        pass
    else:
        filter.append(data[x])

Bessere Praxis: Kürzer und klarer

def is_too_big(value):
    return value > 10

filter = []
for x in data:
    if not is_too_big(x):
        filter.append(x)

Noch Bessere Praxis: Einfaches einfach und Python pythonic machen

filter = [x for x in data if x < 10]

Beispiele basierend auf diesem Blogpost

PEP 20 - Das Zen von Python:#

PEP 20 ist ein Dokument mit dem Titel Das Zen von Python, das die philosophischen Leitlinien für die Entwicklung von Python-Software darstellt. Es wurde von Tim Peters verfasst und beschreibt die grundlegenden Prinzipien, die hinter dem Design der Python-Sprache stehen. Um den gesamten Zen of Python zu bestaunen, führen Sie import this im REPL aus.

Weitere Hilfsmittel und Leitlinien für besseren Code sind Code-Formatter wie black oder ruff, pre-commit hooks und zahlreiche Erweiterungen in Ihrer IDE. Hiermit sollten Sie sich beizeiten mit auseinandersetzen. Das stellt aber zum momentanen Zeitpunkt kein Muss dar.

Bonusinhalt: Kniffel? Yahtzee!

Stellen Sie sich vor, sie arbeiten für eine kleine, inhabergeführte Software-Schmiede und einer ihrer Kollegen hat etwas Arbeit in ein Projekt für die Deutsche Kniffel-Gesellschaft gesteckt. Der Vertrag läuft über 10 Stunden, und Ihr Kollege sitzt bereits 8.5 Stunden an dem Projekt. Am Montag kommen Sie frisch wie eh und je ins Büro, und ihr Kollege ist leider krank. Heute wäre sein Geburtstag gewesen, er hätte Kuchen mitgebracht. Ihre Chefin hat Sie gebeten, für den Kollegen zu übernehmen. Sie möchte, dass Sie noch eine gute Stunde an dem Code weiterarbeiten, damit sie die vollen 10 Stunden abrechnen kann. Sie weist Sie an, den Code ein bisschen aufzuräumen und gegebenenfalls ein paar Notizen zu machen, die Ihrem kranken Kollegen als Feedback zu seinem Code dienen können.

Der Code findet sich in yatzy.py. Die Tests Ihres Kollegen finden sich in test_yatzy.py. Die benötigten Abhängigkeiten sind wie immer in requirements.txt, dies ist schließlich Firmen-Standard. Ihre Chefin meint, die Tests seien bereits komplett und müssen nicht mehr angepasst werden; der Kunde hätte sie bereits abgesegnet. Die Notizen Ihres Kollegen finden Sie auf seinem Tisch:

Regeln für Kniffel -> Wikipedia
Code: Score für gegebenen Wurf in gegebener Kategorie berechnen
Nicht: Würfeln programmieren
Nicht: Logik, die beste Kategorie bestimmt!
python -m pip install requirements.txt, python -m pytest

Inspiration für diese Kata von Emily Bache über github, Code von Emily Bache über github.

Und jetzt?#

Wie geht es jetzt weiter?

Üben, üben, üben.
Programmieren ist Handwerk, und man lernt es am einfachsten durchs Tun. Das kann in kleinen, eigenen Projekten für den Privat-Gebrauch passieren. Das kann aber auch in großen Open-Source-Projekten passieren, die sich beispielsweise auf GitHub finden. Offene Baustellen in diesen Projekten finden sich meistens in Issues. Diese sind oft schon kategorisiert und nach Komplexität geordnet. Falls das der Fall ist, freuen sich oft die Maintainer oft über externe Mitarbeit.
Weitere Kurse:
- Geoscripting, Prof. Höfle
- Advanced Geoscripting, Dr. Ludwig
Abschlussabgabe