Glanz: AI MOOC Plugin 9c45701abb59e456dac2e391ddaadf0b

2026-10-21T22:12:02Z

AI MOOC Plugin 9c45701abb59e456dac2e391ddaadf0b

Neue Seite

{{T}}
{{BR}}
= Einleitung =

Du entwickelst einen '''modularen technischen Prüfrechner''': ein lokales Python-Programm, das ausschließlich erfundene Messwerte eines ungefährlichen Lehrbauteils prüft. Du erhältst zu jeder Entscheidung einen Status und eine begründende Erklärung. Das Programm steuert keine reale Maschine und darf keine Sicherheits- oder Qualitätsfreigabe erzeugen.

'''Zielgruppe:''' Auszubildende im 1. oder 2. Ausbildungsjahr. '''Voraussetzung:''' Grundverständnis für Dateien und technische Einheiten; Programmiererfahrung wird nicht vorausgesetzt. Für alle Übungen genügen ein frei verfügbarer lokaler Python-Interpreter (ab Python 3.10), ein Texteditor und Papier; ein kostenpflichtiges KI-Konto oder Internet ist nicht nötig.

'''Aktivierung des Vorwissens:''' Öffne die [https://moocwiki.org/index.php?curid=60512 bestehende MOOCwiki-Grundlage], falls sie bei dir verfügbar ist, und erkläre kurz, was eine Datei, eine Eingabe, eine Ausgabe und eine Maßeinheit sind. Die Seite war beim Recherchezugriff nicht abrufbar; ihr genauer Inhalt ist daher nicht überprüft und wird hier nicht behauptet. Anschließend gehst du einen Schritt weiter: von einfachen Werten zu Kontrollstrukturen, Funktionen, Datenstrukturen und nachprüfbarer Programmlogik.

'''Lernziele:''' Du wählst passende Datentypen, setzt if/elif/else und for gezielt ein, teilst Programme in Funktionen auf und weist drei verbindliche Prüffälle nach: Normalwert 10.0 mm, unterer Grenzwert 9.5 mm und leere Eingabe. Du kannst einen zusätzlichen Fehlerfall fachlich erklären. Deine Entscheidungen folgen einer '''deterministischen''' Regel: Gleiche Eingaben liefern bei unveränderten Grenzen stets das gleiche Ergebnis. Unsere Modellgrenzen sind didaktisch erfunden und keine technischen Normwerte.

{{BR}}
= Variablen und Datenstrukturen =

{{BR}}
== Benannte Werte und Typen ==

Eine [[Variable (Programmierung)|Variable]] ist ein Name, der auf einen gespeicherten Wert verweist. Die Zuweisung '''sollwert = 10.0''' verbindet den Namen mit der Zahl. Ein [[Datentyp]] beschreibt, welche Art von Daten vorliegt. In Python heißen wichtige Typen '''int''' (ganze Zahl), '''float''' (Gleitkommazahl), '''str''' (Text), '''bool''' (Wahrheitswert) und '''NoneType''' für einen fehlenden Wert '''None'''. Null ist dagegen eine vorhandene Zahl, nicht automatisch ein leerer Messwert.

Eine technische Zahl braucht eine festgelegte Einheit. Alle synthetischen Beispiele verwenden mm. Eine Eingabe als Text "10.0" wird erst nach bewusster Umwandlung zu einer Zahl. Python führt diese Umwandlung nicht für beliebige Zeichenketten stillschweigend durch.

[[File:CPT-programming-variable.svg|390px|frameless|center|alt=Ein Name ist grafisch einem Wert zugeordnet]]
''Bildtext: Schematische Zuordnung zwischen Variablenname und Wert; die Commons-Grafik illustriert ein anderes Sprachbeispiel als Python. Ohne Bild: Stelle dir eine beschriftete Schublade für einen Wert vor.''

{{BR}}
== Liste und Dictionary ==

Eine [[Liste (Datenstruktur)|Liste]] enthält Werte in einer festen Reihenfolge, die mit Index 0 beginnt. Ein '''Dictionary''' weist Schlüsseln jeweils einen Wert zu. Dadurch kannst du erst mehrere synthetische Eingaben verwalten und danach pro Eingabe ein strukturiertes Prüfergebnis ausgeben.

werte = [10.0, 9.5, "", 10.6]
grenzen = {"unten": 9.5, "oben": 10.5}
print(werte[0])
print(grenzen["oben"])

'''Verständnisfrage:''' Warum steht ein leerer String in der Liste? Weil gerade auch der Fehlerfall reproduzierbar getestet werden muss. Er darf nicht aus der Liste entfernt oder wie ein gemessener Nullwert behandelt werden.

[[File:Google Python Class Lecture1-2 Pic1.jpg|500px|frameless|center|alt=Englisch beschriftetes Diagramm einer Listenstruktur]]
''Bildalternative: Mehrere Elemente sind in einer Folge angeordnet; ein Index bezeichnet ihre Position. Die Datei ist englisch beschriftet.''

{{BR}}
== Video zur Wiederholung ==

{{#ev:youtube|https://www.youtube.com/watch?v=RBpK8C3N-Y8|500|center}}
''Deutschsprachiges Python-Tutorial, Programmieren Starten (2021). Gemäß Videobeschreibung: Variablen ab 41:40, Bedingungen ab 1:41:44, Listen ab 2:15:04, Funktionen ab 2:38:42. Offline: sämtliche Begriffe und Beispiele stehen im Lerntext; aktuelle Videowiedergabe ist nicht garantiert.''

{{BR}}
= Kontrollstrukturen: verständliche Entscheidungen =

{{BR}}
== Sequenz, Auswahl und Schleife ==

[[Kontrollstruktur|Kontrollstrukturen]] legen fest, welche Programmschritte wann ausgeführt werden. '''Sequenz''' bedeutet nacheinander. '''if''' führt Anweisungen nur aus, wenn eine Bedingung wahr ist. '''elif''' prüft eine weitere Bedingung; '''else''' übernimmt den restlichen Fall. '''for''' verarbeitet nacheinander Einträge einer Liste. '''while''' läuft, solange eine Bedingung erfüllt ist; dabei muss ein sinnvoller Abbruch möglich sein.

Bei einer synthetischen Prüfung gilt: '''untere Grenze 9.5 mm, obere Grenze 10.5 mm, beide einschließlich'''. Somit sind 10.0 (Normalwert) und 9.5 (Grenzwert) zulässig; 10.6 liegt außerhalb. Eine fehlende Eingabe kann nicht durch einen Vergleich von Messzahlen bewertet werden.

Für einen bereits geprüften Zahlenwert genügt:

if 9.5 <= wert <= 10.5:
print("IM_BEREICH")
else:
print("AUSSERHALB")

'''Fachlicher Hinweis:''' Das ist nur die Kernentscheidung. Ein leerer Text oder "abc" muss vorher abgefangen werden. Die Grenze ist eingeschlossen, weil <= verwendet wird. Wer versehentlich das Vergleichszeichen durch < ersetzt, verändert die Bedeutung des Programms.

[[File:Flowchart de.svg|350px|frameless|center|alt=Programmablaufplan mit Start, Bedingung, alternativen Wegen und Fortsetzung]]
''Bildalternative: Von einer Startmarke verläuft der Ablauf zu einer Entscheidungsraute, teilt sich in zwei Wege und wird anschließend zusammengeführt. Das allgemeine Diagramm ist keine reale Maschinensteuerung.''

{{BR}}
== Kontrollfluss Schritt für Schritt lesen ==

Prüfe die Reihenfolge: Eingabe ansehen, fehlenden Wert unterscheiden, Text in Zahl umwandeln, endlichen Zahlenwert prüfen, Grenzen vergleichen, Status begründen. Schreibe für die drei Eingaben '''10.0''', '''9.5''' und '''""''' jeweils auf, welcher Zweig erreicht wird. Ein Schleifendurchlauf ändert dabei nur den aktuell betrachteten Listeneintrag, nicht automatisch die Regelgrenzen.

werte = [10.0, 9.5, None]
for wert in werte:
print("Jetzt:", repr(wert))

'''Anspruchsvolle Vertiefung:''' Begründe, warum eine for-Schleife für eine vorliegende Liste übersichtlicher ist als eine while-Schleife mit von Hand verwaltetem Zähler und Abbruchbedingung.

[[File:DRAKON algorithm animation.gif|500px|frameless|center|alt=Eine Animation hebt nacheinander Schritte eines Algorithmusdiagramms hervor]]
''Animation als Vergleich, nicht als Python-Ausführungsansicht: Schritt für Schritt wird ein DRAKON-Diagramm hervorgehoben. Auf Commons können große Vorschaubilder statisch sein. Ohne Animation: Markiere Start, Prüfung, Abzweig und Ende nacheinander auf Papier.''

{{BR}}
= Funktionen als Module =

{{BR}}
== Parameter und Rückgabe ==

Eine [[Funktion (Programmierung)|Funktion]] fasst eine Aufgabe unter einem Namen zusammen. '''def''' definiert sie. '''Parameter''' stehen für die Eingaben; '''return''' liefert ein Ergebnis zurück. Durch [[Modularisierung]] werden Eingabeprüfung, Grenzvergleich, Anzeige und Tests separat verständlich und wartbar.

def im_bereich(wert, untergrenze, obergrenze):
return untergrenze <= wert <= obergrenze

print(im_bereich(10.0, 9.5, 10.5))

'''Grenze des Beispiels:''' Die Funktion setzt bereits einen gültigen Zahlenwert sowie korrekte, geordnete Grenzen voraus. Mit unzulässiger Eingabe oder vertauschten Grenzen ist der Funktionsvertrag verletzt. Im fertigen Lernprodukt ist die Eingabeprüfung deshalb ein eigenes Modul.

{{BR}}
== Strukturierte Ergebnisse und nachvollziehbarer Grund ==

Ein '''Funktionsvertrag''' legt fest, was hineingegeben werden darf und was zurückkommt. Unser Prüfkern gibt ein Dictionary mit den Schlüsseln '''status''', '''wert''' und '''grund''' zurück. Das Ergebnis besteht nicht nur aus „bestanden“ oder „nicht bestanden“, sondern nennt einen überprüfbaren Grund.

Das hilft später beim Testen: Erwartung und tatsächlicher Status werden verglichen. Die Kernlogik ist '''deterministisch''', weil keine Zufallsentscheidung und kein generatives Sprachmodell die Grenzen oder Bewertungen verändern. Trotzdem kann eine Regel falsch gewählt sein; Reproduzierbarkeit beweist allein noch keine fachliche Richtigkeit.

{{BR}}
== Zweites Lernvideo ==

{{#ev:youtube|https://www.youtube.com/watch?v=e6vPt_e9sRw|500|center}}
''Deutschsprachiger Python-Kurs, Fabian Rappert / Data Science Institute (2024); Datensatz mit Kapiteln zu Bedingungen ab 1:15:40, Listen ab 1:33:53, Dictionaries ab 2:52:00 und Funktionen ab 3:10:26. Die Video-Metadaten waren verfügbar, die Wiedergabeseite beim erneuten Abruf nicht erreichbar. Die Anleitung unten ist vollständig ohne Video bearbeitbar.''

{{BR}}
= Praxisprojekt: modularer technischer Prüfrechner =

{{BR}}
== Synthetischer Modellfall ==

Das fiktive Lehrbauteil hat eine festgelegte Modelllänge von 10.0 mm. Für die reine Unterrichtssimulation akzeptieren wir Werte von 9.5 bis 10.5 mm einschließlich der Grenzen. Es werden keine Sensordaten gelesen und weder reale Prüfmittel noch industrielle Steuerungen angesprochen.

{| class="wikitable"
! Eingabe !! Erwarteter Status !! Begründung
|-
| 10.0 || IM_BEREICH || Normalwert liegt innerhalb der Grenzen
|-
| 9.5 || IM_BEREICH || Unterer Grenzwert ist eingeschlossen
|-
| 10.5 || IM_BEREICH || Oberer Grenzwert ist eingeschlossen
|-
| 10.6 || AUSSERHALB || Obergrenze überschritten
|-
| "" || FEHLT || Es ist kein Messwert vorhanden
|-
| "abc" || UNGUELTIG || Text ist keine umwandelbare Zahl
|}

'''Geführter Auftrag:''' Formuliere zuerst Soll-Ergebnisse für Normalwert, Grenzwert und leere Eingabe. Führe anschließend den Code aus und kennzeichne die entscheidende Codezeile zu jeder Ausgabe.

{{BR}}
== Quelltext lokal ausführen ==

Speichere alle folgenden Zeilen unter dem Dateinamen '''pruefrechner.py'''. Die eingerückten Zeilen bilden Python-Blöcke. Starte im Dateiverzeichnis den Befehl '''python pruefrechner.py''' oder '''python3 pruefrechner.py'''.

import math

UNTERGRENZE = 9.5
OBERGRENZE = 10.5

def normalisieren(roher_wert):
"""Prueft fehlende, ungueltige und endliche Werte."""
if roher_wert is None or roher_wert == "":
return None, "FEHLT"
if isinstance(roher_wert, bool):
return None, "UNGUELTIG"
try:
zahl = float(roher_wert)
except (TypeError, ValueError, OverflowError):
return None, "UNGUELTIG"
if not math.isfinite(zahl):
return None, "UNGUELTIG"
return zahl, "OK"

def pruefen(roher_wert):
zahl, eingabe = normalisieren(roher_wert)
if eingabe == "FEHLT":
return {"status": "FEHLT", "wert": None,
"grund": "Kein Messwert angegeben."}
if eingabe == "UNGUELTIG":
return {"status": "UNGUELTIG", "wert": None,
"grund": "Keine gueltige endliche Zahl."}
if UNTERGRENZE <= zahl <= OBERGRENZE:
return {"status": "IM_BEREICH", "wert": zahl,
"grund": "Innerhalb beider Grenzen einschliesslich Rand."}
return {"status": "AUSSERHALB", "wert": zahl,
"grund": "Ausserhalb des vorgegebenen Modellbereichs."}

def anzeigen(ergebnis):
print(ergebnis["status"] + ": " + ergebnis["grund"])

def hauptprogramm():
messwerte = [10.0, 9.5, 10.5, 10.6, "", "abc", None]
for eintrag in messwerte:
print("Eingabe:", repr(eintrag))
anzeigen(pruefen(eintrag))

if __name__ == "__main__":
hauptprogramm()

'''So arbeitet das Programm:''' normalisieren erkennt fehlende Daten, prüft die Umwandlung und verwirft auch NaN und Unendlich. pruefen erzeugt den fachlichen Status und eine Begründung. anzeigen ist ausschließlich für die Ausgabe zuständig. hauptprogramm iteriert mit einer for-Schleife durch synthetische Beispiele. Der abschließende Namensvergleich verhindert, dass die Beispielausgaben schon beim Import als Modul gestartet werden.

'''Wichtige Präzision:''' True wird ausdrücklich als bool verworfen; Python behandelt bool sonst in manchen Zahlenkontexten wie eine Zahl. "10,0" mit Komma gilt in diesem bewusst klar definierten Eingabevertrag als ungültig; als Dezimaltrennzeichen wird der Punkt verwendet. Keine Eingabe führt zu einer realen Freigabe.

{{BR}}
== Drei Pflichtprüfungen erklären ==

'''Normalwert:''' Eingabe 10.0 → IM_BEREICH. Beide Vergleiche treffen zu. '''Grenzwert:''' Eingabe 9.5 → IM_BEREICH. Das Zeichen <= umfasst auch die untere Grenze. '''Leerer Wert:''' Eingabe "" → FEHLT. Der Wert wird vor der Zahlenkonvertierung abgefangen und nicht als Nullzahl beurteilt.

Zusatztests: 10.5 → IM_BEREICH; 10.6 → AUSSERHALB; "abc" → UNGUELTIG; float("nan") → UNGUELTIG. '''Fehler gezielt finden:''' Wenn du <= testweise zu < veränderst, wird 9.5 falsch als AUSSERHALB eingestuft. Der genaue Fehler liegt in der Ausschließung des Grenzwerts. Stelle anschließend das Original wieder her.

{{BR}}
= Testen, Transfer und Zukunftsbezug =

{{BR}}
== Automatisierte Lernkontrollen im Programm ==

Lege im selben Verzeichnis '''test_pruefrechner.py''' an. Die Tests nutzen nur die lokale Python-Standardbibliothek und kontrollieren unter anderem die drei Pflichtfälle. '''assert''' schlägt fehl, wenn die angegebene Aussage falsch ist.

from pruefrechner import pruefen

def test_normalwert():
assert pruefen(10.0)["status"] == "IM_BEREICH"

def test_grenzwert():
assert pruefen(9.5)["status"] == "IM_BEREICH"
assert pruefen(10.5)["status"] == "IM_BEREICH"

def test_leer():
assert pruefen("")["status"] == "FEHLT"
assert pruefen(None)["status"] == "FEHLT"

def test_fehler():
assert pruefen("abc")["status"] == "UNGUELTIG"
assert pruefen(10.6)["status"] == "AUSSERHALB"

test_normalwert()
test_grenzwert()
test_leer()
test_fehler()
print("Alle definierten Tests erfolgreich.")

Starte '''python test_pruefrechner.py'''. Dokumentiere Soll, Ist, angewendete Regel und Codeversion. Ein bestandener Test bedeutet nur, dass dieser Testfall korrekt war, nicht dass das Programm unter allen Umständen korrekt ist. Ein '''Regressionstest''' prüft, ob spätere Änderungen zuvor getestete Eigenschaften beibehalten.

{{BR}}
== Deterministische Kernlogik erklären ==

Die Regeln sind explizit und fest: Vorverarbeitung, Endlichkeitsprüfung, Grenzvergleich und Statusbegründung. Dieselbe Eingabe führt unter demselben Regelstand zum gleichen Ergebnis. Du kannst jeden Zweig erklären, ohne eine KI-Aussage zu übernehmen. Sogenannte erklärbare KI ist ein weiter gefasstes Forschungsfeld; hier betrachten wir zunächst eine '''vollständig regelbasierte, nachvollziehbare Entscheidung''' und behaupten gerade nicht, dass der Code ein lernendes KI-Modell sei.

Eine falsche Spezifikation bleibt gefährlich, auch wenn der Code wiederholbar arbeitet. Prüfe deshalb Regelquelle, Versionsstand und Testabdeckung getrennt. Das NIST-Dokument zur generativen KI dient nur als übergeordneter Rechercheeinstieg zu Risiken; die MCP-Sicherheitsempfehlungen sind erst bei einer späteren, nicht hier verwendeten Agenten-/Netzwerkanbindung einschlägig.

'''Grenze der Anwendung:''' Nur Simulation und synthetische Beispiele. Weder Maschinensteuerung noch echte Messprüfung, Sicherheitserlaubnis oder Zertifizierung. Dies ist ein unabhängiges Bildungsangebot ohne offizielle Liebherr- oder IHK-Zertifizierung.

{{BR}}
== Eigenständiger Transfer und Differenzierung ==

'''Hilfe:''' Gehe mit drei Werten vor, drucke jedes Dictionary aus und markiere status und grund. '''Standard:''' Schreibe die Funktion '''serie_pruefen(messwerte)''', die für jede Eingabe ein Ergebnis sammelt. '''Vertiefung:''' Mache Grenzen zu Parametern, prüfe ihre Reihenfolge und dokumentiere den neuen Regelstand. Erkläre, wie sich ein geänderter Vergleich auf vorhandene Tests auswirkt.

Optionales Audio: [[File:IBM M2 sound.ogg]] – kurze mechanische Tastaturanschläge (kein Lehrinhalt, nur akustischer Kontext). '''Textalternative:''' „mehrere hörbare Tastenanschläge“. Für den Kurs ist Ton nicht erforderlich.

{{BR}}
= Interaktive Aufgaben =

{{BR}}
== Quiz: Prüfe dein Wissen ==

Beantworte zehn Fragen. Nach der interaktiven Auswertung kannst du zu jeder Aufgabe anhand der Modellregeln begründen, warum die getroffene Entscheidung stimmt oder berichtigt werden muss. Die Lösungen werden nicht als vorangestellte Erklärung angezeigt.

{{MC}}
'''Was ist eine Variable in Python?'''
(Ein Name der mit einem Wert verbunden ist)
(!Eine reale Maschinensteuerung)
(!Eine fest vorgegebene Millimetereinheit)
(!Ein automatisch erstelltes Diagramm)
{{E}}

{{MC}}
'''Welche Struktur speichert mehrere Werte in Reihenfolge?'''
(Eine Liste)
(!Ein einzelner Wahrheitswert)
(!Ein Dateikommentar)
(!Ein Funktionsname ohne Werte)
{{E}}

{{MC}}
'''Wozu dient eine if Anweisung?'''
(Zur Auswahl eines Codezweigs anhand einer Bedingung)
(!Zur Kalibrierung einer Messmaschine)
(!Zur automatischen Erzeugung eines Videos)
(!Zum Verbot jeder anderen Funktion)
{{E}}

{{MC}}
'''Welche Rolle hat return in einer Funktion?'''
(Es liefert ein Ergebnis an die aufrufende Stelle)
(!Es startet die Messmaschine)
(!Es verschluesselt automatisch alle Listen)
(!Es aendert die Maßeinheit jeder Eingabe)
{{E}}

{{MC}}
'''Wie bewertet das Modell genau 9.5 mm?'''
(Als im Bereich weil die Untergrenze eingeschlossen ist)
(!Als fehlenden Wert)
(!Als nicht endliche Zahl)
(!Als Messwert oberhalb der Obergrenze)
{{E}}

{{MC}}
'''Was geschieht beim leeren Eingabetext?'''
(Er erhaelt den Status FEHLT)
(!Er wird als Normalwert freigegeben)
(!Er wird ungeprueft in Null umgewandelt)
(!Er setzt automatisch eine neue Toleranz)
{{E}}

{{MC}}
'''Wozu dient die for Schleife in unserem Beispiel?'''
(Sie verarbeitet die Eintraege einer Liste nacheinander)
(!Sie steuert ein reales Messgeraet)
(!Sie ersetzt jede Funktionsdefinition)
(!Sie garantiert industrielle Produktfreigabe)
{{E}}

{{MC}}
'''Was bedeutet deterministische Prueflogik?'''
(Gleiche Eingaben und Regeln ergeben gleiche Resultate)
(!Jeder Lauf waehlt neue zufaellige Grenzwerte)
(!Die Tests werden automatisch ueberfluessig)
(!Eine Sprach KI legt verdeckt den Status fest)
{{E}}

{{MC}}
'''Warum prueft math.isfinite eine Zahl?'''
(Um NaN und unendliche Zahlen abzuweisen)
(!Um ein Bild automatisch zu speichern)
(!Um jede Zahl zu einer ganzen Zahl zu machen)
(!Um die Messwerte aus dem Internet abzurufen)
{{E}}

{{MC}}
'''Welche Aussage ist fachlich korrekt?'''
(Der Prüfrechner bleibt eine simulierte Lernanwendung)
(!Der Prüfrechner ist eine offizielle IHK Zertifizierung)
(!Der Prüfrechner darf Sicherheitssignale freigeben)
(!Der Prüfrechner beweist jede industrielle Normkonformitaet)
{{E}}

{{BR}}
== Memory: Begriffe und Bedeutungen ==

Ordne die sechs eindeutig zusammengehörigen Begriffspaare zu.

<div class="memo-quiz">
{|
|-
| Variable || Benennung fuer einen gespeicherten Wert
|-
| Liste || Geordnete Abfolge von Eintraegen
|-
| Dictionary || Zuordnung zwischen Schluessel und Wert
|-
| Parameter || Eingabestelle einer Funktion
|-
| Rueckgabe || Ergebnis das an den Aufrufer gelangt
|-
| Bedingung || Aussage die wahr oder falsch sein kann
|}
{{E}}

{{BR}}
== Drag-and-Drop: Bausteine erkennen ==

Ordne jede Funktion im Arbeitsablauf dem passenden Begriff zu.

<div class="lueckentext-quiz">

{| class="wikitable"
! Passender Begriff
! Funktion im Programm
|-
| '''Normalisierung'''
| Fehlende und ungueltige Eingaben unterscheiden
|-
| '''Grenzvergleich'''
| Zugehoerigkeit zum vorgegebenen Zahlenbereich pruefen
|-
| '''Ergebnisdictionary'''
| Status Wert und Begründung zusammen aufbewahren
|-
| '''For Schleife'''
| Elemente einer Messreihe nacheinander bearbeiten
|-
| '''Regressionstest'''
| Alte Erwartungen nach Aenderungen erneut pruefen
|}
{{E}}

{{BR}}
== Kreuzworträtsel ==

Jede Lösung ist ein einzelnes Fachwort.

<div class="kreuzwort-quiz">
{|
|-
| Variable || Wie heißt ein benannter Verweis auf einen Wert?
|-
| Funktion || Wie heißt ein wiederverwendbarer benannter Codebaustein?
|-
| Schleife || Wie heißt die wiederholende Kontrollstruktur?
|-
| Liste || Wie heißt die geordnete Datenstruktur mit Indizes?
|-
| Grenzwert || Wie heißt ein definierter Rand eines zulaessigen Bereichs?
|-
| Parameter || Wie heißt eine benannte Eingabestelle einer Funktion?
|}
{{E}}

{{BR}}
== LearningApps ==

<iframe> https://learningapps.org/index.php?s=Programmieren+mit+Variablen+Funktionen+und+Datenstrukturen </iframe>

''Die Einbettung ist eine thematische LearningApps-Suchseite, keine als verfügbar bestätigte Einzelaktivität. Offline-Alternative: Beschrifte fünf Karteikarten mit den Begriffen der Zuordnung und ordne passende Definitionen auf weiteren Karten zu.''

{{BR}}
== Lückentext ==

<quiz display=simple>
{'''Ergänze die wichtigsten Begriffe aus dem Lerntext.'''<br>
|type="{}"}
Der Name fuer einen zugeordneten Wert heißt { Variable }.
Mehrere geordnete Werte bilden eine { Liste }.
Ein wiederverwendbarer Baustein heißt { Funktion }.
Eine Auswahl im Programm nutzt eine { Bedingung }.
Ein wiederholter Ablauf heißt { Schleife }.
Mit { return } wird das Ergebnis einer Funktion zurückgegeben.
Eine nicht angegebene Messung erhält den Status { FEHLT }.
Die Zahl oberhalb der Obergrenze bekommt den Status { AUSSERHALB }.
Einheitliche Regeln erlauben eine { deterministische } Entscheidung.
Ein wiederholter Test nach einer Änderung heißt { Regressionstest }.
</quiz>

{{BR}}
= Offene Aufgaben =

{{BR}}
=== Leicht ===
# [[Variable (Programmierung)|Variablen]]: Notiere drei selbst erfundene Zahlen mit verständlichen Variablennamen und den richtigen Einheiten.
# [[Liste (Datenstruktur)|Messreihe]]: Erstelle die Liste mit 10.0, 9.5 und fehlendem Wert; bestimme die Indizes und erläutere den leeren Eintrag.
# [[Kontrollstruktur|Programmablaufplan]]: Zeichne von Hand einen Entscheidungsweg mit Eingabeprüfung, Vergleich und Ausgabe.
# [[Softwaretest|Vorhersage]]: Notiere ohne Programmausführung die erwarteten Status für Normalwert, Grenzwert und leeren Wert.

{{BR}}
=== Standard ===
# [[Funktion (Programmierung)|Code ausführen]]: Schreibe den geführten Prüfrechner in eine lokale Datei und kennzeichne jede Funktionsaufgabe.
# [[Softwaretest|Testprotokoll]]: Führe die drei Pflichtfälle aus; protokolliere Soll, Ist und die entscheidende Regel.
# [[Fehlerbehandlung|Fehleranalyse]]: Prüfe "abc", beschreibe den konkreten Ausnahmezweig und begründe, warum keine Bereichsfreigabe möglich ist.
# [[Modularisierung|Serienverarbeitung]]: Programmiere serie_pruefen für eine Liste synthetischer Eingaben mit einer Ergebnissammlung.

{{BR}}
=== Schwer ===
# [[Regressionstest|Grenzfehler]]: Ändere <= versuchsweise zu <, weise den dadurch entstehenden Fehler mit einem Test nach und stelle die korrekte Fassung wieder her.
# [[Funktionsparameter|Parameter]]: Ersetze feste Modellgrenzen durch geprüfte Funktionsparameter und teste vertauschte Grenzen.
# [[Datenqualität|Eingabeklassen]]: Teste None, leeren Text, "abc", NaN, Unendlich und bool; begründe unterschiedliche Fehlerklassen.
# [[Softwaredokumentation|Versionsbericht]]: Entwirf für eine andere ungefährliche Simulation einen Prüfrechner v1.1 mit Regeländerung, begründeter Testmatrix und Änderungshistorie.

{{:Offene Aufgabe - MOOC erstellen}}

{{BR}}
= Lernkontrolle =

# [[Kontrollstruktur|Entscheidungsfolge]]: Begründe Schritt für Schritt, weshalb 9.5 im Modell IM_BEREICH ergibt.
# [[Fehlerbehandlung|Fehlende Eingaben]]: Erläutere, warum der leere String vor der Zahlenkonvertierung erkannt werden muss und nicht als Nullwert gelten darf.
# [[Softwaretest|Testmatrix]]: Stelle erwartete und beobachtete Ergebnisse für 10.0, 9.5 und "" gegenüber; erkläre eventuelle Unterschiede.
# [[Modularisierung|Funktionsschnittstellen]]: Zeige den Nutzen der Trennung zwischen normalisieren, pruefen und anzeigen an einem konkreten Änderungswunsch.
# [[Determinismus|Grenzen der Erklärbarkeit]]: Beurteile, ob wiederholbare Ausgaben auch die sachliche Richtigkeit einer fehlerhaften Grenzregel beweisen.
# [[Datenstruktur|Transfer]]: Skizziere die Verarbeitung von zehn synthetischen Werten mit Liste, for-Schleife und Dictionary-Ausgabe.

{{BR}}
= Lernnachweis =

Reiche einen lokal ausführbaren Ordner mit '''pruefrechner.py''' und '''test_pruefrechner.py''' sowie eine kurze Dokumentation ein. Prüfkriterien:

* '''Begriffe:''' Du erklärst Variable, Datentyp, Liste, Dictionary, Bedingung, Schleife und Funktion in eigenen Worten.
* '''Lernprodukt:''' Die Prüflogik besteht aus getrennten, verständlich benannten Funktionen und enthält nachvollziehbare Statusbegründungen.
* '''Drei Pflichtfälle:''' Normalwert 10.0, Grenzwert 9.5 und leere Eingabe "" sind mit Soll, Ist und Regelgrund protokolliert.
* '''Fehlerbegründung:''' Du beschreibst einen bewusst provozierten Fehler, den betroffenen Codezweig und die Korrektur.
* '''Transfer:''' Eine zusätzliche synthetische Messreihe oder eine kontrollierte Grenzparametrisierung wird mit Tests nachvollzogen.
* '''Reflexion:''' Du begrenzt die Aussagekraft des Modells auf Simulation, Erklärbarkeit der Regeln und den festgelegten Versionsstand.

'''Hinweis zur Bewertung:''' Dies ist ein unabhängiger Unterrichts-Lernnachweis, keine industrielle Prüfbescheinigung und keine offizielle Liebherr- oder IHK-Zertifizierung.

{{BR}}
= OER und Wikipedia =

'''Quellenstand:''' Recherche 22.10.2026. Ausführung empfohlen mit lokalem Python 3.10 oder neuer; die Python-3-Onlinedokumentation ist dynamisch und kann sich nach dem Erhebungsstand ändern. Die 9.5/10.5-mm-Regel wurde ausschließlich für diese Unterrichtssimulation festgelegt.

* [https://docs.python.org/3/tutorial/controlflow.html Offizielle Python-Dokumentation, Control Flow Tools] – if, for und Funktionen, englisch.
* [https://docs.python.org/3/tutorial/datastructures.html Offizielle Python-Dokumentation, Data Structures] – Listen und Dictionaries, englisch.
* [https://docs.python.org/3/library/math.html#math.isfinite Offizielle Python-Dokumentation, math.isfinite] – Prüfung endlicher Zahlen.
* [https://de.wikipedia.org/wiki/Kontrollstruktur Wikipedia: Kontrollstruktur] – deutschsprachige ergänzende Übersicht.
* [https://de.wikipedia.org/wiki/Funktion_(Programmierung) Wikipedia: Funktion] – weiterführende Grundbegriffe.
* [https://nvlpubs.nist.gov/nistpubs/ai/NIST.AI.600-1.pdf NIST AI 600-1, Generative AI Profile, Juli 2024] – Primärquelle zum Risikomanagement generativer KI, nicht technische Norm des Prüfrechners.
* [https://modelcontextprotocol.io/docs/2026-07-28/tutorials/security/security_best_practices MCP Security Best Practices, Dokumentationspfad 2026-07-28] – Sicherheitsprinzipien für spätere Werkzeuganbindungen; dieser Kurs braucht keine Netzwerkverbindung.
* [https://moocwiki.org/index.php?curid=60512 Vorhandene MOOCwiki-Grundlage] – gewünschter Anschluss; die Seite konnte über den Recherchezugang nicht eingesehen werden.

'''Geprüfte Commons-Dateiseiten und Herkunft:'''

{| class="wikitable"
! Datei !! Originalseite !! Urheber !! Lizenz
|-
| File:CPT-programming-variable.svg || [https://commons.wikimedia.org/wiki/File:CPT-programming-variable.svg Quelle] || Pluke || [https://creativecommons.org/publicdomain/zero/1.0/ CC0 1.0]
|-
| File:Google Python Class Lecture1-2 Pic1.jpg || [https://commons.wikimedia.org/wiki/File:Google_Python_Class_Lecture1-2_Pic1.jpg Quelle] || Nick Parlante || [https://creativecommons.org/licenses/by/2.5/ CC BY 2.5]
|-
| File:Flowchart de.svg || [https://commons.wikimedia.org/wiki/File:Flowchart_de.svg Quelle] || Erik Streb || [https://creativecommons.org/licenses/by-sa/3.0/ CC BY-SA 3.0]
|-
| File:DRAKON algorithm animation.gif || [https://commons.wikimedia.org/wiki/File:DRAKON_algorithm_animation.gif Quelle] || Oleg Garipov || [https://creativecommons.org/licenses/by-sa/4.0/ CC BY-SA 4.0]
|-
| File:IBM M2 sound.ogg || [https://commons.wikimedia.org/wiki/File:IBM_M2_sound.ogg Quelle] || Anonimski || [https://creativecommons.org/publicdomain/zero/1.0/ CC0 1.0]
|}

'''YouTube-Videos:''' [https://www.youtube.com/watch?v=RBpK8C3N-Y8 Python Tutorial Deutsch – Programmieren Starten, 2021] und [https://www.youtube.com/watch?v=e6vPt_e9sRw Python Tutorial Deutsch – Fabian Rappert, 2024]. Sie werden verlinkt/eingebettet und nicht unter einer behaupteten OER-Lizenz vervielfältigt; Rechte liegen bei den jeweiligen Herausgebern. Videometadaten und Themen wurden recherchiert, die jederzeitige Wiedergabe ist nicht zugesichert. Texte, Beispieldaten und Tests sind vollständig auch ohne diese Medien nutzbar.

'''Wikipedia-Einbettung (deutsch):'''
<iframe> https://de.m.wikipedia.org/wiki/Kontrollstruktur </iframe>

'''Nutzungshinweis:''' Für eine Weiterverwendung der Commons-Medien gelten deren jeweilige Lizenzbedingungen, insbesondere bei CC-BY und CC-BY-SA die vorgeschriebenen Namensnennungen und gegebenenfalls Weitergabe unter gleichen Bedingungen.

{{BR}}
= Verknüpfte Lernbereiche =

{| align=center
{{:D-Tab}}
'''[[Programmierung]]'''
# [[Variable (Programmierung)|Variablen]]
# [[Kontrollstruktur|Bedingungen und Schleifen]]
# [[Funktion (Programmierung)|Funktionen]]
# [[Liste (Datenstruktur)|Datenstrukturen]]
'''[[Technische Informatik]]'''
# [[Softwaretest]]
# [[Modularisierung]]
# [[Fehlerbehandlung]]
# [[Datenqualität]]
'''[[Berufsausbildung]]'''
# [[Technische Dokumentation]]
# [[Qualitätssicherung|Qualitätsprüfung als Simulation]]
# [[Softwareentwicklung]]
|}

{{BR}}
= aiMOOC-Projekte =

Erstelle als eigenes Lernprojekt einen zweiten kleinen Prüfrechner, der ausschließlich erfundene Temperaturwerte bewertet. Lege zunächst die Einheit, neue fachlich begründete Modellgrenzen, eine Versionsnummer und die drei Pflicht-Testarten fest. Übertrage dann das bewährte Funktionsmuster. Jede Ausgabe muss die getroffene Entscheidung nachvollziehbar erklären. Auch dieses Projekt darf niemals reale Sensoren oder Maschinen steuern.

[[Category:Sprache:Deutsch]]
[[Category:Locale:de-DE]]
[[Category:Programmierung]]
[[Category:Python]]
[[Category:Technische Informatik]]
[[Category:Berufsausbildung]]
[[Category:AI_MOOC]] [[Category:GPT aiMOOC]]
{{MT}}

Programmieren mit Variablen Funktionen und Datenstrukturen - Versionsgeschichte

Glanz: AI MOOC Plugin 9c45701abb59e456dac2e391ddaadf0b