Die Druckversion wird nicht mehr unterstützt und kann Darstellungsfehler aufweisen. Bitte aktualisiere deine Browser-Lesezeichen und verwende stattdessen die Standard-Druckfunktion des Browsers.

aiMOOC

Programmieren für technische Aufgaben – Funktionen mit klaren Schnittstellen schreiben

QR-Code

Programmieren für technische Aufgaben – Funktionen mit klaren Schnittstellen schreiben

Zielgruppe: Ausbildung in Informatik, Mechatronik, Elektronik und technischen Berufen

Niveau: Grundlagen bis berufliche Anwendung

Dauer: ca. 90–120 Minuten

Programmiersprache: Python ab Version 3.10

Einleitung

Eine gute Funktion übernimmt eine klar definierte Aufgabe, erhält Eingaben über Parameter und liefert ein nachvollziehbares Ergebnis zurück.

In diesem aiMOOC programmierst Du eine fiktive Förderband-Prüfstation. Du berechnest Geschwindigkeiten, prüfst Grenzwerte und verwendest Deine Funktionen mehrfach.

Ein reales Förderband als Anschauungsbeispiel. Die Messwerte und die Software des Lernkurses sind vollständig fiktiv.

Deine Lernziele:

Funktionen mit verständlichen Namen definieren.
Parameter und Argumente unterscheiden.
Mit return Werte zurückgeben.
Schnittstellen mit Einheiten, Datentypen und Fehlerregeln beschreiben.
Funktionen wiederverwenden und kombinieren.
Automatische Tests mit normalen, ungültigen und grenzwertigen Eingaben durchführen.

Sicherheitsregel: Du arbeitest ausschließlich lokal mit erfundenen Messwerten. Keine Verbindung zu Maschinen, Steuerungen, betrieblichen Netzen oder Kundensystemen herstellen. Keine Zugangsdaten oder echten Betriebsdaten eingeben. Die Übungen steuern keine Anlagen und versenden keine Daten.

Dein Lernweg

Einheit	Schwerpunkt	Ergebnis
1 – Verstehen	Parameter und Rückgabe	Erste Funktion
2 – Anwenden	Technische Messwerte	Geschwindigkeit berechnen
3 – Absichern	Fehlerbehandlung und Tests	Geprüfte Funktionen
4 – Übertragen	Wiederverwendung	Eigenes kleines Lernprojekt

Vorbereitung: Installiere Python 3.10 oder neuer auf einem lokalen Lernrechner. Lege einen Ordner funktionslabor an. Alle späteren Beispiele benötigen ausschließlich die Python-Standardbibliothek. Es sind weder ein Online-Compiler noch zusätzliche Pakete erforderlich.

Lerneinheit 1: Funktionen verstehen

Eingabe – Verarbeitung – Ausgabe

Stelle Dir eine Funktion als Baustein vor.

Eingabe → Funktion → Rückgabe

Der Baustein muss nicht wissen, woher die Daten stammen. Der aufrufende Programmteil muss nicht wissen, wie die Berechnung intern erfolgt.

Eine mathematische Funktionsmaschine veranschaulicht das Prinzip. In der Programmierung kommen zusätzlich Fehlerbehandlung, Datentypen und Schnittstellenregeln hinzu.

Parameter und Argumente

def berechne_tempo(weg_m: float, zeit_s: float) -> float:
    return weg_m / zeit_s

ergebnis = berechne_tempo(12.0, 10.0)
print(ergebnis)

Erwartete Ausgabe:

1.2

Element	Bedeutung
`berechne_tempo`	Funktionsname
`weg_m`	Parameter für Weg in Metern
`zeit_s`	Parameter für Zeit in Sekunden
`12.0` und `10.0`	Konkrete Argumente des Aufrufs
`float`	Datentypangabe
`return`	Gibt das Berechnungsergebnis zurück

Merke: Ein Parameter steht in der Funktionsdefinition. Ein Argument ist der konkrete übergebene Wert.

Die Typangaben sind in Python Hinweise für Menschen und Prüfwerkzeuge. Sie erzwingen zur Laufzeit nicht automatisch den angegebenen Datentyp.

Achtung: Dieses erste Beispiel enthält noch keine Eingabeprüfung. Bei einer Zeit von null würde die Division scheitern. Das verbessern wir später.

