aiMOOC

Programmieren für technische Aufgaben – Quellcode verständlich dokumentieren

QR-Code

Programmieren für technische Aufgaben – Quellcode verständlich dokumentieren

Zielgruppe: Berufliche Ausbildung in IT und technischen Berufen

Niveau: Grundlagen mit Anwendungs- und Transferaufgaben

Dauer: 5 Lerneinheiten zu je etwa 10 Minuten, zusätzlich Übungs- und Projektzeit

Werkzeug: Python 3.10 oder neuer, lokal installiert

Leitfrage: Wie dokumentierst Du Programmcode so, dass andere seine Funktion, Beispiele und bekannten Grenzen verstehen?

Einleitung

Guter Quelltext soll nicht nur funktionieren, sondern auch für andere verständlich sein. In diesem Kurs lernst Du, mit sprechenden Namen, sinnvollen Kommentaren, Docstrings, Beispielen und Tests die Softwaredokumentation zu verbessern.

Du arbeitest an einem vollständig fiktiven Temperaturprüfstand. Alle Daten sind Übungswerte. Es gibt keine Verbindung zu echten Sensoren, Netzwerken oder Produktionsanlagen.

Deine Lernziele:

Lesbarkeit: Du kannst unübersichtlichen Code verständlich benennen und strukturieren.
Softwaredokumentation: Du beschreibst Eingaben, Rückgaben, Regeln, Beispiele und bekannte Grenzen.
Softwaretest: Du prüfst Normalfälle, Grenzwerte und ungültige Eingaben.
Code-Review: Du erkennst Widersprüche zwischen Programmverhalten und Dokumentation.
Softwarequalität: Du kannst begründen, weshalb eine Dokumentation hilfreich oder unzureichend ist.

Dein Lernweg

Einheit	Inhalt	Ergebnis
1	Code lesen	Verständliche Namen
2	Dokumentieren	Aussagekräftiger Docstring
3	Grenzen verstehen	Dokumentierte Testfälle
4	Lokal testen	Ausführbares Kurslabor
5	Prüfen und verbessern	Review und Übergabe

Lerneinheit 1: Lesbaren Quellcode schreiben

Merke: Namen sollen den Zweck verraten. Kommentare sollen vor allem wichtige Entscheidungen und nicht offensichtliche Zusammenhänge erklären.

Abbildung: Syntaxhervorhebung verbessert die Orientierung im Quelltext. Das Beispielbild verwendet HTML; das Prinzip gilt auch für Python.

Vorher und nachher

Schwer verständlich:

def f(x):
    return 18 <= x <= 26

Besser lesbar:

def temperatur_im_bereich(temp_c):
    """Pruefe den fiktiven Bereich von 18 bis 26 Grad C."""
    return 18 <= temp_c <= 26

Die zweite Variante macht den Zweck besser erkennbar. Sie ist allerdings noch kein robustes Prüfprogramm: Ungültige Eingaben können Fehler auslösen oder unerwartete Ergebnisse liefern.

Mini-Aufgabe: Benenne die Funktion und ihre Eingabe um. Welche Information liefert der neue Name?

Video: How to Write Good Code Comments. Englischsprachige Vertiefung zum sinnvollen Kommentieren.

Lerneinheit 2: Funktionen richtig dokumentieren

In Python ist ein Docstring eine Dokumentationszeichenkette am Anfang einer Funktion, Klasse oder eines Moduls.

Eine hilfreiche Funktionsdokumentation beantwortet fünf Fragen:

Frage	Beispiel
Was macht die Funktion?	Temperatur bewerten
Welche Eingabe erwartet sie?	Temperatur in Grad Celsius
Was liefert sie zurück?	OK, AUSSERHALB oder UNGUELTIG
Welches Beispiel gilt?	18,0 ergibt OK
Welche Grenzen hat sie?	Keine Messunsicherheit oder Sensoranbindung

Merksatz: Dokumentiere das Verhalten und die wichtigen Annahmen, statt lediglich Programmzeilen in Worten zu wiederholen.

Video: Python Tutorial: Docstrings. Englischsprachiges Lernvideo.

Kommentare oder Docstrings?

