Ein kleines Auswertungsprogramm nachvollziehen und testen

Drei Messwerte, aber noch keine Auswertung

Die Nordblick Gebäudetechnik richtet neue Besprechungsräume ein. Nach der Installation misst das Serviceteam, wie lange ein Testgerät für den Verbindungsaufbau braucht. Der vereinbarte Richtwert liegt bei höchstens 30 Sekunden. Bislang trägt das Team jeden Messwert in eine Tabelle ein und zählt Überschreitungen von Hand.

Für drei Räume wurden 18, 30 und 47 Sekunden gemessen. Ein kleines Programm soll jeden Wert einlesen, sofort einordnen und am Ende die Zahl der Überschreitungen ausgeben. An diesem überschaubaren Auftrag kannst du die Grundbausteine eines Programms sehen, ohne gleichzeitig eine umfangreiche Anwendung bauen zu müssen.

Du brauchst keine Vorkenntnisse in Python. Jeder neue Begriff wird an der Stelle erklärt, an der du ihn verwendest. Nach der Lektion kannst du einen einfachen Programmablauf lesen, verändern und mit Testwerten prüfen.

Werte werden durch Variablen auffindbar

Ein Wert ist eine konkrete Information, mit der das Programm arbeitet. 30, 47 und "Richtwert eingehalten" sind Werte. Sie bedeuten für das Programm zunächst nur das, was ihr Datentyp und der umgebende Code festlegen.

Eine Variable gibt einem Wert einen Namen. Der Name macht sichtbar, wofür der Wert im Programm steht:

limit_seconds = 30
measured_seconds = 47
exceeded_count = 0

Die Variable limit_seconds verweist auf den Richtwert. measured_seconds enthält den gerade betrachteten Messwert. In exceeded_count merkt sich das Programm, wie viele Überschreitungen es bisher gefunden hat.

Das Gleichheitszeichen ist hier eine Zuweisung. Die Zeile exceeded_count = 0 legt nicht die mathematische Aussage “Überschreitungen sind immer null” fest. Sie gibt der Variable zu diesem Zeitpunkt den Startwert 0. Später kann ein anderer Wert zugewiesen werden.

Datentypen legen mögliche Operationen fest

Ein Datentyp beschreibt, welche Art von Wert vorliegt und welche Operationen damit sinnvoll sind. Für das Beispiel reichen drei Typen:

Der Typ ist keine Nebensache. Mit zwei ganzen Zahlen kann Python rechnen. Zwei Texte werden beim Pluszeichen dagegen aneinandergefügt. Deshalb ergibt 20 + 5 den Zahlenwert 25, während "20" + "5" den Text "205" ergibt.

Im nächsten Schritt entsteht ein Wahrheitswert durch einen Vergleich:

measured_seconds = 47
limit_seconds = 30
within_limit = measured_seconds <= limit_seconds

print(within_limit)

Der Ausdruck measured_seconds <= limit_seconds fragt, ob der Messwert kleiner oder gleich dem Richtwert ist. Bei 47 und 30 ist das Ergebnis False. Dieses Ergebnis wird in der Variable within_limit gespeichert und anschließend ausgegeben.

Eingabe kommt zunächst als Text an

Mit input() wartet ein Python-Programm auf eine Eingabe. Der Text in den Klammern dient als verständliche Aufforderung:

room_name = input("Raumbezeichnung: ")
print("Geprüft:", room_name)

input() liefert immer eine Zeichenkette. Das passt für room_name. Ein eingegebener Messwert soll jedoch mit 30 verglichen werden. Dafür wird der Text mit int() in eine ganze Zahl umgewandelt:

input_text = input("Verbindungszeit in Sekunden: ")
measured_seconds = int(input_text)

Die beiden Zeilen trennen zwei Schritte: zuerst einlesen, danach umwandeln. Diese Trennung hilft beim Nachvollziehen. Die kürzere Schreibweise int(input(...)) wäre ebenfalls möglich, versteckt aber einen Zwischenschritt.