Video: Python Funktionen – Definition, Parameter und erstes Beispiel. Kanal: PyJa.

Rückgabe statt bloßer Ausgabe

def quadrat(zahl: float) -> float:
    return zahl * zahl

flaeche = quadrat(4.0)
print(flaeche)

Ergebnis: 16.0

Eine Funktion mit return liefert einen Wert, den andere Funktionen weiterverarbeiten können.

print() zeigt dagegen etwas auf dem Bildschirm an. Ein bloßes print() ist kein Ersatz für einen passenden Rückgabewert.

Ohne ausdrückliches return gibt eine Python-Funktion normalerweise None zurück.

Video: Python-Funktionen mit Rückgabewert. Kanal: Programmieren Starten.

Mini-Aufgabe 1

Schreibe die Funktion quadrat so um, dass sie den Parameter seitenlaenge verwendet.

Prüfe lokal, ob quadrat(5.0) den Wert 25.0 zurückgibt.

Hilfe 1: Ändere den Namen in der Parameterliste und im Funktionskörper.

Hilfe 2: Der Ausdruck hinter return muss die Seitenlänge mit sich selbst multiplizieren.

Begründetes Feedback: Stimmt das Ergebnis und lässt es sich einer Variablen zuweisen, hast Du eine wiederverwendbare Funktion. Wird lediglich ein Wert ausgegeben, fehlt möglicherweise die korrekte Rückgabe.

Lerneinheit 2: Der Ausbildungsfall

Fiktive Förderband-Prüfstation

Eine erfundene Ausbildungswerkstatt möchte Messwerte eines Förderbandmodells auswerten.

Die Software erhält zwei Werte:

Weg in Metern und Zeit in Sekunden.

Daraus berechnet sie die Geschwindigkeit:

$v = \frac{s}{t}$

Die Prüfgrenze beträgt im fiktiven Beispiel 1,5 m/s. Dieser Wert ist ausschließlich eine Übungsannahme und kein allgemeiner Sicherheitsgrenzwert für Förderanlagen.

Foto eines photoelektrischen Sensors als Anschauung. Die Übung liest keine Sensoren aus.

Messdaten untersuchen

Alle Messwerte sind erfunden.

Messung	Weg in m	Zeit in s	Tempo in m/s	Status
A	12	10	1,2	OK
B	9	6	1,5	OK
C	10	5	2,0	PRUEFEN

Visualisierung: Ein Block steht für 0,1 m/s.

A  ████████████          1,2  OK
B  ███████████████       1,5  OK
C  ████████████████████  2,0  PRUEFEN

Grenze: 1,5 m/s

Erkenntnis: Der Grenzwert gehört als Parameter in die Prüffunktion. So kann dieselbe Software mit unterschiedlichen fiktiven Prüfgrenzen getestet werden, ohne ihre Berechnungslogik umzuschreiben.

Schnittstellen festlegen

Funktion	Eingaben	Rückgabe	Fehlerregel
`berechne_tempo`	`weg_m`, `zeit_s`	Geschwindigkeit als `float`	Weg nicht negativ, Zeit positiv
`bewerte_tempo`	`tempo_m_s`, `grenze_m_s`	`OK` oder `PRUEFEN`	Tempo nicht negativ, Grenze positiv
`pruefe`	Weg, Zeit, Grenze	Tupel aus Tempo und Status	Fehler aus den Teilfunktionen

Für alle Eingaben werden endliche Zahlen vorausgesetzt. Ungültige Zahlen werden mit ValueError zurückgewiesen.

Eine klare Schnittstelle beschreibt Namen, Eingaben, Einheiten, Rückgabe und Fehlerverhalten.

Lerneinheit 3: Saubere Funktionen programmieren

Lokales Programm: pruefstation.py

Erstelle die Datei pruefstation.py in Deinem Lernordner und übernimm den vollständigen Code.

from math import isfinite

def berechne_tempo(weg_m: float, zeit_s: float) -> float:
    """Berechnet die Geschwindigkeit in m/s aus Weg und Zeit."""
    if not isfinite(weg_m) or not isfinite(zeit_s):
        raise ValueError("Weg und Zeit muessen endlich sein.")
    if weg_m < 0 or zeit_s <= 0:
        raise ValueError("Weg >= 0 und Zeit > 0 erforderlich.")
    return weg_m / zeit_s