Mittel	Aufgabe
Sprechender Name	Macht die Absicht direkt erkennbar
Kommentar	Erklärt eine wichtige Entscheidung oder Ausnahme
Docstring	Beschreibt den Vertrag einer Funktion
Testfall	Prüft, ob das tatsächliche Verhalten zum Vertrag passt

Nach PEP 8 sollen Kommentare hilfreich und aktuell sein. PEP 257 beschreibt verbreitete Konventionen für Python-Docstrings.

Lerneinheit 3: Ausbildungsfall Temperaturprüfstand

Auftrag: In einer simulierten Ausbildungssituation soll eine Funktion fiktive Temperaturwerte klassifizieren.

Die Werte 18,0 °C und 26,0 °C sind eingeschlossen. Diese Grenzen sind ausschließlich für die Übung gewählt und keine technischen Norm- oder Sicherheitsgrenzen.

Die Entscheidungsregel

FIKTIVER TEMPERATURBEREICH

Zu niedrig       Freigegebener Übungsbereich        Zu hoch

     17,9   |18,0 ==================== 26,0|   26,1
            |                            |
 AUSSERHALB |             OK             | AUSSERHALB

Darstellung schematisch, nicht maßstabsgetreu.

Abbildung: Allgemeines Flussdiagramm. Nutze dieses Darstellungsmittel, um die eigene Prüflogik zu skizzieren.

Visualisierte Beispieldaten

Fiktiver Wert	Erwarteter Status	Begründung
17,9 °C	AUSSERHALB	Unterhalb der Untergrenze
18,0 °C	OK	Untergrenze ist eingeschlossen
22,0 °C	OK	Innerhalb des Bereichs
26,0 °C	OK	Obergrenze ist eingeschlossen
26,1 °C	AUSSERHALB	Oberhalb der Obergrenze
Kein Wert	UNGUELTIG	Keine auswertbare Messung
NaN	UNGUELTIG	Keine endliche Zahl

Frage: Warum reicht es nicht, nur den Wert 22,0 °C zu testen?

Feedback: Ein Normalfall zeigt nicht, ob Grenzwerte eingeschlossen sind oder ungültige Eingaben sicher behandelt werden.

Bekannte Grenzen des Ausbildungsfalls

Die Werte stammen nicht aus echten Messungen.
Die Funktion ist nicht für eine Sicherheitssteuerung vorgesehen.
Messunsicherheit, Kalibrierung und Hysterese sind nicht berücksichtigt.
Die Simulation steuert keine Aktoren oder technischen Anlagen.
Die dokumentierten Beispielgrenzen sind nicht auf reale Anlagen übertragbar.

Lerneinheit 4: Lokales Python-Labor

Sicherheitsregel: Arbeite nur auf Deinem eigenen oder ausdrücklich freigegebenen Ausbildungsrechner. Nutze ausschließlich fiktive Werte. Es werden weder Kundendaten noch Zugangsdaten benötigt.

Vorbereitung: Speichere den folgenden vollständigen Code als kurs.py.

"""Kurslabor: Temperaturcheck an einem fiktiven Pruefstand.

Start: python3 -I -B kurs.py
Keine echten Messwerte, Dateien, Netze oder Anlagen.
"""

import math
import unittest

MIN_C = 18.0
MAX_C = 26.0


def temperatur_status(temp_c):
    """Bewerte einen fiktiven Temperaturwert in Grad Celsius.

    Eingabe: int oder float, jedoch kein bool, NaN oder Unendlich.
    Rueckgabe: OK fuer 18.0 bis 26.0 einschliesslich,
    AUSSERHALB fuer andere endliche Zahlen, sonst UNGUELTIG.
    Beispiel: temperatur_status(18.0) liefert OK.
    Grenzen: keine Sensoranbindung, Kalibrierung oder Hysterese.
    """
    if type(temp_c) not in (int, float):
        return "UNGUELTIG"
    if type(temp_c) is float and not math.isfinite(temp_c):
        return "UNGUELTIG"

    # Im fiktiven Auftrag sind beide Grenzwerte eingeschlossen.
    if MIN_C <= temp_c <= MAX_C:
        return "OK"
    return "AUSSERHALB"


