Lektion for while

.gitignore

@@ -0,0 +1,8 @@
+graphify-out/
+graphity-out
+.json
+main.pdf
+CLAUDE.md
+.idea/
+__pycache__/
+*.pyc

Code/09_schleifen/countdown.py

@@ -0,0 +1,13 @@
+# Eine while-Schleife wiederholt einen Block, solange die Bedingung wahr ist.
+
+sekunden = 5
+
+while sekunden > 0:
+    print(sekunden)
+    sekunden = sekunden - 1   # Ohne diese Zeile laeuft die Schleife ewig!
+
+print("Start!")
+
+# Ablauf: Python prueft "sekunden > 0". Ist das wahr, laeuft der eingerueckte
+# Block einmal komplett durch - danach wird die Bedingung ERNEUT geprueft.
+# Erst wenn sie falsch ist, geht es unterhalb der Schleife weiter.

Code/09_schleifen/eingabe_pruefen.py

@@ -0,0 +1,26 @@
+# Ein haeufiger Einsatz von Schleifen: so lange fragen, bis die Eingabe passt.
+
+alter = -1   # Ein Startwert, der die Bedingung sicher erfuellt.
+
+while alter < 0 or alter > 120:
+    alter = int(input("Wie alt bist du? (0 bis 120) "))
+
+    if alter < 0 or alter > 120:
+        print("Das kann nicht stimmen. Versuch es noch einmal.")
+
+print(f"Danke! Du bist {alter} Jahre alt.")
+
+
+# Dieselbe Idee mit "while True" und "break".
+# "while True" ist eine Schleife ohne Ende - sie wird von innen heraus
+# mit "break" verlassen. Das spart den kuenstlichen Startwert oben.
+
+while True:
+    lieblingsfarbe = input("Nenne eine Farbe (nicht leer): ")
+
+    if lieblingsfarbe != "":
+        break               # verlaesst die Schleife sofort
+
+    print("Da stand nichts. Bitte nochmal.")
+
+print(f"Schoene Wahl: {lieblingsfarbe}")

Code/09_schleifen/einmaleins.py

@@ -0,0 +1,14 @@
+# Schleifen duerfen ineinander stecken. Die innere Schleife laeuft dabei
+# bei jedem einzelnen Durchlauf der aeusseren Schleife komplett durch.
+
+for reihe in range(1, 11):
+
+    for faktor in range(1, 11):
+        ergebnis = reihe * faktor
+        # end=" " verhindert den Zeilenumbruch nach jeder Ausgabe.
+        # :4 sorgt fuer eine Breite von vier Zeichen - so stehen die Spalten untereinander.
+        print(f"{ergebnis:4}", end=" ")
+
+    print()   # leeres print() beendet die Zeile
+
+# 10 Durchlaeufe aussen mal 10 Durchlaeufe innen ergeben 100 Ausgaben.

Code/09_schleifen/for_range.py

@@ -0,0 +1,39 @@
+# Wenn von vornherein feststeht, wie oft etwas passieren soll,
+# ist die for-Schleife die passende Wahl.
+
+for i in range(5):
+    print(i)
+
+# Ausgabe: 0 1 2 3 4
+# range(5) liefert fuenf Zahlen - beginnend bei 0, OHNE die 5 selbst.
+
+print("---")
+
+# Mit zwei Angaben: von wo bis wo (Ende bleibt aussen vor).
+for zahl in range(1, 6):
+    print(zahl)
+
+# Ausgabe: 1 2 3 4 5
+
+print("---")
+
+# Mit drei Angaben: von, bis, Schrittweite.
+for zahl in range(0, 21, 5):
+    print(zahl)
+
+# Ausgabe: 0 5 10 15 20
+
+print("---")
+
+# Rueckwaerts zaehlen mit negativer Schrittweite.
+for zahl in range(3, 0, -1):
+    print(zahl)
+print("Start!")
+
+print("---")
+
+# Dieselbe Summe wie mit while - nur deutlich kuerzer.
+summe = 0
+for zahl in range(1, 101):
+    summe += zahl
+print(f"Summe von 1 bis 100: {summe}")

Code/09_schleifen/for_zeichenkette.py