def bewerte_tempo(tempo_m_s: float, grenze_m_s: float) -> str:
    """Liefert einen rein informativen Pruefstatus."""
    if not isfinite(tempo_m_s) or not isfinite(grenze_m_s):
        raise ValueError("Tempo und Grenze muessen endlich sein.")
    if tempo_m_s < 0 or grenze_m_s <= 0:
        raise ValueError("Tempo >= 0 und Grenze > 0 erforderlich.")
    return "OK" if tempo_m_s <= grenze_m_s else "PRUEFEN"

def pruefe(weg_m: float, zeit_s: float,
           grenze_m_s: float) -> tuple[float, str]:
    tempo = berechne_tempo(weg_m, zeit_s)
    return tempo, bewerte_tempo(tempo, grenze_m_s)

if __name__ == "__main__":
    messungen = [(12.0, 10.0), (9.0, 6.0), (10.0, 5.0)]
    for weg, zeit in messungen:
        tempo, status = pruefe(weg, zeit, 1.5)
        print(f"{weg:.1f} m / {zeit:.1f} s -> {tempo:.1f} m/s: {status}")

Starte in einem lokalen Terminal im Lernordner:

python pruefstation.py

Erwartete Ausgabe:

12.0 m / 10.0 s -> 1.2 m/s: OK
9.0 m / 6.0 s -> 1.5 m/s: OK
10.0 m / 5.0 s -> 2.0 m/s: PRUEFEN

Warum drei Funktionen?

Die Darstellung zeigt, wie Funktionen hintereinander arbeiten können.

weg_m + zeit_s
      |
      v
berechne_tempo
      |
      v
   tempo_m_s ---- grenze_m_s
      |                |
      +--------+-------+
               |
               v
         bewerte_tempo
               |
               v
        OK / PRUEFEN

Die erste Funktion berechnet, die zweite bewertet, die dritte verknüpft beide Aufgaben.

Diesen Entwurf nennt man modulare Programmierung.

Wichtig: Der zurückgegebene Status ist nur eine Information innerhalb der Simulation. Er darf nicht unmittelbar als Maschinenfreigabe oder Sicherheitsentscheidung eingesetzt werden.

Entscheidungslogik

Allgemeines Beispiel eines Programmablaufplans.

Die entscheidende Bedingung aus unserem Programm lautet:

return "OK" if tempo_m_s <= grenze_m_s else "PRUEFEN"

Wenn die Geschwindigkeit genau dem Grenzwert entspricht, ist der Status OK. Das folgt aus dem Vergleichsoperator <=.

Lerneinheit 4: Lokal und isoliert testen

Automatische Unit-Tests

Ein Kontrollflussgraph hilft dabei, unterschiedliche Verzweigungen eines Programms zu untersuchen.

Erstelle neben pruefstation.py eine zweite Datei namens test_pruefstation.py.

import unittest
from pruefstation import berechne_tempo, bewerte_tempo, pruefe

class TestPruefstation(unittest.TestCase):
    def test_normalfall(self):
        self.assertAlmostEqual(berechne_tempo(12.0, 10.0), 1.2)

    def test_grenze_ist_erlaubt(self):
        self.assertEqual(bewerte_tempo(1.5, 1.5), "OK")

    def test_ueberschreitung(self):
        self.assertEqual(pruefe(10.0, 5.0, 1.5), (2.0, "PRUEFEN"))

    def test_zeit_null(self):
        with self.assertRaises(ValueError):
            berechne_tempo(3.0, 0.0)

    def test_negativer_weg(self):
        with self.assertRaises(ValueError):
            berechne_tempo(-1.0, 2.0)

    def test_nicht_endliche_zahl(self):
        with self.assertRaises(ValueError):
            bewerte_tempo(float("inf"), 1.5)

if __name__ == "__main__":
    unittest.main()

Lokal starten:

python -m unittest -v test_pruefstation.py

Erwartetes Testergebnis bei unverändertem Code:

Ran 6 tests
OK

Die tatsächliche Ausgabe enthält zusätzlich Testnamen und Laufzeitangaben.