class TestTemperaturStatus(unittest.TestCase):
    """Teste die dokumentierte Regel mit fiktiven Werten."""

    def test_normalfall(self):
        self.assertEqual(temperatur_status(22), "OK")

    def test_grenzen(self):
        for wert in (18.0, 26.0):
            with self.subTest(wert=wert):
                self.assertEqual(temperatur_status(wert), "OK")

    def test_ausserhalb(self):
        for wert in (17.9, 26.1):
            with self.subTest(wert=wert):
                self.assertEqual(
                    temperatur_status(wert), "AUSSERHALB"
                )

    def test_ungueltig(self):
        for wert in (None, True, "22", float("nan"),
                     float("inf")):
            with self.subTest(wert=wert):
                self.assertEqual(
                    temperatur_status(wert), "UNGUELTIG"
                )


def labor():
    """Biete fiktive Konsolenwerte als lokale Uebung an."""
    print("Fiktive Beispieldaten:")
    for wert in (17.9, 18.0, 22.0, 26.0, 26.1, None):
        print(f"{str(wert):>5} -> {temperatur_status(wert)}")

    print("Nur lokale Testwerte eingeben; x beendet die Uebung.")
    while True:
        try:
            text = input(
                "Temperatur in Grad C (x=Ende): "
            ).strip()
        except EOFError:
            return

        if text.lower() == "x":
            return

        try:
            wert = float(text.replace(",", "."))
        except ValueError:
            print("UNGUELTIG")
        else:
            print(temperatur_status(wert))


if __name__ == "__main__":
    ergebnis = unittest.TextTestRunner(verbosity=2).run(
        unittest.defaultTestLoader.loadTestsFromTestCase(
            TestTemperaturStatus
        )
    )
    if not ergebnis.wasSuccessful():
        raise SystemExit(1)
    labor()

Programm lokal starten

Öffne ein Terminal im Verzeichnis Deiner selbst erstellten Datei.

Linux oder macOS:

python3 -I -B kurs.py

Windows mit Python Launcher:

py -I -B kurs.py

Die Funktionstests laufen zuerst. Danach beginnt die interaktive Konsolenübung.

Erwartete Testausgabe: Vier Testmethoden, keine Fehler, Status OK. Die anschließende Eingabeübung bleibt lokal.

Die Option -I schränkt Python-Umgebungseinflüsse ein; -B unterdrückt die Erzeugung von Bytecode-Cachedateien. Diese Optionen sind keine vollständige Sicherheits-Sandbox.

Interaktives Experiment

Gib im lokalen Labor nacheinander folgende Testwerte ein:

Eingabe	Erwartete Antwort
18	OK
26,1	AUSSERHALB
abc	UNGUELTIG
NaN	UNGUELTIG
x	Programm beenden

Forscherauftrag: Verändere einen fiktiven Eingabewert. Vergleiche die tatsächliche Ausgabe mit Deiner Vorhersage.

Achtung: Eine Konsoleneingabe wie 22 wird in dieser Übung in eine Fließkommazahl umgewandelt. Ein direkt als Zeichenkette an die Funktion übergebenes "22" wird dagegen bewusst zurückgewiesen.

Optional: stärker abgeschottete Testumgebung

Nur für freigegebene Ausbildungssysteme mit bereits lokal vorhandener, vertrauenswürdig bereitgestellter Docker-Umgebung.

Voraussetzung: Das Image python:3.12-alpine ist schon lokal installiert. Der Befehl lädt ausdrücklich kein Image herunter.

Beispiel für eine Linux-/macOS-Shell:

docker run --rm -it --pull=never \
  --network=none --read-only \
  --cap-drop=ALL \
  --security-opt=no-new-privileges \
  --pids-limit=64 --memory=256m \
  -v "$PWD/kurs.py:/app/kurs.py:ro" \
  python:3.12-alpine python -I -B /app/kurs.py

Die Übung verwendet kein Netzwerk, bindet nur die lokale Kursdatei schreibgeschützt ein und entfernt den Container nach Beendigung.

Wichtig: Container-Isolation ersetzt keine Sicherheitsprüfung durch die Ausbildungsorganisation. Verwende keine fremden Docker-Images, Anlagenverbindungen, Host-Zugangsdaten oder produktiven Volumes.