@@ -0,0 +1,24 @@
+# Eine for-Schleife laeuft nicht nur ueber Zahlen, sondern ueber alles,
+# was aus mehreren Teilen besteht. Ein Text besteht aus einzelnen Zeichen.
+
+wort = "Python"
+
+for zeichen in wort:
+    print(zeichen)
+
+print("---")
+
+# Damit lassen sich Texte untersuchen. Hier zaehlen wir die Vokale.
+
+satz = input("Schreib einen Satz: ")
+vokale = 0
+
+for zeichen in satz:
+    if zeichen in "aeiouAEIOU":
+        vokale += 1
+
+print(f"Dein Satz enthaelt {vokale} Vokale.")
+
+# Das Wort "in" hat hier zwei verschiedene Aufgaben:
+# In der for-Zeile bedeutet es "laufe nacheinander durch".
+# In der if-Zeile bedeutet es "kommt darin vor?" und liefert True oder False.

Code/09_schleifen/summe_sammeln.py

@@ -0,0 +1,15 @@
+# Eine Schleife eignet sich gut, um Werte aufzusammeln.
+# Wir addieren alle Zahlen von 1 bis 100.
+
+zahl = 1
+summe = 0        # Der "Sammelbehaelter". Er startet leer, also bei 0.
+
+while zahl <= 100:
+    summe = summe + zahl   # Kurzform: summe += zahl
+    zahl = zahl + 1        # Kurzform: zahl += 1
+
+print(f"Die Summe der Zahlen von 1 bis 100 ist {summe}.")
+
+# Zwei Variablen mit klar getrennten Aufgaben:
+# "zahl" zaehlt hoch und steuert, wann die Schleife endet.
+# "summe" sammelt das Ergebnis ein und wird nie zurueckgesetzt.

Code/09_schleifen/zahlenraten_schleife.py

@@ -0,0 +1,25 @@
+# Das Ratespiel aus der letzten Lektion - jetzt mit mehreren Versuchen.
+
+GESUCHTE_ZAHL = 7
+MAX_VERSUCHE = 3
+
+versuch = 0
+geraten = False
+
+while versuch < MAX_VERSUCHE and not geraten:
+    versuch += 1
+    tipp = int(input(f"Versuch {versuch} von {MAX_VERSUCHE}. Zahl von 1 bis 10? "))
+
+    if tipp == GESUCHTE_ZAHL:
+        print("Volltreffer!")
+        geraten = True
+    elif tipp < GESUCHTE_ZAHL:
+        print("Zu klein.")
+    else:
+        print("Zu gross.")
+
+if not geraten:
+    print(f"Schade, die Zahl war {GESUCHTE_ZAHL}.")
+
+# Die Schleife endet aus ZWEI Gruenden: entweder sind die Versuche
+# aufgebraucht, oder die Zahl wurde erraten. Beides steht in der Bedingung.

Code/HelloWorld.java

@@ -0,0 +1,5 @@
+public class HelloWorld {
+    public static void main(String[] args) {
+        System.out.println("Hello World!");
+    }
+}

Code/division_pruefen.py

@@ -0,0 +1,18 @@
+# Aus der letzten Lektion: Dieses Programm stuerzt ab, wenn die zweite
+# Zahl 0 ist (ZeroDivisionError). Jetzt fangen wir diesen Fall hoeflich ab.
+
+erste_zahl = int(input("Gib eine ganze Zahl ein: "))
+zweite_zahl = int(input("Gib noch eine ganze Zahl ein: "))
+
+# Die bedingte Anweisung: Python prueft, ob die Bedingung nach "if" wahr ist.
+if zweite_zahl == 0:
+    # Dieser Block wird NUR ausgefuehrt, wenn die Bedingung wahr ist.
+    print("Fehler: Durch 0 darf nicht geteilt werden.")
+else:
+    # Dieser Block wird ausgefuehrt, wenn die Bedingung falsch ist.
+    ergebnis = erste_zahl / zweite_zahl
+    print(f"{erste_zahl} geteilt durch {zweite_zahl} ist {ergebnis}")
+
+# Diese Zeile steht NICHT eingerueckt - sie gehoert zu keinem Block
+# und wird deshalb immer ausgefuehrt, egal wie die Eingabe war.
+print("Das Programm ist fertig.")

Code/eingabe_zahlen.py

@@ -0,0 +1,17 @@
+# input() hält das Programm an und wartet auf eine Eingabe der Nutzerin.
+# WICHTIG: input() liefert das Eingegebene IMMER als Text (str) zurück -
+# auch dann, wenn die Nutzerin eine Zahl eingetippt hat.
+
+erste_eingabe = input("Gib eine Zahl ein: ")
+zweite_eingabe = input("Gib noch eine Zahl ein: ")
+
+# "+" verbindet zwei Texte einfach hintereinander (Konkatenation).
+# Bei den Eingaben "12" und "3" käme hier "123" heraus - nicht 15!
+print("Als Text aneinandergehängt:", erste_eingabe + zweite_eingabe)
+
+# Damit wir rechnen können, müssen wir den Text erst in eine ganze Zahl
+# umwandeln. Das erledigt die Funktion int().
+erste_zahl = int(erste_eingabe)
+zweite_zahl = int(zweite_eingabe)
+
+print("Als Zahlen addiert:", erste_zahl + zweite_zahl)