Warum testen wir Grenzwerte? Fehler treten häufig an Grenzen auf: genau auf dem Grenzwert, knapp darüber oder bei ungültigen Eingaben.

Interaktives lokales Lernlabor

Du kannst eigene fiktive Werte eingeben und die Rückmeldungen unmittelbar ausprobieren.

Erstelle dafür eine dritte Datei namens lern_labor.py.

from pruefstation import pruefe

print("Lokales Lernlabor mit fiktiven Werten. Leere Zeile beendet.")
while True:
    zeile = input("Weg in m und Zeit in s (z. B. 12 10): ").strip()
    if not zeile:
        break
    try:
        weg_text, zeit_text = zeile.split()
        weg, zeit = float(weg_text), float(zeit_text)
        tempo, status = pruefe(weg, zeit, 1.5)
        print(f"Tempo: {tempo:.2f} m/s | Status: {status}")
    except ValueError:
        print("Ungueltige Eingabe: zwei endliche Zahlen, Weg >= 0, Zeit > 0.")

Starte es lokal:

python lern_labor.py

Teste nacheinander die Eingaben 12 10, 9 6, 10 5 und 3 0. Mit einer leeren Eingabe beendest Du das Labor.

Die Programmdateien benötigen keine Netzwerkverbindung. Sie lesen nur Deine Tastatureingaben, verarbeiten sie im Speicher und zeigen Ergebnisse im lokalen Terminal.

Begründetes Testfeedback

Eingabe	Erwartung	Begründung
12 und 10	1,2 – OK	Das Tempo liegt unter der Grenze.
9 und 6	1,5 – OK	Die Grenze darf in diesem Übungsmodell erreicht werden.
10 und 5	2,0 – PRUEFEN	Das berechnete Tempo überschreitet die Grenze.
3 und 0	Eingabefehler	Eine Zeit von null ist für diese Division unzulässig.
-1 und 2	Eingabefehler	Ein negativer zurückgelegter Weg ist im Modell nicht erlaubt.

Vertiefung auf Englisch: Unit Testing in Python using unittest framework – Basic Introduction and How to Write Tests. Kanal: The Theory Of Code.

Gestufter Lernpfad mit Feedback

Basisaufgabe: Eine Funktion beschreiben

Auftrag: Ergänze für berechne_tempo eine kurze Schnittstellenbeschreibung mit Parametern, Einheiten, Rückgabetyp und einer Vorbedingung.

Hilfe 1: Schaue auf die Funktionsdefinition und die Dokumentationszeichenkette.

Hilfe 2: Formuliere, warum zeit_s positiv sein muss.

Feedback: Eine vollständige Beschreibung nennt die Eingaben Weg in Metern und Zeit in Sekunden sowie das Ergebnis in m/s. Die Vorbedingung verhindert eine Division durch null. Dadurch wissen andere Programmierende, wie sie die Funktion korrekt aufrufen können.

Anwendungsaufgabe: Eine zweite Funktion nutzen

Auftrag: Verwende pruefe für drei weitere erfundene Messungen mit einer neuen Grenze von 2.0 m/s. Dokumentiere die Ergebnisse in einer Tabelle.

Hilfe 1: Übergib die neue Grenze als drittes Argument.

Hilfe 2: Vergleiche einen Wert unter der Grenze, einen genau auf der Grenze und einen darüber.

Feedback: Die korrekte Lösung benötigt keine Änderung an berechne_tempo. Genau darin besteht der Vorteil einer parametrisierten, wiederverwendbaren Schnittstelle.

Transferaufgabe: Einen Warnbereich ergänzen

Auftrag: Entwickle eine zusätzliche Funktion bewerte_mit_warnung. Sie soll unter 90 Prozent der Grenze OK, ab 90 Prozent bis einschließlich der Grenze WARNUNG und oberhalb der Grenze PRUEFEN zurückgeben.

Hilfe 1: Prüfe die Überschreitung vor dem Warnbereich.

Hilfe 2: Berechne zunächst warnschwelle = 0.9 * grenze_m_s und behalte die Eingabeprüfung bei.