Lerneinheit 5: Testen, Review und Übergabe

Abbildung: Testpyramide. Die Übung konzentriert sich auf Unit-Tests; sie ersetzt keine Integrations- oder Systemprüfung.

Ein Unit-Test überprüft eine kleine Programmeinheit automatisiert. Die dokumentierten Regeln liefern die Grundlage für geeignete Testfälle.

Video: Python Tutorial: Unit Testing Your Code with the unittest Module. Englischsprachige Vertiefung.

Fünf Fragen für ein Code-Review

Prüffrage	Qualitätsmerkmal
Versteht eine andere Person den Zweck?	Klare Namen und Kurzbeschreibung
Sind Ein- und Ausgaben beschrieben?	Nachvollziehbarer Funktionsvertrag
Stimmen Beispiele mit dem Code überein?	Ausführbare Testfälle
Sind Einschränkungen sichtbar?	Dokumentierte bekannte Grenzen
Ist die Testumgebung sicher?	Fiktive Daten, keine externen Systeme

Abbildung: Schulung zu Code-Reviews. Prüfe auch die Verständlichkeit für andere Personen.

Dokumentation ist Teil der Wartung

Abbildung: Allgemeiner Softwareentwicklungszyklus. Ändert sich das Verhalten, müssen auch Dokumentation und Tests überprüft werden.

Gestufte Hilfen

Versuche jede Aufgabe zunächst selbst. Lies die nächste Hilfe erst, wenn Du sie benötigst.

Hilfestufe	Unterstützung
Hilfe 1 – Denkanstoß	Frage Dich, was hineingeht, was herauskommt und wann ein Ergebnis gültig ist.
Hilfe 2 – Struktur	Schreibe im Docstring Zweck, Eingabe, Rückgabe, Beispiel und Grenzen auf.
Hilfe 3 – Konkreter Ansatz	Prüfe zuerst den Datentyp, danach endliche Zahlen und zuletzt die beiden eingeschlossenen Grenzwerte.

Begründetes Feedback zu den Lernstufen

Stufe	Tragfähige Lösung	Warum?
Basis	Ein sprechender Funktionsname ersetzt eine unklare Abkürzung.	Der Zweck wird ohne zusätzliche Erklärung erkennbar.
Anwendung	Tests prüfen beide Grenzwerte und ungültige Werte.	Die dokumentierte Regel wird an kritischen Stellen überprüft.
Transfer	Eine neue Anforderung führt zur Anpassung von Code, Dokumentation, Beispielen und Tests.	Nur so bleiben die verschiedenen Beschreibungen des Programmverhaltens konsistent.

Negativbeispiel: Eine Kommentarzeile behauptet, 26,0 °C sei ungültig, während der Code OK zurückgibt. Das ist unzureichend, weil die Dokumentation eine falsche Erwartung erzeugt.

Interaktive Aufgaben

Quiz: Teste Dein Wissen

Welches Ziel hat gute Quellcodedokumentation? (Das Verhalten und die Grenzen des Programms verständlich machen) (!Möglichst viele Kommentare schreiben) (!Alle Tests ersetzen) (!Die Ausführung des Programms verlangsamen)

Was ist in Python ein Docstring? (Eine Dokumentationszeichenkette am Anfang einer Funktion oder Klasse) (!Ein beliebiger Variablenname) (!Eine automatisch ausgeführte Testdatei) (!Ein Ersatz für Python selbst)

Wann ist ein Kommentar besonders hilfreich? (Wenn er eine nicht offensichtliche Entscheidung erklärt) (!Wenn er jeden einzelnen Operator wiederholt) (!Wenn er veraltete Regeln enthält) (!Wenn er unverständliche Namen grundsätzlich beibehält)

Was ergibt im Ausbildungsfall die Eingabe 18,0 Grad Celsius? (OK) (!AUSSERHALB) (!UNGUELTIG) (!Programmabbruch)

Wie bewertet das Programm 26,1 Grad Celsius? (AUSSERHALB) (!OK) (!UNGUELTIG) (!Keine Ausgabe)