Code/einrueckung_wichtig.py

@@ -0,0 +1,23 @@
+# In Python entscheidet die EINRUECKUNG, welche Zeilen zu einem Block
+# gehoeren. Es gibt keine geschweiften Klammern wie in anderen Sprachen.
+
+alter = int(input("Wie alt bist du? "))
+
+# --- Version A: beide print-Zeilen sind eingerueckt ---------------------
+# Beide Zeilen gehoeren zum if-Block. Bei alter >= 18 werden BEIDE
+# ausgegeben, sonst KEINE.
+if alter >= 18:
+    print("Du bist volljaehrig.")
+    print("Du darfst waehlen.")
+
+# --- Zum Ausprobieren: ruecke die zweite Zeile aus --------------------
+# Wenn "Du darfst waehlen." NICHT eingerueckt ist, gehoert sie nicht mehr
+# zum if-Block. Dann wird sie IMMER ausgegeben - auch fuer eine 12.
+#
+# if alter >= 18:
+#     print("Du bist volljaehrig.")
+# print("Du darfst waehlen.")     # <- steht jetzt ausserhalb des if
+
+# Merke: Die Einrueckung ist nicht Deko, sie ist Teil der Bedeutung.
+# Ueblich sind 4 Leerzeichen pro Stufe. Alle Zeilen eines Blocks muessen
+# gleich weit eingerueckt sein.

Code/helloworld.cpp

@@ -0,0 +1,6 @@
+#include <iostream>
+
+int main() {
+    std::cout<<"Hello world!"<<std::endl;
+    return 0;
+}

Code/noten_kategorie.py

@@ -0,0 +1,23 @@
+# Mehr als zwei Faelle: mit "elif" (kurz fuer "else if") haengen wir
+# weitere Bedingungen an. Python prueft sie der Reihe nach von oben nach
+# unten und nimmt den ERSTEN Zweig, dessen Bedingung wahr ist.
+
+punkte = int(input("Wie viele Punkte hast du erreicht (0-100)? "))
+
+if punkte >= 90:
+    note = "sehr gut"
+elif punkte >= 75:
+    note = "gut"
+elif punkte >= 60:
+    note = "befriedigend"
+elif punkte >= 50:
+    note = "ausreichend"
+else:
+    # Wird nur erreicht, wenn KEINE der Bedingungen oben wahr war.
+    note = "nicht bestanden"
+
+print(f"Ergebnis: {note}")
+
+# Warum ist die Reihenfolge wichtig? Bei 95 Punkten ist auch
+# "punkte >= 75" wahr - aber Python hat den ersten passenden Zweig
+# (punkte >= 90) schon genommen und ueberspringt den Rest.

Code/rechnen.py