Feedback: Bei einer Grenze von 1,5 m/s beginnt die Warnung bei 1,35 m/s. Ein Tempo von 1,5 m/s ergibt jetzt WARNUNG, 1,6 m/s ergibt PRUEFEN. Die neue Funktion lässt die ursprüngliche Schnittstelle unverändert; dadurch bleibt vorhandener Programmcode kompatibel. Für einen praktischen Einsatz wären weitere Anforderungen und Sicherheitsprüfungen notwendig.

Interaktive Aufgaben

Quiz: Teste Dein Wissen

Welches Schlüsselwort definiert in Python eine Funktion? (def) (!function) (!start) (!define)

Wie heißt ein Name für eine erwartete Eingabe in der Funktionsdefinition? (Parameter) (!Ergebnis) (!Ausgabe) (!Kommentar)

Was ist ein Argument beim Funktionsaufruf? (Ein konkret übergebener Wert) (!Der Name der Programmdatei) (!Ein automatischer Testbericht) (!Ein Kommentar im Quelltext)

Wozu dient return? (Zur Rückgabe eines Wertes) (!Zum Neustart des Computers) (!Zum Erstellen eines Netzwerks) (!Zum dauerhaften Speichern einer Datei)

Was ergibt die Division von zwölf Metern durch zehn Sekunden? (1,2 Meter pro Sekunde) (!12 Meter pro Sekunde) (!10 Meter pro Sekunde) (!120 Meter pro Sekunde)

Welche Zeitangabe muss unsere Berechnungsfunktion zurückweisen? (Null Sekunden) (!Zehn Sekunden) (!Zwei Sekunden) (!Eine Sekunde)

Welcher Status gilt im Beispiel für exakt 1,5 Meter pro Sekunde bei einer Grenze von 1,5 Meter pro Sekunde? (OK) (!PRUEFEN) (!FEHLER) (!UNBEKANNT)

Warum teilen wir Berechnung und Bewertung in getrennte Funktionen auf? (Weil beide Bausteine getrennt getestet und wiederverwendet werden können) (!Weil dadurch keine Parameter mehr benötigt werden) (!Weil Python nur eine Berechnung je Datei erlaubt) (!Weil sonst keine Zahlen verwendet werden dürfen)

Welches Python-Modul wird im Kurs für automatische Tests genutzt? (unittest) (!socket) (!random) (!tkinter)

Welche Arbeitsumgebung ist für das Lernlabor vorgesehen? (Ein lokaler Rechner mit fiktiven Daten) (!Eine fremde Produktionssteuerung) (!Ein öffentlich erreichbarer Betriebsserver) (!Ein unbekanntes Kundennetzwerk)

Memory

Funktionsparameter	Erwarteter Eingabename in der Definition
Aufrufargument	Konkret übergebener Wert
Rückgabewert	Ergebnis einer Funktion
Schnittstelle	Festgelegte Regeln für Ein- und Ausgaben
Vorbedingung	Voraussetzung für gültige Eingaben
Unit-Test	Automatische Prüfung eines einzelnen Programmbausteins
Modularisierung	Zerlegung in getrennt nutzbare Bausteine

Drag and Drop

Ordne die richtigen Begriffe zu.	Aufgabe
berechne_tempo	Berechnung
bewerte_tempo	Klassifikation
pruefe	Zusammensetzung
ValueError	Fehlersignal
unittest	Testautomatisierung
return	Wertrückgabe

Kreuzworträtsel

Parameter	Wie heißt ein erwarteter Eingabename einer Funktion?
Argument	Wie heißt der konkrete Wert bei einem Funktionsaufruf?
Ergebnis	Was liefert eine berechnende Funktion mit return zurück?
Schnittstelle	Welcher Begriff bezeichnet die festgelegten Regeln für Ein- und Ausgaben?
Grenzwert	Wie heißt die festgelegte Grenze für eine zulässige Messgröße?
Ausnahme	Was löst eine Funktion bei einer ungültigen Eingabe aus?

LearningApps

Optionale externe Lernmaterialsuche. Das eigentliche Programmierlabor wird ausschließlich lokal ausgeführt. Gib auf externen Lernseiten keine Betriebsdaten oder Zugangsdaten ein.

Lückentext

Eine Python-Funktion wird mit dem Schlüsselwort

eingeleitet.

Ein erwarteter Eingabename in einer Funktionsdefinition heißt