Wie behandelt die Funktion den fehlenden Wert None? (UNGUELTIG) (!OK) (!AUSSERHALB) (!Als Null Grad Celsius)

Warum wird math.isfinite bei Fließkommazahlen verwendet? (Um NaN und unendliche Werte zu erkennen) (!Um automatisch Sensoren zu kalibrieren) (!Um Kommentare zu erzeugen) (!Um Dateien im Internet abzurufen)

Warum wird True im Kurs nicht als Messwert akzeptiert? (Weil boolesche Werte keine zulässigen Temperaturmessungen sind) (!Weil True immer unendlich ist) (!Weil True größer als 26 ist) (!Weil True grundsätzlich ein Syntaxfehler ist)

Welche Aussage zur lokalen Python-Option I trifft zu? (Sie isoliert Teile der Python-Umgebung ohne vollständige Betriebssystemabschottung) (!Sie deaktiviert garantiert jede Netzwerkverbindung) (!Sie ersetzt alle Tests) (!Sie macht jede beliebige Datei ungefährlich)

Was sollte nach einer Änderung der Temperaturgrenzen passieren? (Code, Dokumentation, Beispiele und Tests gemeinsam überprüfen) (!Nur den Dateinamen ändern) (!Alle Docstrings löschen) (!Nur die Bildgröße anpassen)

Memory

Finde die zusammengehörenden Begriffe.

Docstring	Dokumentationszeichenkette einer Funktion
Grenzwerttest	Prüfung am Rand des erlaubten Bereichs
Unit-Test	Automatisierte Prüfung einer kleinen Programmeinheit
Sprechender Name	Bezeichnung mit erkennbarem Zweck
Bekannte Grenze	Dokumentierte Einschränkung der Lösung
Code-Review	Fachliche Prüfung durch eine andere Person

Drag and Drop

Ordne die Dokumentationselemente ihren Aufgaben zu.

Ordne die richtigen Begriffe zu.	Thema
Funktionsname	Verständliche Benennung
Docstring	Beschreibung der Schnittstelle
Grenzfall	Prüfung eines Randwertes
Unit-Test	Automatischer Ergebnisvergleich
Warnhinweis	Erklärung einer bekannten Einschränkung

Kreuzworträtsel

Docstring	Wie heißt die Dokumentationszeichenkette am Anfang einer Python-Funktion?
Kommentar	Wie heißt eine erläuternde Anmerkung innerhalb des Quellcodes?
Grenzwert	Wie nennt man einen Randwert eines erlaubten Bereichs?
Testfall	Wie nennt man eine einzelne Prüfung mit Eingabe und erwartetem Ergebnis?
Lesbarkeit	Welche Eigenschaft beschreibt, wie gut Menschen Quelltext erfassen können?
Hysterese	Wie heißt eine Umschaltdifferenz, die häufiges Hin- und Herschalten vermeiden kann?

LearningApps

Externe Ergänzung: LearningApps darf nur genutzt werden, wenn die Ausbildungsorganisation die Verwendung und Datenübertragung ausdrücklich freigegeben hat. Für alle Kernaufgaben genügt das lokale Kurslabor.

Lückentext

Verständliche Variablennamen verbessern die

eines Programms.

Eine Dokumentationszeichenkette am Anfang einer Python-Funktion heißt

.

Ein Kommentar kann erläutern,

eine Entscheidung getroffen wird.

Die fiktiven Temperaturen werden in Grad

angegeben.

Die beiden Grenzwerte sind im Ausbildungsfall

.

Fehlende oder unzulässige Eingaben liefern den Status

.

Mit einem

prüfst Du eine Bereichsgrenze.

Die Python-Bibliothek

ermöglicht automatisierte Funktionstests.

Der Wert

ist keine endliche Zahl.

Die Beispieldaten müssen im Kurs ausschließlich

sein.

Nach Programmänderungen müssen auch die

überprüft werden.

Bekannte technische

gehören in die Dokumentation.

Offene Aufgaben

Arbeitsweise: Bearbeite die Aufgaben mit fiktiven Daten. Leicht entspricht der Basisstufe, Standard der Anwendung und Schwer dem Transfer. Prüfe Deine Ergebnisse anhand der Feedbackkriterien.