@@ -0,0 +1,18 @@
+# Rechnen mit ganzen Zahlen. Python nutzt die Rechenausdrücke, die wir aus
+# der Schule kennen, plus die bereits bekannte Zuweisung mit "=".
+
+a = 18
+b = 5
+
+print("Summe:        ", a + b)   # 23
+print("Differenz:    ", a - b)   # 13
+print("Produkt:      ", a * b)   # 90
+print("Quotient:     ", a / b)   # 3.6   <- / liefert IMMER eine Kommazahl (float)
+print("Ganzzahl-Div: ", a // b)  # 3     <- // schneidet den Rest ab
+print("Rest (modulo):", a % b)   # 3     <- was bei 18 : 5 übrig bleibt
+print("Potenz:       ", a ** b)  # 1889568  <- a hoch b
+
+# Rechenreihenfolge ("Punkt vor Strich") gilt wie in der Mathematik.
+# Mit Klammern kann man sie steuern:
+print(2 + 3 * 4)     # 14
+print((2 + 3) * 4)   # 20

Code/rechner_eingabe.py

@@ -0,0 +1,13 @@
+# Ein kleines Rechenprogramm: Es nimmt zwei ganze Zahlen entgegen und gibt
+# Summe, Differenz, Produkt und Quotient aus.
+
+erste_zahl = int(input("Gib eine ganze Zahl ein: "))
+zweite_zahl = int(input("Gib noch eine ganze Zahl ein: "))
+
+print("Summe:     ", erste_zahl + zweite_zahl)
+print("Differenz: ", erste_zahl - zweite_zahl)
+print("Produkt:   ", erste_zahl * zweite_zahl)
+print("Quotient:  ", erste_zahl / zweite_zahl)
+
+# f-strings sind bequem, um Text und Werte zu mischen:
+print(f"{erste_zahl} geteilt durch {zweite_zahl} ist {erste_zahl / zweite_zahl}")

Code/teilbarkeit.py

@@ -0,0 +1,14 @@
+# Teilt die zweite Zahl die erste? Wir nutzen den Rest-Operator "%"
+# aus der letzten Lektion: Ist der Rest 0, dann ist die Division glatt
+# aufgegangen - die zweite Zahl ist ein Teiler der ersten.
+
+zahl = int(input("Zahl: "))
+teiler = int(input("Moeglicher Teiler: "))
+
+if teiler == 0:
+    print("Durch 0 teilt es sich nicht.")
+elif zahl % teiler == 0:
+    print(f"{teiler} teilt {zahl}.")
+else:
+    rest = zahl % teiler
+    print(f"{teiler} teilt {zahl} nicht (Rest {rest}).")

Code/test_installation.py

@@ -0,0 +1,20 @@
+import sys
+import platform
+
+print("=" * 50)
+print("Installation Überprüfung")
+print("=" * 50)
+
+# Python-Version
+print(f"\n✓ Python-Version: {sys.version}")
+
+# Betriebssystem
+print(f"✓ Betriebssystem: {platform.system()}")
+
+# Architektur
+print(f"✓ Architektur: {platform.machine()}")
+
+print("\n" + "=" * 50)
+print("Alle Überprüfungen bestanden! 🎉")
+print("=" * 50)
+print("\nNächster Schritt: Lektion 2 - Hello World")

Code/variablen.py

@@ -0,0 +1,5 @@
+beschreibung = "wundervoll"
+
+print(f"Hallo, mein Tag war {beschreibung}!")
+print(f"ich habe {beschreibung} aus einem skript gelernt.")
+print(f"Ich hoffe dir geht es genauso {beschreibung}")

Code/variablen_aendern.py

@@ -0,0 +1,23 @@
+# Ein Programm ist eine Folge von Anweisungen, die von oben nach unten
+# abgearbeitet werden - keine Sammlung mathematischer Aussagen.
+
+zaehler = 0          # Lasse zaehler zuerst den Wert 0 haben.
+zaehler = zaehler + 1  # Nimm den aktuellen Wert (0), addiere 1, speichere zurueck.
+zaehler = zaehler + 1  # Und noch einmal: aus 1 wird 2.
+
+print("zaehler ist jetzt:", zaehler)
+
+# Mathematisch ergibt "zaehler = zaehler + 1" keinen Sinn.
+# Als Anweisung gelesen heisst es: "Der Name links soll ab jetzt den
+# Wert der rechten Seite tragen."
+
+# Eine Variable kann im Laufe des Programms ihren Wert - und sogar ihre
+# Art von Wert - wechseln:
+inhalt = "ein Text"
+print(inhalt, "->", type(inhalt))
+
+inhalt = 42
+print(inhalt, "->", type(inhalt))
+
+inhalt = 3.5
+print(inhalt, "->", type(inhalt))

Code/vergleiche_und_wahrheit.py

@@ -0,0 +1,21 @@
+# Jede Bedingung ist im Kern eine Frage, die Python mit True (wahr) oder
+# False (falsch) beantwortet. True und False sind ein eigener Datentyp: bool.
+
+alter = 20
+
+print(alter == 20)   # Gleich?            -> True
+print(alter != 20)   # Ungleich?          -> False
+print(alter < 18)    # Kleiner?           -> False
+print(alter >= 18)   # Groesser-gleich?   -> True
+
+# Mit and, or und not lassen sich Bedingungen verknuepfen:
+temperatur = 24
+sonnig = True
+
+print(temperatur > 20 and sonnig)   # beide muessen wahr sein  -> True
+print(temperatur > 30 or sonnig)    # eine reicht              -> True
+print(not sonnig)                   # kehrt um                 -> False
+
+# Genau dieselben Ausdruecke stehen sonst hinter einem "if":
+if temperatur > 20 and sonnig:
+    print("Zeit fuer eine Pause draussen.")