Die Umwandlung hat eine Grenze. Bei einer Eingabe wie schnell kann Python keine ganze Zahl bilden und beendet das Programm mit einem Fehler. Eine robuste Behandlung ungültiger Eingaben ist wichtig, würde hier aber zusätzliche Sprachmittel einführen. Diese Lektion arbeitet deshalb mit der klaren Voraussetzung, dass ganze, nicht negative Sekundenwerte eingegeben werden.

Eine Bedingung entscheidet zwischen zwei Wegen

Eine Bedingung liefert True oder False. Mit if entscheidet das Programm, welcher Code abhängig von diesem Ergebnis ausgeführt wird. else beschreibt den anderen Fall:

limit_seconds = 30
measured_seconds = int(input("Verbindungszeit in Sekunden: "))

if measured_seconds <= limit_seconds:
    print("Richtwert eingehalten")
else:
    print("Richtwert überschritten")

Der Doppelpunkt eröffnet jeweils einen eingerückten Block. Die Einrückung ist in Python Teil der Syntax. Nur die eingerückte Ausgabe unter der passenden Verzweigung wird ausgeführt.

Für den Messwert 30 ist die Bedingung wahr. Das Programm gibt Richtwert eingehalten aus. Für 47 ist sie falsch und das Programm folgt dem else-Zweig.

Eine Verzweigung ist dann hilfreich, wenn aus einer fachlichen Regel unterschiedliche Handlungen folgen. Sie ersetzt nicht die fachliche Klärung. Bevor Code entsteht, muss zum Beispiel eindeutig sein, ob 30 Sekunden noch zulässig sind. Im Szenario sagt “höchstens 30 Sekunden”, dass der Grenzwert dazugehört.

Eine Schleife verarbeitet mehrere Messwerte

Das Programm soll denselben Ablauf für drei Räume durchführen. Dreimal kopierter Code wäre schwerer zu ändern und lädt zu Abweichungen ein. Eine Schleife wiederholt einen Codeblock nach einer festgelegten Regel.

In Python liefert range(3) nacheinander die Zahlen 0, 1 und 2. Die for-Schleife führt ihren eingerückten Block für jede dieser Zahlen einmal aus:

for index in range(3):
    print("Messung", index + 1)

Die Ausgabe beginnt durch index + 1 bei 1. Die Schleife selbst hat weiterhin drei Durchläufe. Dieses Detail ist hilfreich, weil Computer häufig ab null zählen, Menschen eine erste Messung aber meist als Nummer 1 bezeichnen.

Jetzt kommen die bisherigen Bausteine zusammen:

limit_seconds = 30
measurement_count = 3
exceeded_count = 0

for index in range(measurement_count):
    room_name = input("Raumbezeichnung: ")
    input_text = input("Verbindungszeit in Sekunden: ")
    measured_seconds = int(input_text)
    within_limit = measured_seconds <= limit_seconds

    if within_limit:
        print(room_name, ": Richtwert eingehalten")
    else:
        print(room_name, ": Richtwert überschritten")
        exceeded_count = exceeded_count + 1

print("Überschreitungen:", exceeded_count)

exceeded_count liegt vor der Schleife, weil die Anzahl über alle Durchläufe hinweg erhalten bleiben soll. Im else-Zweig liest exceeded_count = exceeded_count + 1 zuerst den bisherigen Wert, erhöht ihn und weist das Ergebnis wieder derselben Variable zu.

Die letzte Ausgabe ist nicht eingerückt. Sie gehört daher nicht zur Schleife und erscheint genau einmal, nachdem alle Messwerte verarbeitet wurden.

Ein Schreibtischtest macht den Zustand sichtbar

Bei einem Schreibtischtest führst du den Code mit festgelegten Eingaben Schritt für Schritt aus. Du notierst nach jedem Durchlauf die Werte wichtiger Variablen. So kannst du erwartetes und tatsächliches Verhalten vergleichen, ohne dich auf einen schnellen Blick in den Code zu verlassen.