Leicht

Code lesen: Unterstreiche in einem selbst erfundenen kurzen Programm unklare Bezeichner und erkläre ihre Bedeutung. Feedback: Gut gelöst, wenn eine andere Person die Funktion ohne Rückfrage erkennt.
Namen verbessern: Ersetze mindestens vier unklare Variablennamen durch sprechende Namen. Feedback: Gute Namen beschreiben einen Zweck statt nur einen Datentyp.
Kommentare prüfen: Formuliere zwei sinnvolle und zwei unnötige Kommentare. Feedback: Sinnvoll ist eine Erklärung besonders dann, wenn der Code die Entscheidung allein nicht verständlich macht.
Docstring schreiben: Beschreibe Eingabe, Rückgabe, Beispiel und Grenze einer eigenen Mini-Funktion. Feedback: Vollständig ist die Lösung, wenn diese Angaben das tatsächliche Verhalten treffen.

Standard

Testtabelle erstellen: Erstelle für den fiktiven Prüfstand sechs Testfälle samt erwarteter Ergebnisse. Feedback: Berücksichtige beide Grenzen, mindestens einen Normalfall und ungültige Eingaben, weil dort unterschiedliche Fehler entstehen können.
Funktion erweitern: Ergänze im lokalen Kurslabor einen weiteren fiktiven Testwert und die zugehörige Prüfung. Feedback: Der neue Test soll eine klar begründete Regel nachweisen und wiederholbar sein.
Partnerprüfung: Tausche Deinen selbst geschriebenen Code mit einer anderen lernenden Person und sammle drei konkrete Verbesserungsvorschläge. Feedback: Gute Kritik benennt Fundstelle, Wirkung und mögliche Änderung.
Ablauf visualisieren: Zeichne die Entscheidungen für gültige Eingabe, Bereichsprüfung und Rückgabe. Feedback: Jeder mögliche Rückgabestatus benötigt einen nachvollziehbaren Pfad.

Schwer

Regeländerung durchführen: Ändere ausschließlich im lokalen Übungsprojekt die fiktiven Grenzen auf 19 und 25 Grad Celsius. Aktualisiere Code, Docstring, Testfälle und Grafik. Feedback: Alle vier Darstellungen müssen widerspruchsfrei sein.
Messunsicherheit analysieren: Entwickle einen schriftlichen Vorschlag, wie eine fiktive Messunsicherheit beschrieben werden könnte, ohne eine reale Steuerung zu programmieren. Feedback: Die Lösung ist tragfähig, wenn offene Annahmen und Entscheidungsbedarf deutlich werden.
Übergabedokument erstellen: Erstelle eine einseitige Anleitung mit Zweck, Nutzung, Beispielen, Tests und bekannten Grenzen. Feedback: Eine neue Person soll die Übung ohne mündliche Nachhilfe nachvollziehen können.
Dokumentationsaudit gestalten: Erfinde drei veraltete Aussagen in einer Dokumentation und zeige, wie Du sie durch lokale Tests überprüfen würdest. Feedback: Begründete Korrekturen verweisen auf beobachtbares Verhalten statt Vermutungen.

Lernkontrolle

Bearbeite die folgenden Aufgaben schriftlich oder mit selbst erstellten fiktiven Testdaten.

Änderungsfolgen: Erkläre, weshalb das bloße Ändern der Grenzwerte im Code keine ausreichende Wartungsmaßnahme ist. Beschreibe die Auswirkungen auf Dokumentation und Tests.
Grenzfallanalyse: Vergleiche eine Teststrategie mit ausschließlich Normalwerten mit einer Strategie aus Normal-, Grenz- und ungültigen Fällen. Begründe, welche Fehler die zweite Strategie zusätzlich aufdecken kann.
Widerspruch erkennen: Ein Docstring bezeichnet 26 Grad Celsius als ungültig, der Code liefert OK. Entwickle ein Verfahren, mit dem Du den Widerspruch lokal nachweisen und beheben kannst.
Unklare Spezifikation: Ein Ausbildungsauftrag nennt nur einen zulässigen Temperaturbereich, aber keine Regel für fehlende Werte. Formuliere zwei notwendige Rückfragen und begründe sie.
Grenzen bewerten: Erkläre, weshalb ein bestandener Unit-Test keine Aussage über Kalibrierung, Messunsicherheit oder die Sicherheit einer echten Anlage beweist.
Sicher übertragen: Entwirf einen Ablauf, mit dem Du eine Programmierübung aus einem Ausbildungsbetrieb an eine andere lernende Person weitergeben kannst, ohne vertrauliche Daten oder produktive Zugänge preiszugeben.

