{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# DS 3 – Verzweigungen: Programme treffen Entscheidungen\n",
    "**Informatik 10 – MINT-Zweig | Textuelle Programmierung und Datenstrukturen**\n",
    "\n",
    "## Lernziele\n",
    "Ich kann\n",
    "- erklären, woraus eine Verzweigung besteht, und die Begriffe *Bedingung*, *dann-Teil* und *sonst-Teil* verwenden,\n",
    "- ein-, zwei- und mehrseitige Verzweigungen mit `if`, `else` und `elif` schreiben,\n",
    "- mit der Einrückung festlegen, welche Anweisungen zu einem Block gehören, und Einrückungsfehler beheben,\n",
    "- den Ablauf eines Programms mit Verzweigung in einem Ablaufprotokoll darstellen,\n",
    "- Bedingungen mit `and` und `or` formulieren und Verzweigungen verschachteln."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "sprachhilfe"
    ]
   },
   "source": [
    "## 🗣️ Sprachhilfe\n",
    "- *„Ich bekomme raus, ob die Zahl größer als 4 ist.“*\n",
    "- → „Die Anweisung gibt ‚Die Zahl ist größer als 4.‘ aus, wenn die Zahl größer als 4 ist, und sonst ‚Die Zahl ist nicht größer als 4.‘“\n",
    "- → „Die Alternativanweisung prüft, ob eine Zahl größer als 4 ist. Ist dies der Fall, wird der dann-Teil ausgeführt, sonst der sonst-Teil.“\n",
    "\n",
    "Nützliche Wendungen: *Die Verzweigung besteht aus …* · *Es wird geprüft, ob …* · *Ist die Bedingung erfüllt, wird …*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Worum es geht\n",
    "*Wenn* es regnet, *dann* nehme ich einen Schirm mit. *Wenn* der Bus kommt, steige ich ein, *sonst* warte ich. Bisher hat Python jede Zeile ausgeführt, von oben nach unten. Jetzt lernst du, wie ein Programm abhängig von einer **Bedingung** nur bestimmte Anweisungen ausführt. Aus der Blockprogrammierung kennst du „falls … dann“ und „falls … dann … sonst“.\n",
    "\n",
    "## 1 Die einseitige Verzweigung: `if`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "temperatur = 30\n",
    "if temperatur > 25:\n",
    "    print(\"Es ist heiß. Trink genug Wasser!\")\n",
    "print(\"Schönen Tag!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Zeile 2:** `if` heißt „wenn“ oder „falls“. Python prüft die Bedingung `temperatur > 25`: 30 > 25 ist `True`. Am Ende steht ein **Doppelpunkt**.\n",
    "- **Zeile 3:** Diese Zeile ist **eingerückt** (vier Leerzeichen). Sie gehört zur `if`-Anweisung und wird nur ausgeführt, weil die Bedingung wahr ist.\n",
    "- **Zeile 4:** Nicht eingerückt, wird also in jedem Fall ausgeführt.\n",
    "\n",
    "**🔮 Vorhersage:** Was gibt das Programm bei `temperatur = 18` aus? Überlege zuerst, dann führe die Zelle aus."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "temperatur = 18\n",
    "if temperatur > 25:\n",
    "    print(\"Es ist heiß. Trink genug Wasser!\")\n",
    "print(\"Schönen Tag!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Die Bedingung ist `False`, Python **überspringt** Zeile 3. Anweisungen wie `if`, die den Ablauf steuern, heißen **Kontrollstrukturen**.\n",
    "\n",
    "> 📌 **Definition:** Eine **Bedingung** ist ein Ausdruck, dessen Wert `True` oder `False` ist, z. B. `temperatur > 25`. Eine **Verzweigung** (bedingte Anweisung) ist eine Kontrollstruktur, die abhängig von einer Bedingung festlegt, welche Anweisungen ausgeführt werden.\n",
    "\n",
    "> 📌 **Merksatz:** **Einseitige Verzweigung:** `if Bedingung:` – der eingerückte Block wird nur ausgeführt, wenn die Bedingung `True` ist."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2 Einrückung: Was gehört zum Block?\n",
    "Alle Zeilen direkt unter dem `if`, die gleich weit eingerückt sind, gehören zum Block. **🔮 Vorhersage:** Die beiden Programme unterscheiden sich nur in Zeile 4. Was gibt jedes aus?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "punkte = 3\n",
    "if punkte >= 10:\n",
    "    print(\"Gewonnen!\")\n",
    "    print(\"Du bekommst einen Preis.\")\n",
    "print(\"Spiel beendet.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "punkte = 3\n",
    "if punkte >= 10:\n",
    "    print(\"Gewonnen!\")\n",
    "print(\"Du bekommst einen Preis.\")\n",
    "print(\"Spiel beendet.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Im ersten Programm werden Zeilen 3 und 4 übersprungen. Im zweiten gehört nur Zeile 3 zum Block, und das Programm verteilt einen Preis, obwohl niemand gewonnen hat.\n",
    "\n",
    "> 📌 **Merksatz:** Die **Einrückung** (4 Leerzeichen) bestimmt, welche Anweisungen zu einem Block gehören. Die Zeile mit der Bedingung endet mit einem **Doppelpunkt** `:`.\n",
    "\n",
    "### ⚠️ Stolpersteine: Doppelpunkt und Einrückung\n",
    "Führe die drei Zellen aus und lies jeweils die letzte Zeile der Fehlermeldung."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "zahl = 5\n",
    "if zahl > 0\n",
    "    print(\"positiv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "zahl = 5\n",
    "if zahl > 0:\n",
    "print(\"Die Zahl ist positiv.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "zahl = 5\n",
    "    print(zahl)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. `SyntaxError: expected ':'`: Der Doppelpunkt fehlt, `^` zeigt auf die Stelle.\n",
    "2. `IndentationError: expected an indented block after 'if' statement on line 2`: Nach dem `if` fehlt der eingerückte Block.\n",
    "3. `IndentationError: unexpected indent`: Eine Zeile ist eingerückt, obwohl kein Block mit Doppelpunkt davor steht.\n",
    "\n",
    "> 💡 **Tipp:** Nach einem Doppelpunkt rückt die Umgebung meist automatisch ein. Achte darauf, dass alle Zeilen eines Blocks **genau gleich weit** eingerückt sind."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3 Die zweiseitige Verzweigung: `if` … `else`\n",
    "Soll das Programm in **beiden** Fällen etwas tun, gibt es `else` („sonst“)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "zahl = int(input(\"Gib eine Zahl ein: \"))\n",
    "if zahl > 4:\n",
    "    print(\"Die Zahl ist größer als 4.\")\n",
    "else:\n",
    "    print(\"Die Zahl ist nicht größer als 4.\")\n",
    "print(\"Fertig.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Zeile 3:** der **dann-Teil**, wird ausgeführt, wenn die Bedingung wahr ist.\n",
    "- **Zeile 4:** `else:` steht genau unter dem `if`, hat **keine** eigene Bedingung, aber einen Doppelpunkt.\n",
    "- **Zeile 5:** der **sonst-Teil**, nur wenn die Bedingung falsch ist.\n",
    "\n",
    "Es wird **immer genau einer** der beiden Teile ausgeführt. Deshalb heißt die zweiseitige Verzweigung auch **Alternativanweisung**.\n",
    "\n",
    "Das **Ablaufprotokoll** zeigt, welche Zeilen wirklich ausgeführt werden, links für die Eingabe 7, rechts für 2:\n",
    "\n",
    "| Schritt | Zeile | `zahl` | | Schritt | Zeile | `zahl` |\n",
    "|:-:|:-:|:-:|:-:|:-:|:-:|:-:|\n",
    "| 1 | 1 | `7` | | 1 | 1 | `2` |\n",
    "| 2 | 2 | `7` | | 2 | 2 | `2` |\n",
    "| 3 | 3 | `7` | | 3 | 5 | `2` |\n",
    "| 4 | 6 | `7` | | 4 | 6 | `2` |\n",
    "\n",
    "Die Zeile `else:` selbst tut nichts, deshalb taucht Zeile 4 nicht auf.\n",
    "\n",
    "> 📌 **Merksatz:** **Zweiseitige Verzweigung:** `if … else:` – entweder der **dann-Teil** oder der **sonst-Teil** wird ausgeführt.\n",
    "\n",
    "### 🔮 Übung 1 – Glatteis-Warnung\n",
    "Lies das Programm. Beschreibe in zwei bis drei Sätzen mit Fachbegriffen, was es tut. Gib dann **ohne Ausführen** an, was es bei `-3`, `0` und `5` ausgibt. Überprüfe danach."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "temperatur = int(input(\"Temperatur in Grad Celsius: \"))\n",
    "if temperatur <= 0:\n",
    "    print(\"Achtung, Glatteisgefahr!\")\n",
    "else:\n",
    "    print(\"Keine Glatteisgefahr.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Beschreibung und Ausgaben:**\n",
    "\n",
    "…"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4 Die mehrseitige Verzweigung: `if` … `elif` … `else`\n",
    "Bei mehr als zwei Möglichkeiten gibt es `elif`, kurz für *else if*, „sonst, wenn“."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "note = int(input(\"Punktzahl (0-100) eingeben: \"))\n",
    "if note >= 90:\n",
    "    print(\"Note: sehr gut\")\n",
    "elif note >= 75:\n",
    "    print(\"Note: gut\")\n",
    "elif note >= 50:\n",
    "    print(\"Note: befriedigend\")\n",
    "else:\n",
    "    print(\"Note: nicht bestanden\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Zeile 2:** Ist 80 ≥ 90? Nein.\n",
    "- **Zeile 4:** Weil die erste Bedingung falsch war, wird die nächste geprüft: Ist 80 ≥ 75? Ja.\n",
    "- **Zeile 5:** Der zugehörige Block wird ausgeführt.\n",
    "- **Zeilen 6–9:** Werden übersprungen. Sobald eine Bedingung zutrifft, prüft Python die weiteren **gar nicht mehr**, obwohl auch `80 >= 50` wahr wäre.\n",
    "\n",
    "Der `else`-Teil fängt alle übrigen Fälle auf. Er darf auch fehlen.\n",
    "\n",
    "> 📌 **Merksatz:** **Mehrseitige Verzweigung:** `if … elif … else:` – es wird nur der Block der **ersten** zutreffenden Bedingung ausgeführt. Trifft keine zu, wird der `else`-Block ausgeführt.\n",
    "\n",
    "### ⚠️ Stolperstein: die Reihenfolge\n",
    "**🔮 Vorhersage:** Was gibt das Programm bei 95 Punkten aus?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "note = int(input(\"Punktzahl (0-100) eingeben: \"))\n",
    "if note >= 50:\n",
    "    print(\"Note: befriedigend\")\n",
    "elif note >= 75:\n",
    "    print(\"Note: gut\")\n",
    "elif note >= 90:\n",
    "    print(\"Note: sehr gut\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "95 Punkte, aber nur „befriedigend“: `95 >= 50` ist schon wahr, der Rest wird übersprungen. Regel: Bei `>=` die **größte** Grenze zuerst prüfen, bei `<` die **kleinste**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5 Bedingungen mit `and` und `or`\n",
    "Eine Bedingung darf alles sein, was `True` oder `False` ergibt, also auch Verknüpfungen aus DS 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tag = input(\"Welcher Tag ist heute? \")\n",
    "if tag == \"Samstag\" or tag == \"Sonntag\":\n",
    "    print(\"Wochenende! Ausschlafen.\")\n",
    "else:\n",
    "    print(\"Wecker stellen.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Zeile 1:** Hier wird nicht umgewandelt, denn es soll ein Text verglichen werden.\n",
    "- **Zeile 2:** Wahr, wenn **mindestens einer** der beiden Vergleiche wahr ist.\n",
    "\n",
    "### ⚠️ Stolperstein: abgekürztes `or`\n",
    "**🔮 Vorhersage:** Was gibt das Programm am Montag aus?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tag = input(\"Welcher Tag ist heute? \")\n",
    "if tag == \"Samstag\" or \"Sonntag\":\n",
    "    print(\"Wochenende! Ausschlafen.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python liest `\"Sonntag\"` als eigene Bedingung, und ein nicht leerer Text zählt als wahr. Die Bedingung ist **immer** erfüllt. Schreibe auf **beiden** Seiten von `or` und `and` einen vollständigen Vergleich.\n",
    "\n",
    "> ⚠️ **Stolperstein:** `if zahl = 0:` meldet `SyntaxError: invalid syntax. Maybe you meant '==' or ':=' instead of '='?` Gemeint ist `==`.\n",
    "\n",
    "## 6 Verschachtelte Verzweigungen\n",
    "Im Block einer Verzweigung darf wieder eine Verzweigung stehen. Nur wenn der Benutzername bekannt ist, wird nach dem Passwort gefragt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "benutzer = input(\"Benutzername: \")\n",
    "if benutzer == \"alex\":\n",
    "    passwort = input(\"Passwort: \")\n",
    "    if passwort == \"geheim123\":\n",
    "        print(\"Willkommen, Alex!\")\n",
    "    else:\n",
    "        print(\"Falsches Passwort.\")\n",
    "else:\n",
    "    print(\"Unbekannter Benutzer.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Zeile 2:** Die äußere Verzweigung prüft den Benutzernamen.\n",
    "- **Zeilen 4–7:** die **innere** Verzweigung. Ihre Blöcke sind acht Leerzeichen eingerückt.\n",
    "- **Zeile 8:** Das `else` steht genau unter dem äußeren `if` und gehört deshalb dazu.\n",
    "\n",
    "Ablaufprotokoll für die Eingaben `alex` und `1234` (– heißt: die Variable gibt es noch nicht):\n",
    "\n",
    "| Schritt | Zeile | `benutzer` | `passwort` |\n",
    "|:-:|:-:|:-:|:-:|\n",
    "| 1 | 1 | `\"alex\"` | – |\n",
    "| 2 | 2 | `\"alex\"` | – |\n",
    "| 3 | 3 | `\"alex\"` | `\"1234\"` |\n",
    "| 4 | 4 | `\"alex\"` | `\"1234\"` |\n",
    "| 5 | 7 | `\"alex\"` | `\"1234\"` |\n",
    "\n",
    "> 📌 **Merksatz:** Verzweigungen können **verschachtelt** werden. Die Einrückung zeigt, welcher Block zu welcher Bedingung gehört. Ein `else` gehört zu dem `if`, unter dem es genau steht."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 📝 Übungen: Schritt für Schritt selbstständig\n",
    "Das **Musterbeispiel** ist ganz vorgemacht. Bei Übung 2 füllst du Lücken `___`, bei Übung 3 steht nur noch ein Gerüst aus Kommentaren, die Zusatzaufgabe schreibst du allein.\n",
    "\n",
    "| Schritt | Frage |\n",
    "|:-:|:--|\n",
    "| 1 | **Fälle:** Wie viele Möglichkeiten gibt es? Zwei → `if … else`, mehr → `elif`. |\n",
    "| 2 | **Bedingungen:** Welche Bedingung trennt die Fälle? In welcher Reihenfolge prüfe ich? |\n",
    "| 3 | **Testen:** Welche Eingaben prüfen jeden Fall und jeden **Grenzwert**? |\n",
    "\n",
    "### 🧩 Musterbeispiel (vorgemacht) – Schwimmbad\n",
    "Aufgabe: Das Programm fragt nach dem Alter. Unter 18 kostet der Eintritt 3 Euro, sonst 5 Euro.\n",
    "\n",
    "1. **Fälle:** zwei, also `if … else`.\n",
    "2. **Bedingung:** `alter < 18`. Ist sie wahr, kostet es 3 Euro.\n",
    "3. **Testen:** 12 (jugendlich), 30 (erwachsen) und die Grenzwerte 17 und 18."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "alter = int(input(\"Wie alt bist du? \"))\n",
    "if alter < 18:\n",
    "    print(\"Eintritt: 3 Euro\")\n",
    "else:\n",
    "    print(\"Eintritt: 5 Euro\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| Eingabe | `alter < 18` | Ausgabe |\n",
    "|:-:|:-:|:--|\n",
    "| `12` | `True` | `Eintritt: 3 Euro` |\n",
    "| `17` | `True` | `Eintritt: 3 Euro` |\n",
    "| `18` | `False` | `Eintritt: 5 Euro` |\n",
    "| `30` | `False` | `Eintritt: 5 Euro` |\n",
    "\n",
    "### 📝 Übung 2 – Größte von zwei Zahlen (Lücken füllen)\n",
    "Das Programm liest zwei Zahlen ein und gibt aus, welche größer ist oder ob beide gleich sind. Das sind drei Fälle. Ersetze jedes `___`.\n",
    "\n",
    "Kontrolle: 7 und 3 → erste größer, 3 und 7 → zweite größer, 5 und 5 → gleich."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = float(input(\"Erste Zahl: \"))\n",
    "b = float(input(\"Zweite Zahl: \"))\n",
    "if a ___ b:\n",
    "    print(\"Die erste Zahl ist größer.\")\n",
    "___ b > a:\n",
    "    print(\"Die zweite Zahl ist größer.\")\n",
    "___:\n",
    "    print(\"Beide Zahlen sind gleich.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 📝 Übung 3 – Altersklassen (mit Gerüst)\n",
    "Das Programm liest ein Alter ein und ordnet es ein:\n",
    "- unter 6: „Kleinkind“\n",
    "- 6 bis unter 13: „Kind“\n",
    "- 13 bis unter 18: „Jugendlicher“\n",
    "- ab 18: „Erwachsener“\n",
    "\n",
    "Ersetze die Kommentare durch Programmzeilen. Teste besonders die **Grenzwerte** 5, 6, 12, 13, 17 und 18."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Alter als Ganzzahl einlesen\n",
    "# if: jünger als 6 → Kleinkind\n",
    "# elif: jünger als 13 → Kind\n",
    "# elif: jünger als 18 → Jugendlicher\n",
    "# else → Erwachsener"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 🚀 Zusatzaufgabe – Achterbahn-Check (selbstständig)\n",
    "Regeln für eine Achterbahn:\n",
    "- ab 140 cm: Man darf mitfahren.\n",
    "- 120 cm bis unter 140 cm: nur in Begleitung eines Erwachsenen.\n",
    "- unter 120 cm: nicht mitfahren.\n",
    "\n",
    "Frage die Körpergröße (in cm) und ob eine erwachsene Begleitung dabei ist (`ja`/`nein`). Gib die passende Meldung aus. Nutze eine **verschachtelte** Verzweigung.\n",
    "\n",
    "Kontrolle: 150/nein → mitfahren, 130/ja → in Begleitung, 130/nein → nicht, 110/ja → nicht."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Zusatzaufgabe – Achterbahn-Check"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 📌 Das Wichtigste in Kürze\n",
    "- `if Bedingung:` → Block nur bei `True`. Doppelpunkt nicht vergessen!\n",
    "- Die **Einrückung** (4 Leerzeichen) bestimmt, was zum Block gehört.\n",
    "- `if … else:` → genau einer der beiden Teile wird ausgeführt.\n",
    "- `if … elif … else:` → nur die **erste** zutreffende Bedingung zählt. Reihenfolge beachten!\n",
    "- Bei `or` und `and` auf beiden Seiten einen vollständigen Vergleich schreiben.\n",
    "- Immer die **Grenzwerte** testen.\n",
    "\n",
    "Zum Weiterüben: `DS03_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
}