Für die Eingaben Raum A, 18, Raum B, 30 und Raum C, 47 ergibt sich:

Die Tabelle zeigt besonders den Grenzwert 30. Ein Test nur mit 18 und 47 würde zwar beide Zweige ausführen, aber nicht prüfen, ob der Grenzwert selbst richtig behandelt wird.

Testfälle beschreiben erwartbares Verhalten

Ein Testfall verbindet eine Eingabe mit einem erwarteten Ergebnis. Für die Bedingung sind Werte aus drei Gruppen hilfreich:

• unter dem Grenzwert, zum Beispiel 18 Sekunden,
• genau auf dem Grenzwert, also 30 Sekunden,
• über dem Grenzwert, zum Beispiel 47 Sekunden.

Für die Schleife kommt eine weitere Frage dazu: Stimmt die Zusammenfassung, wenn mehrere Messwerte den Grenzwert überschreiten? Mit den Eingaben 31, 45 und 12 muss exceeded_count am Ende den Wert 2 haben.

Solche Beispiele beweisen nicht, dass das Programm für jede mögliche Eingabe fehlerfrei ist. Sie machen aber die fachliche Erwartung überprüfbar. In einer späteren Lektion können daraus systematischere Testverfahren und eine Behandlung ungültiger Eingaben entstehen.

Was hier noch nicht Teil der Aufgabe ist

Dieses Programm enthält bereits eine klare Folge von Schritten. Ein Algorithmus ist allgemeiner: Er beschreibt ein eindeutiges, endliches Verfahren zur Lösung einer Aufgabenklasse. Der systematische Entwurf, die grafische Darstellung und die Beurteilung von Algorithmen brauchen mehr als die hier gezeigten Sprachbausteine. Diese Themen gehören in eine eigene Lektion.

Auch objektorientierte Programmierung wird hier nicht benötigt. Sie ordnet Daten und Verhalten häufig in Klassen und Objekten. Für drei Messwerte würde eine zusätzliche Objektstruktur den grundlegenden Ablauf eher verdecken. Bei einer größeren Anwendung mit Räumen, Geräten, Messreihen und unterschiedlichen Regeln kann diese Modellierung später sinnvoll werden.

Funktionen sind ebenfalls ein nächster Ausbauschritt. Sie fassen eine benannte Teilaufgabe mit klaren Eingaben und Ausgaben zusammen. In dieser Lektion bleibt der Code bewusst an einer Stelle, damit du Zuweisung, Verzweigung, Schleife und Zustand zuerst direkt verfolgen kannst.

Übertrage den Ablauf auf eine neue Messreihe

limit_degrees = 24
check_count = 4
exceeded_count = 0

for index in range(check_count):
    input_text = input("Temperatur in Grad Celsius: ")
    measured_degrees = int(input_text)

    if measured_degrees <= limit_degrees:
        print("im Bereich")
    else:
        print("zu warm")
        exceeded_count = exceeded_count + 1

print("Überschreitungen:", exceeded_count)

Das nimmst du mit

Ein kleines Programm wird verständlich, wenn jeder Baustein eine erkennbare Aufgabe trägt. Werte enthalten konkrete Informationen. Variablen geben ihnen Namen. Datentypen legen fest, wie das Programm die Werte behandeln kann. Eingabe bringt Daten in den Ablauf, eine Bedingung entscheidet zwischen Wegen und eine Schleife wiederholt die Verarbeitung.

Testfälle machen aus einer vagen Erwartung ein überprüfbares Verhalten. Werte unter, auf und über einer Grenze helfen dabei, eine Bedingung gezielt zu prüfen. Ein Schreibtischtest zeigt zusätzlich, wie sich Variablen während mehrerer Durchläufe verändern.

Damit steht das Grundgerüst. Algorithmusentwurf, Funktionen, Fehlerbehandlung und objektorientierte Modellierung bauen darauf auf, lösen aber jeweils ein eigenes Problem.

Belegmatrix