{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# DS 5 – Die for-Schleife: Anweisungen wiederholen\n",
    "**Informatik 10 – MINT-Zweig | Textuelle Programmierung und Datenstrukturen**\n",
    "\n",
    "## Lernziele\n",
    "Ich kann\n",
    "- erklären, was eine Schleife ist und wann man eine for-Schleife verwendet,\n",
    "- eine for-Schleife mit Schleifenkopf und eingerücktem Schleifenrumpf schreiben,\n",
    "- mit `range` Zahlenfolgen erzeugen, auch mit eigenem Start und eigener Schrittweite,\n",
    "- mit einer Schleife eine Summe berechnen und dabei `+=` verwenden,\n",
    "- den Ablauf einer Schleife in einem Ablaufprotokoll Schritt für Schritt verfolgen."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "sprachhilfe"
    ]
   },
   "source": [
    "## 🗣️ Sprachhilfe\n",
    "- *„Das wird fünfmal gemacht.“* → „Die Anweisungen im Schleifenrumpf werden fünfmal wiederholt.“\n",
    "- *„i wird immer eins mehr.“* → „Der Wert der Zählvariablen `i` wird bei jedem Durchlauf um 1 erhöht.“\n",
    "- *„Da kommt 15 raus.“* → „Die Schleife addiert die Zahlen von 1 bis 5 zur Summenvariablen. Nach der Schleife gibt das Programm den Wert 15 aus.“"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Worum es geht\n",
    "Dein Programm soll die Zahlen von 1 bis 100 ausgeben. Bisher bräuchtest du 100 `print`-Zeilen. Besser wäre: „Wiederhole das 100-mal.“ Aus der Blockprogrammierung kennst du „wiederhole 10-mal“. In Python heißt das **for-Schleife**.\n",
    "\n",
    "## 1 Wiederholen statt abschreiben"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(3):\n",
    "    print(\"Hallo!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Zeile 1:** der **Schleifenkopf**: „Mache das Folgende dreimal.“ Er endet mit einem **Doppelpunkt**.\n",
    "- **Zeile 2:** **eingerückt**. Alles, was eingerückt unter dem Kopf steht, wird wiederholt. Das ist der **Schleifenrumpf**.\n",
    "\n",
    "**🧪 Probiere es aus:** Schreibe statt `3` die Zahl `100`.\n",
    "\n",
    "> 📌 **Definition:** Eine **Schleife** ist eine Kontrollstruktur, die einen Block von Anweisungen (den **Schleifenrumpf**) mehrfach ausführt. Jede Ausführung heißt **Durchlauf**. Bei einer **for-Schleife** (Zählschleife) steht die Anzahl der Durchläufe schon vor dem Start fest.\n",
    "\n",
    "> 📌 **Merksatz:** Die **for-Schleife** verwendet man, wenn die **Anzahl der Wiederholungen vorher bekannt** ist."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2 Aufbau einer for-Schleife\n",
    "### Die Zählvariable\n",
    "Im Kopf steht eine Variable, hier `i`, die **Zählvariable**. Bei jedem Durchlauf bekommt sie automatisch den nächsten Wert."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(1, 4):\n",
    "    print(\"Runde\", i)\n",
    "print(\"Fertig\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Zeile 1:** `range(1, 4)` liefert der Reihe nach `1`, `2` und `3`.\n",
    "- **Zeile 2:** Der Rumpf gibt in jedem Durchlauf den aktuellen Wert von `i` aus.\n",
    "- **Zeile 3:** **Nicht** eingerückt. Sie wird erst ausgeführt, wenn die Schleife fertig ist, und nur einmal.\n",
    "\n",
    "Stell dir eine Läuferin auf der Bahn vor: Sie läuft ihre Runden und zählt mit. Nach der letzten Runde geht sie zur Bank (Zeile 3).\n",
    "\n",
    "| Schritt | Zeile | Anweisung | `i` |\n",
    "|:-:|:-:|:--|:-:|\n",
    "| 1 | 1 | `for i in range(1, 4):` | `1` |\n",
    "| 2 | 2 | `print(\"Runde\", i)` | `1` |\n",
    "| 3 | 1 | `for i in range(1, 4):` | `2` |\n",
    "| 4 | 2 | `print(\"Runde\", i)` | `2` |\n",
    "| 5 | 1 | `for i in range(1, 4):` | `3` |\n",
    "| 6 | 2 | `print(\"Runde\", i)` | `3` |\n",
    "| 7 | 1 | `for i in range(1, 4):` | `3` |\n",
    "| 8 | 3 | `print(\"Fertig\")` | `3` |\n",
    "\n",
    "- Nach dem Rumpf springt Python **zurück zum Kopf**. Dort bekommt `i` den nächsten Wert.\n",
    "- In Schritt 7 liefert `range` keine Zahl mehr. Die Schleife endet, `i` behält den Wert `3`.\n",
    "- Der Kopf wird viermal ausgeführt, der Rumpf dreimal.\n",
    "\n",
    "> 📌 **Merksatz:** Die **Zählvariable** bekommt bei jedem Durchlauf automatisch den nächsten Wert. Du musst sie nicht selbst erhöhen.\n",
    "\n",
    "### Einrückung: Was gehört zur Schleife?\n",
    "**🔮 Vorhersage:** Die beiden Programme unterscheiden sich nur in der letzten Zeile. Was gibt jedes aus?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(3):\n",
    "    print(\"Ich übe Python.\")\n",
    "    print(\"Das macht Spaß!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(3):\n",
    "    print(\"Ich übe Python.\")\n",
    "print(\"Das macht Spaß!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ⚠️ Stolpersteine: Einrückung und Doppelpunkt\n",
    "Führe beide Zellen aus und lies die letzte Zeile der Fehlermeldung."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(3):\n",
    "print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(3)\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. `IndentationError: expected an indented block after 'for' statement on line 1`: Der Rumpf muss eingerückt sein.\n",
    "2. `SyntaxError: expected ':'`: Am Ende des Kopfes fehlt der Doppelpunkt."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3 Zahlenfolgen mit `range`\n",
    "`range` („Bereich“) erzeugt eine Folge ganzer Zahlen.\n",
    "- **`range(stop)`** beginnt bei `0` und endet **vor** `stop`.\n",
    "- **`range(start, stop)`** beginnt bei `start` und endet **vor** `stop`.\n",
    "- **`range(start, stop, schritt)`** zählt mit der **Schrittweite** `schritt`, negativ heißt rückwärts.\n",
    "\n",
    "| Aufruf | erzeugt die Zahlen | Anzahl |\n",
    "|:--|:--|:-:|\n",
    "| `range(5)` | 0, 1, 2, 3, 4 | 5 |\n",
    "| `range(1, 6)` | 1, 2, 3, 4, 5 | 5 |\n",
    "| `range(3, 8)` | 3, 4, 5, 6, 7 | 5 |\n",
    "| `range(0, 10, 2)` | 0, 2, 4, 6, 8 | 5 |\n",
    "| `range(1, 10, 3)` | 1, 4, 7 | 3 |\n",
    "| `range(10, 0, -1)` | 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 | 10 |\n",
    "| `range(5, 1)` | keine Zahl (die Schleife läuft gar nicht) | 0 |\n",
    "\n",
    "> 📌 **Merksatz:** `range(n)` erzeugt `0, 1, …, n-1`. `range(start, stop)` erzeugt `start` bis `stop-1`. `range(start, stop, schritt)` erlaubt eine eigene Schrittweite.\n",
    "\n",
    "> 💡 **Tipp:** `stop` ist wie die Ziellinie: Man zählt bis kurz davor. Bei `range(start, stop)` gibt es genau `stop - start` Zahlen.\n",
    "\n",
    "### Zahlen ausgeben und das Einmaleins\n",
    "**🔮 Vorhersage:** Überlege zuerst, was das Programm ausgibt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(1, 6):\n",
    "    print(i)\n",
    "print(\"---\")\n",
    "for i in range(1, 11):\n",
    "    print(\"7 *\", i, \"=\", 7 * i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Zeilen 1–2:** Für „1 bis 5“ braucht man `range(1, 6)`.\n",
    "- **Zeile 3:** nicht eingerückt, wird einmal ausgegeben.\n",
    "- **Zeilen 4–5:** `7 * i` wird in jedem Durchlauf neu ausgerechnet. Beide Schleifen dürfen `i` benutzen.\n",
    "\n",
    "### Rückwärts zählen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(5, 0, -1):\n",
    "    print(i)\n",
    "print(\"Start!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> ⚠️ **Stolperstein:** `range(1, 10)` erzeugt die Zahlen von 1 bis **9**. Python meldet keinen Fehler. Prüfe immer die erste und die letzte Zahl der Ausgabe. Für „1 bis 10“ schreibst du `range(1, 11)`.\n",
    "\n",
    "### 🔮 Übung 1 – range-Detektiv\n",
    "1. Welche Zahlen erzeugen die Aufrufe? Erst im Kopf, dann in der Codezelle prüfen.\n",
    "2. Gib zu den Zahlenfolgen einen passenden `range`-Aufruf an.\n",
    "\n",
    "| Aufruf | erzeugt die Zahlen |\n",
    "|:--|:--|\n",
    "| `range(4)` | |\n",
    "| `range(2, 7)` | |\n",
    "| `range(5, 30, 5)` | |\n",
    "| `range(9, 3, -2)` | |\n",
    "\n",
    "| Zahlenfolge | Aufruf |\n",
    "|:--|:--|\n",
    "| 1, 2, 3, 4, 5, 6, 7, 8 | |\n",
    "| 10, 20, 30, 40, 50 | |\n",
    "| 3, 2, 1, 0 | |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Prüfe hier jeden Aufruf, indem du die Zahl in range(...) änderst\n",
    "for i in range(4):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ✏️ Übung 2 – Zahlenreihe\n",
    "Gib alle geraden Zahlen von 2 bis 20 aus. Tipp: Schrittweite nutzen. Prüfe die erste und die letzte Zahl!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(___, ___, ___):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4 Summen bilden\n",
    "Denk an eine Kasse: Am Anfang steht die Anzeige auf 0. Bei jedem Artikel kommt sein Preis dazu. Am Ende steht der Gesamtbetrag da. Im Programm brauchst du dafür eine **Summenvariable** (Fachwort **Akkumulator**, lateinisch *accumulare* = anhäufen)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "summe = 0\n",
    "for i in range(1, 6):\n",
    "    summe = summe + i\n",
    "print(\"Summe:\", summe)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Zeile 1:** Startwert `0`, die Kasse ist leer.\n",
    "- **Zeile 3:** Der aktuelle Wert von `i` kommt zur bisherigen Summe dazu, wie `alter = alter + 1`.\n",
    "- **Zeile 4:** nicht eingerückt, die Summe wird einmal am Ende ausgegeben.\n",
    "\n",
    "Lies im Ablaufprotokoll die Spalte `summe` von oben nach unten: 0, 1, 3, 6, 10, 15.\n",
    "\n",
    "| Schritt | Zeile | Anweisung | `i` | `summe` |\n",
    "|:-:|:-:|:--|:-:|:-:|\n",
    "| 1 | 1 | `summe = 0` | – | `0` |\n",
    "| 2 | 2 | `for i in range(1, 6):` | `1` | `0` |\n",
    "| 3 | 3 | `summe = summe + i` | `1` | `1` |\n",
    "| 4 | 2 | `for i in range(1, 6):` | `2` | `1` |\n",
    "| 5 | 3 | `summe = summe + i` | `2` | `3` |\n",
    "| 6 | 2 | `for i in range(1, 6):` | `3` | `3` |\n",
    "| 7 | 3 | `summe = summe + i` | `3` | `6` |\n",
    "| 8 | 2 | `for i in range(1, 6):` | `4` | `6` |\n",
    "| 9 | 3 | `summe = summe + i` | `4` | `10` |\n",
    "| 10 | 2 | `for i in range(1, 6):` | `5` | `10` |\n",
    "| 11 | 3 | `summe = summe + i` | `5` | `15` |\n",
    "| 12 | 2 | `for i in range(1, 6):` | `5` | `15` |\n",
    "| 13 | 4 | `print(\"Summe:\", summe)` | `5` | `15` |\n",
    "\n",
    "> 📌 **Merksatz:** Eine Summe berechnet man in drei Schritten: **vor** der Schleife `summe = 0`, **in** der Schleife `summe = summe + zahl`, **nach** der Schleife das Ergebnis ausgeben.\n",
    "\n",
    "### Die Kurzschreibweise `+=`\n",
    "`summe += i` heißt „`summe` wird um `i` erhöht“ und bewirkt dasselbe wie `summe = summe + i`.\n",
    "\n",
    "| Kurzschreibweise | bedeutet | Beispiel (vorher `x = 10`) |\n",
    "|:--|:--|:--|\n",
    "| `x += 3` | `x = x + 3` | `x` ist danach `13` |\n",
    "| `x -= 3` | `x = x - 3` | `x` ist danach `7` |\n",
    "| `x *= 3` | `x = x * 3` | `x` ist danach `30` |\n",
    "\n",
    "### ⚠️ Stolpersteine beim Summieren\n",
    "**🔮 Vorhersage:** Was geben die beiden Programme aus? Vergleiche mit dem richtigen Programm oben."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(1, 6):\n",
    "    summe = 0\n",
    "    summe = summe + i\n",
    "print(\"Summe:\", summe)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "summe = 0\n",
    "for i in range(1, 6):\n",
    "    summe = summe + i\n",
    "    print(\"Summe:\", summe)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Der Startwert steht **in** der Schleife: Die Summe wird jedes Mal auf 0 gesetzt, am Ende steht nur die letzte Zahl 5 darin.\n",
    "2. Die Ausgabe ist eingerückt: Nach jedem Durchlauf kommt eine Zwischensumme. Das ist zum Nachprüfen nützlich, ist aber nur das Ergebnis gefragt, gehört `print` nach der Schleife.\n",
    "\n",
    "### Die Obergrenze eingeben lassen\n",
    "`range` arbeitet nur mit ganzen Zahlen, deshalb `int(...)`. Damit `n` selbst mitgezählt wird, ist der Stoppwert `n + 1`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = int(input(\"Bis zu welcher Zahl soll ich addieren? \"))\n",
    "summe = 0\n",
    "for i in range(1, n + 1):\n",
    "    summe += i\n",
    "print(\"Die Summe von 1 bis\", n, \"ist\", summe)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> ⚠️ **Stolperstein:** Ohne `int(...)` ist `n` ein Text: `TypeError: 'str' object cannot be interpreted as an integer`. Mit `float` heißt es `'float'`. `range` braucht **ganze Zahlen**.\n",
    "\n",
    "### 🔮 Übung 3 – Ablaufprotokoll\n",
    "Fülle das Ablaufprotokoll aus, **ohne** das Programm auszuführen (– heißt: noch kein Wert). Gib dann an, was es ausgibt. Prüfe danach."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 0\n",
    "for i in range(3):\n",
    "    x = x + 2 * i\n",
    "print(\"x =\", x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| Schritt | Zeile | Anweisung | `i` | `x` |\n",
    "|:-:|:-:|:--|:-:|:-:|\n",
    "| 1 | 1 | `x = 0` | – | |\n",
    "| 2 | 2 | `for i in range(3):` | | |\n",
    "| 3 | 3 | `x = x + 2 * i` | | |\n",
    "| 4 | 2 | `for i in range(3):` | | |\n",
    "| 5 | 3 | `x = x + 2 * i` | | |\n",
    "| 6 | 2 | `for i in range(3):` | | |\n",
    "| 7 | 3 | `x = x + 2 * i` | | |\n",
    "| 8 | 2 | `for i in range(3):` | | |\n",
    "| 9 | 4 | `print(\"x =\", x)` | | |\n",
    "\n",
    "**Ausgabe:** …"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 📝 Übungen: Schritt für Schritt selbstständig\n",
    "Das **Musterbeispiel** ist ganz vorgemacht. Bei Übung 4 füllst du Lücken `___`, bei Übung 5 steht nur noch ein Gerüst aus Kommentaren, die Zusatzaufgabe schreibst du allein.\n",
    "\n",
    "| Schritt | Frage |\n",
    "|:-:|:--|\n",
    "| 1 | **Vor der Schleife:** Welche Variable braucht einen Startwert? |\n",
    "| 2 | **Schleifenkopf:** Welche Zahlen soll `i` annehmen? Erste und letzte Zahl prüfen! |\n",
    "| 3 | **Rumpf:** Was passiert in jedem Durchlauf? |\n",
    "| 4 | **Nach der Schleife:** Was wird einmal am Ende ausgegeben? |\n",
    "\n",
    "### 🧩 Musterbeispiel (vorgemacht) – Summe der geraden Zahlen\n",
    "Aufgabe: Berechne die Summe der geraden Zahlen von 2 bis 10, also 2 + 4 + 6 + 8 + 10.\n",
    "\n",
    "1. **Vor der Schleife:** `summe = 0`.\n",
    "2. **Schleifenkopf:** `i` soll 2, 4, 6, 8, 10 sein. Start 2, Schrittweite 2, und der Stoppwert muss **größer** als 10 sein: `range(2, 11, 2)`.\n",
    "3. **Rumpf:** `summe += i`.\n",
    "4. **Nach der Schleife:** nicht eingerückt `print`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Schritt 1: vor der Schleife\n",
    "summe = 0\n",
    "\n",
    "# Schritt 2 und 3: Schleifenkopf und Rumpf\n",
    "for i in range(2, 11, 2):\n",
    "    summe += i\n",
    "\n",
    "# Schritt 4: nach der Schleife\n",
    "print(\"Summe der geraden Zahlen von 2 bis 10:\", summe)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kontrolle von Hand: 2 + 4 + 6 + 8 + 10 = 30.\n",
    "\n",
    "### 📝 Übung 4 – Summe von 1 bis 100 (Lücken füllen)\n",
    "Berechne die Summe aller Zahlen von 1 bis 100, ohne eine fertige Summenfunktion. Ersetze jedes `___`. Kontrolle: Wer `4950` erhält, hat die 100 vergessen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "summe = ___\n",
    "for i in range(___, ___):\n",
    "    summe ___ i\n",
    "print(\"Summe:\", ___)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 📝 Übung 5 – Quadratzahlen (mit Gerüst)\n",
    "Lies eine Zahl `n` ein. Gib für jede Zahl von 1 bis `n` ihre Quadratzahl aus und am Ende die Summe aller Quadratzahlen. Ersetze die Kommentare durch Programmzeilen.\n",
    "\n",
    "```\n",
    "Bis zu welcher Zahl? 4\n",
    "1 zum Quadrat ist 1\n",
    "2 zum Quadrat ist 4\n",
    "3 zum Quadrat ist 9\n",
    "4 zum Quadrat ist 16\n",
    "Summe der Quadratzahlen: 30\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# n als Ganzzahl einlesen\n",
    "# Summenvariable mit Startwert\n",
    "# Schleife: i von 1 bis n (Stoppwert beachten!)\n",
    "#     Quadratzahl ausgeben\n",
    "#     Quadratzahl zur Summe addieren\n",
    "# nach der Schleife: Summe ausgeben"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 🚀 Zusatzaufgabe – Sternendreieck (selbstständig)\n",
    "> 🧰 **Werkzeug:** Ein Text mal eine ganze Zahl hängt den Text so oft hintereinander: `\"ab\" * 3` ergibt `ababab`, `\"-\" * 20` ergibt 20 Striche. Die Zahl darf auch die Zählvariable sein.\n",
    "\n",
    "Gib mit einer for-Schleife dieses Muster aus:\n",
    "```\n",
    "*\n",
    "**\n",
    "***\n",
    "****\n",
    "*****\n",
    "```\n",
    "Für Schnelle: Gib das Dreieck auch auf dem Kopf aus."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Zusatzaufgabe – Sternendreieck"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 📌 Das Wichtigste in Kürze\n",
    "- Die **for-Schleife** wiederholt den eingerückten **Rumpf**, wenn die Anzahl der Durchläufe vorher feststeht.\n",
    "- Die **Zählvariable** bekommt bei jedem Durchlauf automatisch den nächsten Wert.\n",
    "- `range(stop)`, `range(start, stop)`, `range(start, stop, schritt)`: `stop` gehört **nie** dazu.\n",
    "- Summe: vor der Schleife `summe = 0`, in der Schleife `summe += zahl`, danach ausgeben.\n",
    "- `range` braucht ganze Zahlen, Eingaben also mit `int(...)` umwandeln.\n",
    "\n",
    "Zum Weiterüben: `DS05_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
}