{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# DS 6 – Die while-Schleife: Wiederholen, solange eine Bedingung gilt\n",
    "**Informatik 10 – MINT-Zweig | Textuelle Programmierung und Datenstrukturen**\n",
    "\n",
    "## Lernziele\n",
    "Ich kann\n",
    "- eine while-Schleife mit Bedingung und eingerücktem Schleifenrumpf schreiben,\n",
    "- den Ablauf einer while-Schleife in einem Ablaufprotokoll darstellen,\n",
    "- eine Endlosschleife erkennen, abbrechen und ihre Ursache beheben,\n",
    "- Eingaben so lange wiederholen lassen, bis sie gültig sind,\n",
    "- Zufallszahlen mit `random.randint` erzeugen,\n",
    "- begründet entscheiden, ob eine for- oder eine while-Schleife besser passt."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "sprachhilfe"
    ]
   },
   "source": [
    "## 🗣️ Sprachhilfe\n",
    "- *„Das läuft, bis man 0 eingibt.“* → „Die Anweisungen im Schleifenrumpf werden wiederholt, solange die eingegebene Zahl ungleich 0 ist.“\n",
    "- *„Dann hört es auf.“* → „Sobald die Bedingung `zahl != 0` falsch ist, terminiert die Schleife, und das Programm gibt die Summe aus.“\n",
    "- *„Das hängt sich auf.“* → „Die Schleife terminiert nicht, weil der Wert der Variablen `i` im Schleifenrumpf nicht erhöht wird.“"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Worum es geht\n",
    "Mit der for-Schleife wiederholst du eine feste Anzahl von Malen. Oft weiß man das vorher nicht: Beim Würfelspiel würfelst du, **bis** eine Sechs kommt. Ein Geldautomat fragt die PIN, **solange** sie falsch ist. Dafür gibt es die **while-Schleife**.\n",
    "\n",
    "## 1 Wiederholen, solange eine Bedingung wahr ist\n",
    "*while* heißt „solange“. Die Bedingung kennst du von `if`: ein Ausdruck, der `True` oder `False` ergibt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i = 1\n",
    "while i <= 3:\n",
    "    print(i)\n",
    "    i = i + 1\n",
    "print(\"Ende\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Zeile 1:** Startwert. Das musst du bei while selbst erledigen.\n",
    "- **Zeile 2:** `while`, Bedingung, Doppelpunkt. Vor **jedem** Durchlauf prüft Python, ob `i <= 3` wahr ist.\n",
    "- **Zeilen 3–4:** der Rumpf. Die Erhöhung in Zeile 4 ist wichtig: Ohne sie bliebe `i` immer `1`.\n",
    "- **Zeile 5:** wird ausgeführt, sobald die Bedingung falsch ist.\n",
    "\n",
    "| Schritt | Zeile | Anweisung | `i` |\n",
    "|:-:|:-:|:--|:-:|\n",
    "| 1 | 1 | `i = 1` | `1` |\n",
    "| 2 | 2 | `while i <= 3:` | `1` |\n",
    "| 3 | 3 | `print(i)` | `1` |\n",
    "| 4 | 4 | `i = i + 1` | `2` |\n",
    "| 5 | 2 | `while i <= 3:` | `2` |\n",
    "| 6 | 3 | `print(i)` | `2` |\n",
    "| 7 | 4 | `i = i + 1` | `3` |\n",
    "| 8 | 2 | `while i <= 3:` | `3` |\n",
    "| 9 | 3 | `print(i)` | `3` |\n",
    "| 10 | 4 | `i = i + 1` | `4` |\n",
    "| 11 | 2 | `while i <= 3:` | `4` |\n",
    "| 12 | 5 | `print(\"Ende\")` | `4` |\n",
    "\n",
    "In Schritt 11 ist `4 <= 3` falsch, die Schleife **endet**. Am Ende hat `i` den Wert `4`, obwohl zuletzt `3` ausgegeben wurde.\n",
    "\n",
    "> 📌 **Definition:** Eine **while-Schleife** (bedingte Schleife) wiederholt ihren Rumpf, **solange** eine Bedingung wahr ist. Die Bedingung wird **vor** jedem Durchlauf geprüft. Ist sie schon beim ersten Mal falsch, wird der Rumpf kein einziges Mal ausgeführt.\n",
    "\n",
    "> 📌 **Merksatz:** Die **while-Schleife** verwendet man, wenn die **Anzahl der Wiederholungen vorher nicht bekannt** ist. Syntax: `while Bedingung:` und darunter der eingerückte Block."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2 Zahlen addieren, bis 0 eingegeben wird\n",
    "Hier hilft die for-Schleife nicht: Wie viele Zahlen es sind, entscheidet die Nutzerin beim Eintippen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "summe = 0\n",
    "zahl = int(input(\"Zahl eingeben (0 zum Beenden): \"))\n",
    "while zahl != 0:\n",
    "    summe = summe + zahl\n",
    "    zahl = int(input(\"Zahl eingeben (0 zum Beenden): \"))\n",
    "print(\"Summe aller Eingaben:\", summe)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Zeile 2:** Die **erste** Zahl wird **vor** der Schleife eingelesen. Sonst hätte `zahl` in Zeile 3 noch keinen Wert.\n",
    "- **Zeile 3:** Solange die Zahl nicht 0 ist, wird der Rumpf ausgeführt.\n",
    "- **Zeile 5:** Die **nächste** Zahl wird eingelesen. Diese Zeile sorgt dafür, dass sich die Bedingung ändern kann.\n",
    "\n",
    "Ablaufprotokoll für die Eingaben 4, 7, 2, 0:\n",
    "\n",
    "| Schritt | Zeile | `zahl` | `summe` |\n",
    "|:-:|:-:|:-:|:-:|\n",
    "| 1 | 1 | – | `0` |\n",
    "| 2 | 2 | `4` | `0` |\n",
    "| 3 | 3 | `4` | `0` |\n",
    "| 4 | 4 | `4` | `4` |\n",
    "| 5 | 5 | `7` | `4` |\n",
    "| 6 | 3 | `7` | `4` |\n",
    "| 7 | 4 | `7` | `11` |\n",
    "| 8 | 5 | `2` | `11` |\n",
    "| 9 | 3 | `2` | `11` |\n",
    "| 10 | 4 | `2` | `13` |\n",
    "| 11 | 5 | `0` | `13` |\n",
    "| 12 | 3 | `0` | `13` |\n",
    "| 13 | 6 | `0` | `13` |\n",
    "\n",
    "> 💡 **Muster für Schleifen mit Eingaben:** 1. **vor** der Schleife die erste Eingabe einlesen, 2. im Kopf die Eingabe prüfen, 3. **am Ende** des Rumpfs die nächste Eingabe einlesen.\n",
    "\n",
    "**🧪 Probiere es aus:** Gib gleich als Erstes `0` ein. Warum wird der Rumpf kein einziges Mal ausgeführt?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3 Endlosschleifen\n",
    "Bei while bist **du** dafür verantwortlich, dass die Bedingung irgendwann falsch wird. Ein Countdown soll von 3 herunterzählen. **🔮 Findest du den Fehler, bevor du die Zelle startest?**\n",
    "\n",
    "Führe die Zelle aus und **brich sie ab**: in Jupyter mit der Stopp-Schaltfläche (Quadrat) oben, in VS Code mit „Interrupt“. Links neben der Zelle steht so lange ein Sternchen `[*]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "zahl = 3\n",
    "while zahl > 0:\n",
    "    print(zahl)\n",
    "    zahl = zahl + 1\n",
    "print(\"Start!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Zeile 4 wird `zahl` erhöht statt verringert, `zahl > 0` bleibt für immer wahr. Richtig wäre `zahl = zahl - 1`. Beim Abbrechen meldet Python `KeyboardInterrupt`: Das ist kein Fehler im Code, nur die Bestätigung, dass du angehalten hast.\n",
    "\n",
    "> 📌 **Definition:** Eine **Endlosschleife** ist eine Schleife, deren Bedingung nie falsch wird. Sie **terminiert nicht**.\n",
    "\n",
    "> 📌 **Merksatz:** Die Bedingung muss sich **innerhalb der Schleife verändern** können, sonst entsteht eine Endlosschleife.\n",
    "\n",
    "**So findest du die Ursache:**\n",
    "1. Welche Variablen stehen in der Bedingung?\n",
    "2. Wird mindestens eine davon **im Rumpf** verändert (`i = i + 1`, neues `input(...)`)?\n",
    "3. In die **richtige Richtung**?\n",
    "4. Steht die Änderung wirklich **eingerückt** im Rumpf?\n",
    "\n",
    "### 🐞 Übung 1 – Endlosschleife reparieren\n",
    "Der Code enthält eine Endlosschleife. Ändere **nicht** die Bedingung `i < 10`, sondern behebe den Fehler im Rumpf. Kontrolle: Ausgabe 0 bis 9. (Vorsicht beim Starten der unveränderten Zelle: abbrechen!)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i = 0\n",
    "while i < 10:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4 Eingaben prüfen: Wiederholen, bis die Eingabe stimmt\n",
    "Das Programm akzeptiert nur Schulnoten von 1 bis 6. Wie oft sich jemand vertippt, weiß man vorher nicht."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "note = int(input(\"Gib deine Note ein (1 bis 6): \"))\n",
    "while note < 1 or note > 6:\n",
    "    print(\"Ungültig! Erlaubt sind nur 1 bis 6.\")\n",
    "    note = int(input(\"Gib deine Note ein (1 bis 6): \"))\n",
    "print(\"Gespeichert: Note\", note)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Zeile 2:** Die Bedingung beschreibt eine **ungültige** Eingabe. Solange das zutrifft, wird wiederholt.\n",
    "- **Zeile 5:** Hier kommt das Programm nur an, wenn die Note gültig ist.\n",
    "\n",
    "> 💡 **Tipp:** Frage dich: „**Wann muss ich noch einmal fragen?**“ Die Antwort ist die Bedingung der while-Schleife.\n",
    "\n",
    "## 5 Zufallszahlen\n",
    "> 🧰 **Werkzeug:** Das **Modul** `random` ist eine Sammlung von Befehlen rund um den Zufall. Schreibe **einmal am Anfang** `import random`. Dann liefert `random.randint(a, b)` eine zufällige ganze Zahl von `a` bis `b`. Anders als bei `range` gehören **beide** Grenzen dazu: `random.randint(1, 6)` ist ein Würfel.\n",
    "\n",
    "Das Programm würfelt, bis eine Sechs fällt, und zählt die Würfe. Starte die Zelle mehrmals."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "wurf = random.randint(1, 6)\n",
    "anzahl = 1\n",
    "print(\"Gewürfelt:\", wurf)\n",
    "while wurf != 6:\n",
    "    wurf = random.randint(1, 6)\n",
    "    anzahl += 1\n",
    "    print(\"Gewürfelt:\", wurf)\n",
    "print(\"Endlich eine Sechs! Anzahl der Würfe:\", anzahl)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Zeilen 2–4:** Der erste Wurf wird vor der Schleife ausgeführt, gezählt und ausgegeben.\n",
    "- **Zeilen 6–8:** Neu würfeln, Zähler erhöhen, ausgeben. Durch das neue Würfeln kann sich die Bedingung ändern.\n",
    "\n",
    "## 6 for oder while?\n",
    "**🔮 Vorhersage:** Geben beide Zellen dasselbe aus?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(1, 4):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i = 1\n",
    "while i <= 3:\n",
    "    print(i)\n",
    "    i = i + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ja. Die for-Schleife ist aber kürzer und sicherer: Startwert, Bedingung und Erhöhung stecken alle in `range(1, 4)`. Für „würfle bis zur Sechs“ passt for nicht, weil `range` eine feste Anzahl braucht. Die entscheidende Frage: **Steht beim Start der Schleife fest, wie oft wiederholt wird?** (Das gilt auch, wenn die Anzahl vorher eingegeben wurde.)\n",
    "\n",
    "| Situation | Schleife | Begründung |\n",
    "|:--|:-:|:--|\n",
    "| Zahlen von 1 bis 100 ausgeben | `for` | genau 100 Durchläufe |\n",
    "| Summe von 1 bis `n`, `n` wird eingegeben | `for` | beim Start der Schleife steht `n` fest |\n",
    "| Zahlen addieren, bis 0 eingegeben wird | `while` | Ende hängt von der Eingabe ab |\n",
    "| Eingabe wiederholen, bis sie gültig ist | `while` | Anzahl der Fehlversuche unbekannt |\n",
    "| würfeln, bis eine Sechs fällt | `while` | Ende hängt vom Zufall ab |\n",
    "\n",
    "> 📌 **Merksatz:** Anzahl der Durchläufe vorher bekannt → `for`. Ende hängt von einer Bedingung oder Eingabe ab → `while`.\n",
    "\n",
    "### ✏️ Übung 2 – for oder while?\n",
    "Entscheide und begründe kurz. Du musst die Programme nicht schreiben.\n",
    "\n",
    "| Situation | for oder while? | Begründung |\n",
    "|:--|:-:|:--|\n",
    "| a) 20-mal „Hallo“ ausgeben | | |\n",
    "| b) Wörter einlesen, bis „stopp“ eingegeben wird | | |\n",
    "| c) das Einmaleins einer eingegebenen Zahl ausgeben | | |\n",
    "| d) 100 € wachsen jedes Jahr um 5 %: Nach wie vielen Jahren sind es mindestens 200 €? | | |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 📝 Übungen: Schritt für Schritt selbstständig\n",
    "Das **Musterbeispiel** ist ganz vorgemacht. Bei Übung 3 füllst du Lücken `___`, bei Übung 4 steht nur noch ein Gerüst aus Kommentaren, die Zusatzaufgabe schreibst du allein.\n",
    "\n",
    "| Schritt | Frage |\n",
    "|:-:|:--|\n",
    "| 1 | **Vor der Schleife:** Welche Variablen brauchen einen Startwert? Welche erste Eingabe? |\n",
    "| 2 | **Bedingung:** Wann muss die Schleife **noch einmal** laufen? |\n",
    "| 3 | **Rumpf:** Was passiert pro Durchlauf? Was ändert die Bedingung (neue Eingabe, Erhöhung)? |\n",
    "| 4 | **Nach der Schleife:** Was wird einmal am Ende ausgegeben? |\n",
    "\n",
    "### 🧩 Musterbeispiel (vorgemacht) – Wörter zählen\n",
    "Aufgabe: Das Programm liest Wörter ein, bis „stopp“ eingegeben wird. Am Ende gibt es aus, wie viele Wörter es waren (ohne „stopp“).\n",
    "\n",
    "1. **Vor der Schleife:** Zähler `anzahl = 0`, erstes Wort einlesen.\n",
    "2. **Bedingung:** noch einmal, solange das Wort nicht „stopp“ ist: `wort != \"stopp\"`.\n",
    "3. **Rumpf:** Zähler um 1 erhöhen, **am Ende** das nächste Wort einlesen.\n",
    "4. **Nach der Schleife:** die Anzahl ausgeben."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Schritt 1: vor der Schleife\n",
    "anzahl = 0\n",
    "wort = input(\"Wort (stopp zum Beenden): \")\n",
    "\n",
    "# Schritt 2: Bedingung\n",
    "while wort != \"stopp\":\n",
    "    # Schritt 3: Rumpf\n",
    "    anzahl += 1\n",
    "    wort = input(\"Wort (stopp zum Beenden): \")\n",
    "\n",
    "# Schritt 4: nach der Schleife\n",
    "print(\"Du hast\", anzahl, \"Wörter eingegeben.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Testfälle: Hund, Katze, Maus, stopp → 3 Wörter. Sofort `stopp` → 0 Wörter, der Rumpf läuft kein einziges Mal.\n",
    "\n",
    "### 📝 Übung 3 – Zahl erraten (Lücken füllen)\n",
    "Die geheime Zahl ist im Code festgelegt. Man darf so lange raten, bis sie stimmt. Nach jedem Versuch kommt „zu hoch“ oder „zu niedrig“. Ersetze jedes `___`.\n",
    "\n",
    "Kontrolle: 50 → zu hoch, 30 → zu niedrig, 42 → Richtig geraten!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "geheim = 42\n",
    "versuch = int(input(\"Rate die Zahl: \"))\n",
    "while versuch ___ geheim:\n",
    "    if versuch < geheim:\n",
    "        print(___)\n",
    "    else:\n",
    "        print(___)\n",
    "    versuch = ___\n",
    "print(\"Richtig geraten!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 📝 Übung 4 – Quersumme (mit Gerüst)\n",
    "Berechne mit einer while-Schleife die Quersumme einer eingegebenen Zahl. Beispiel: Die Quersumme von 384 ist 3 + 8 + 4 = 15.\n",
    "\n",
    "> 💡 **Tipp:** `384 % 10` ergibt `4` (die letzte Ziffer), `384 // 10` ergibt `38` (die letzte Ziffer ist weg). Mit `38` bekommst du `8` und `3`, mit `3` bekommst du `3` und `0`. Bei `0` ist keine Ziffer mehr übrig: Das ist deine Abbruchbedingung.\n",
    "\n",
    "Ersetze die Kommentare durch Programmzeilen. Weitere Kontrollwerte: 7 → 7, 1000 → 1, 99999 → 45."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Zahl einlesen\n",
    "# Quersumme mit Startwert 0\n",
    "# solange noch Ziffern übrig sind:\n",
    "#     letzte Ziffer zur Quersumme addieren\n",
    "#     letzte Ziffer abschneiden\n",
    "# Quersumme ausgeben"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 🚀 Zusatzaufgabe – Ratespiel mit Zufallszahl (selbstständig)\n",
    "Erweitere dein Programm aus Übung 3:\n",
    "1. Die geheime Zahl wird mit `random.randint` zufällig zwischen 1 und 100 gewählt.\n",
    "2. Das Programm zählt die Versuche und gibt am Ende aus, wie viele es waren.\n",
    "\n",
    "> 💡 **Tipp zum Testen:** Lass die geheime Zahl vorübergehend mit `print(geheim)` ausgeben und lösche die Zeile danach."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Zusatzaufgabe – Ratespiel mit Zufallszahl"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 📌 Das Wichtigste in Kürze\n",
    "- `while Bedingung:` wiederholt den Rumpf, **solange** die Bedingung wahr ist. Sie wird **vor** jedem Durchlauf geprüft.\n",
    "- Startwerte setzt du selbst, und im Rumpf muss sich die Bedingung ändern können, sonst **Endlosschleife**.\n",
    "- Muster mit Eingaben: erste Eingabe vor der Schleife, nächste Eingabe am Ende des Rumpfs.\n",
    "- `import random`, dann `random.randint(a, b)`: Zufallszahl von `a` bis `b`, beide Grenzen inklusive.\n",
    "- Anzahl bekannt → `for`, Ende hängt von Bedingung ab → `while`.\n",
    "\n",
    "Zum Weiterüben: `DS06_Weitere_Uebungen.ipynb`."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "name": "python",
   "version": "3.11"
  },
  "v3_revision": {
   "basis": "MINT-Lehrplan Informatik 10 (2026)",
   "didaktik": "fragend-entwickelnder Kern, kurzer Transfer, flexible Reserve",
   "lerngruppe": "11 SuS"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}