.

Ein konkreter beim Aufruf übergebener Wert heißt

.

Eine berechnende Funktion gibt ihren Wert mit

zurück.

Eine Funktion ohne ausdrückliche Rückgabe liefert in Python normalerweise

zurück.

Die Geschwindigkeit ergibt sich aus dem Weg geteilt durch die

.

Der Datentyp für Dezimalzahlen heißt in Python

.

Eine unzulässige Eingabe signalisiert unser Programm mit

.

Die Grenze der fiktiven Prüfstelle beträgt

Meter pro Sekunde.

Die Aufteilung eines Programms in getrennte Bausteine nennt man

.

Die automatische Prüfung einzelner Programmbausteine heißt

.

Die Beschreibung von Eingaben und Ergebnissen gehört zur

.

Ein Test genau an einer festgelegten Grenze untersucht einen

.

Die Wiederverwendung einer Funktion vermeidet unnötige

.

Offene Aufgaben

Leicht

Basis – Funktionssteckbrief: Gestalte eine Lernkarte mit Funktionsname, Parametern, Rückgabewert und einer kurzen Beispielrechnung.
Basis – Parameter erkennen: Markiere die Parameter und Argumente in einem eigenen kurzen Python-Programm und erkläre den Unterschied.
Basis – Einheiten prüfen: Erstelle eine Tabelle mit fünf erfundenen Weg- und Zeitwerten. Berechne die Geschwindigkeit und schreibe die Einheit dazu.
Basis – Abläufe zeichnen: Zeichne eine kleine Grafik vom Funktionsaufruf über die Berechnung bis zur Rückgabe.

Standard

Anwendung – Programm strukturieren: Schreibe ein eigenes kleines Programm mit mindestens zwei getrennten Funktionen und begründe ihre Aufgabenverteilung.
Anwendung – Fehler untersuchen: Teste lokal mehrere ungültige Eingaben. Dokumentiere, welche Ausnahmen auftreten sollen und warum.
Anwendung – Testfälle ergänzen: Ergänze drei zusätzliche automatische Tests für die fiktive Prüfstation und erläutere deren erwartete Ergebnisse.
Anwendung – Ergebnisse darstellen: Erstelle mit erfundenen Daten ein Balkendiagramm für sechs Messungen und kennzeichne die angenommene Grenze.

Schwer

Transfer – Code verbessern: Überarbeite ein selbst erstelltes längeres Programm so, dass wiederholte Berechnungen in Funktionen ausgelagert werden. Vergleiche Vorher und Nachher.
Transfer – Anderen Anwendungsfall entwickeln: Übertrage die Schnittstellenidee auf eine lokale Simulation für Temperaturüberwachung, Materialverbrauch oder Durchflussberechnung.
Transfer – Schnittstellen dokumentieren: Verfasse eine kleine technische Dokumentation mit Einheiten, Vorbedingungen, Rückgabetypen, Beispielen und Fehlerfällen.
Transfer – Sicherheitskonzept: Erstelle ein Konzept für einen isolierten Testplatz. Begründe, warum fremde Netze, reale Anlagen, vertrauliche Messdaten und Zugangsdaten ausgeschlossen bleiben.

Lernkontrolle

Funktionsentwurf beurteilen: Ein Programm enthält dieselbe Geschwindigkeitsberechnung an vier Stellen. Erkläre, welche Probleme dadurch bei Änderungen entstehen und wie ein Funktionsentwurf diese reduziert.
Schnittstelle verbessern: Eine Funktion erwartet eine Zahl ohne Einheit und liefert lediglich True oder False. Entwickle eine verständlichere Schnittstelle für einen technischen Prüfbericht und begründe Deine Entscheidung.
Fehlerfolgen analysieren: Ein Programm akzeptiert eine negative Zeitangabe. Untersuche mögliche Folgen für Berechnung und Bewertung. Entwickle eine passende Eingabeprüfung.
Teststrategie entwickeln: Stelle für eine neue Grenzwertfunktion mindestens fünf Testfälle zusammen. Begründe, warum Normalwerte allein nicht ausreichen.
Transfer planen: Eine zweite Ausbildungsabteilung möchte dieselbe Berechnung mit einer anderen Prüfgrenze nutzen. Erkläre, welche Teile wiederverwendet werden können und welche angepasst werden müssen.
Qualität kritisch bewerten: Diskutiere, warum sechs erfolgreiche lokale Unit-Tests noch nicht beweisen, dass eine reale Industrieanlage sicher betrieben werden kann.