Lernnachweis

Für einen erfolgreichen Lernnachweis benötigst Du:

Kommentierten Quellcode: Eine lokal lauffähige Python-Funktion mit verständlicher Benennung und zutreffendem Docstring.
Funktionsvertrag: Angaben zu Zweck, Eingaben, Rückgaben, Beispielen und bekannten Grenzen.
Testnachweis: Mindestens sechs fiktive Testfälle, darunter beide Grenzwerte und ungültige Eingaben.
Testprotokoll: Erwartete und tatsächlich ermittelte Ergebnisse mit kurzer Begründung bei Abweichungen.
Visualisierung: Eine eigene Tabelle oder ein Flussdiagramm zur dokumentierten Entscheidungsregel.
Review: Mindestens drei nachvollziehbare Qualitätsprüfungen und eine begründete Verbesserung.
Transferleistung: Eine dokumentierte Änderung der fiktiven Anforderung einschließlich angepasster Tests.
Sicherheitsnachweis: Bestätigung, dass ausschließlich lokale oder ausdrücklich freigegebene Testumgebungen und fiktive Daten verwendet wurden.

Bewertungsvorschlag: Lesbarkeit 20 Prozent, Dokumentation 25 Prozent, Tests 25 Prozent, Transfer und Begründung 20 Prozent, sichere Durchführung 10 Prozent.

OERs zum Thema

Fachlich überprüfte Quellen

PEP 8 – Style Guide for Python Code: Offizielle Empfehlungen zu Lesbarkeit, Benennungen und Kommentaren.
PEP 257 – Docstring Conventions: Konventionen für Dokumentationszeichenketten.
Python-Dokumentation – unittest: Offizielle Erläuterung des Testframeworks.
Python-Dokumentation – math: Beschreibung mathematischer Funktionen einschließlich isfinite.
Softwaredokumentation: Überblick über Formen und Ziele der Softwaredokumentation.
Programmierstil: Hintergrund zu lesbarem und wartbarem Programmcode.
Kommentar (Programmierung): Erläuterung von Kommentaren in Programmiersprachen.

Hinweis: Nicht jede frei abrufbare Fachquelle und nicht jedes YouTube-Video ist automatisch eine frei lizenzierte OER.

Geprüfte Medien und Nutzungsrechte

Medium	Urheberangabe	Lizenz laut Wikimedia Commons
Syntaxhighlighting.png	Geany-Entwickler, Screenshot bereitgestellt von Kreuzschnabel	GPL ab Version 2
Flowchart de.svg	Erik Streb	CC BY-SA 3.0
Testing Pyramid.svg	Abbe98	CC BY-SA 4.0
Code Review photo-1.jpg	Matthew (WMF)	CC BY-SA 3.0
Software Development Life cycle.png	Tazlavi	CC BY-SA 4.0

Die Dateien sind unverändert eingebunden. Beachte bei einer Weiterverwendung die jeweilige Lizenz, die Namensnennung und gegebenenfalls die Weitergabe unter gleichen Bedingungen. Die verlinkten Commons-Dateibeschreibungen enthalten die maßgeblichen Lizenzdetails.

Die eingebetteten YouTube-Videos sind externe Angebote. Die Rechte verbleiben bei den jeweiligen Berechtigten. Eine frei verfügbare Wiedergabe bedeutet keine Erlaubnis zur beliebigen Kopie oder Bearbeitung.

Datenschutz: Externe Videos, LearningApps und Wikipedia-Einbettungen können beim Aufruf Verbindungen zu Drittanbietern auslösen. Verwende sie nur im Rahmen der Freigaben Deiner Ausbildungsorganisation. Keine Übungs- oder Kundendaten an solche Dienste übertragen.