Lernnachweis

Für einen erfolgreichen Lernnachweis erstellst Du ein kleines, vollständig lokales Projekt mit fiktiven Daten.

Funktionsdefinitionen: Mindestens zwei sinnvoll benannte Funktionen mit klaren Aufgaben.
Schnittstellen: Dokumentierte Parameter, Einheiten, Rückgabewerte und Fehlerregeln.
Wiederverwendung: Nachweis, dass eine Funktion mehrfach mit unterschiedlichen Eingaben aufgerufen wird.
Fehlerbehandlung: Sinnvolle Reaktion auf ungültige oder nicht endliche Zahlen.
Tests: Mindestens sechs nachvollziehbare Testfälle einschließlich eines Grenzwerts und eines Fehlerfalls.
Dokumentation: Beschreibung der erwarteten Ergebnisse und eine begründete Erklärung des Programmentwurfs.
Sicherheitsabgrenzung: Bestätigung, dass ausschließlich fiktive Daten lokal verarbeitet und keine fremden oder produktiven Systeme angesprochen werden.

Bewertungsvorschlag:

Kriterium	Anteil
Funktionalität und fachliche Richtigkeit	30 %
Klarheit der Schnittstellen	25 %
Testqualität und Fehlerbehandlung	25 %
Wiederverwendbarkeit und Dokumentation	15 %
Nachvollziehbare Sicherheitsabgrenzung	5 %

OERs zum Thema

Wikipedia: Funktion in der Programmierung

Geprüfte Fachquellen

Python-Dokumentation – Funktionen definieren: Offizielle Erklärung von Funktionsdefinitionen, Parametern, Argumenten und Rückgabewerten.
Python-Dokumentation – unittest: Offizielle Beschreibung automatischer Tests und der Prüfmethoden.
Wikipedia – Funktion in der Programmierung: Hintergrundwissen zu Funktionen, Rückgabewerten und Wiederverwendung.
Wikipedia – Unterprogramm: Bedeutung von Unterprogrammen für Programmstruktur und Wartbarkeit.

Mediennachweise und Nutzungsrechte

Die folgenden Dateien wurden anhand ihrer Wikimedia-Commons-Dateiseiten ausgewählt. Die Lizenzangaben beziehen sich jeweils auf die konkrete Datei.

Medium	Urheber	Angegebene Lizenz
Förderband Rübeland	Leonhard Lenz	CC0 1.0
Blackbox	Frap	Gemeinfrei
Funktionsmaschine	Wvbailey	Gemeinfrei
Photoelektrischer Sensor	Honmingjun	CC BY-SA 3.0
Funktionsverkettung	Kismalac	CC0 1.0
Programmablaufplan	Kayau	CC BY-SA 3.0
Kontrollflussgraph	MartinThoma	CC BY 3.0

Bei CC-BY- und CC-BY-SA-Medien sind die Namensnennung und die weiteren jeweiligen Lizenzbedingungen zu beachten. Bei Bearbeitungen können zusätzliche Bedingungen gelten.

Verwendete YouTube-Videos:

Python Funktionen – Python Tutorial deutsch – PyJa.
Python Tutorial deutsch – Funktionen mit Rückgabewert – Programmieren Starten.
Unit Testing in Python using unittest framework – The Theory Of Code.

Die Videos werden über ihre öffentlichen YouTube-Adressen eingebunden. Eine freie Lizenz für die Videoinhalte wird nicht behauptet. Die Urheberrechte verbleiben bei den jeweiligen Rechteinhabern. Ein Onlinezugang ist für die optionalen Videos und externen Lernmaterialien nötig, nicht für die Python-Übungen.

Hinweis zur fachlichen Sicherheit: Der Kurs vermittelt Grundlagen von Softwarefunktionen und lokalen Unit-Tests. Er stellt keine Anleitung zur Inbetriebnahme, Steuerung oder sicherheitstechnischen Freigabe realer Anlagen dar.