{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# DS 4 – Übung: Verzweigungen lesen, testen und erweitern\n",
    "**Informatik 10 – MINT-Zweig | Textuelle Programmierung und Datenstrukturen**\n",
    "\n",
    "## Lernziele\n",
    "Ich kann\n",
    "- Fehler in Programmen mit Verzweigungen finden, mit Hilfe der Fehlermeldung erklären und beheben,\n",
    "- ein Programm mit Verzweigungen lesen und seine Ausgabe vorhersagen, ohne es auszuführen,\n",
    "- zu einem Programm sinnvolle Testfälle auswählen, auch für die Grenzfälle,\n",
    "- eine Mehrfachauswahl als `CASE OF` beschreiben und in Python mit `match`/`case` umsetzen,\n",
    "- ein Programm mit einer Mehrfachauswahl und einer verschachtelten Verzweigung schreiben."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "sprachhilfe"
    ]
   },
   "source": [
    "## 🗣️ Sprachhilfe\n",
    "- *„Da ist ein Fehler in Zeile 2.“* → „In Zeile 2 fehlt der Doppelpunkt. Python meldet `SyntaxError: expected ':'`.“\n",
    "- *„Ich hab’s mit 5 probiert.“* → „Im Testfall mit der Eingabe 5 erwarte ich die Ausgabe ‚positiv‘. Das Programm liefert ‚positiv‘, der Test ist bestanden.“\n",
    "- *„Match guckt, was es ist.“* → „Die Mehrfachauswahl vergleicht den Wert von `op` nacheinander mit den festen Werten der Fälle.“"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Worum es geht\n",
    "Programmiererinnen und Programmierer **lesen** fremden Code, **suchen Fehler** und **erweitern** Programme. Die Fehlersuche heißt *Debugging*, „Entwanzen“, denn einen Programmfehler nennt man *Bug* („Käfer“). Heute übst du das mit Verzweigungen, lernst gut ausgewählte **Testfälle** und eine neue Verzweigung: die **Mehrfachauswahl**.\n",
    "\n",
    "## 1 Das brauchst du\n",
    "```\n",
    "if Bedingung_1:\n",
    "    Anweisungen, wenn Bedingung_1 wahr ist\n",
    "elif Bedingung_2:\n",
    "    Anweisungen, wenn Bedingung_1 falsch und Bedingung_2 wahr ist\n",
    "else:\n",
    "    Anweisungen, wenn keine Bedingung wahr ist\n",
    "```\n",
    "\n",
    "> 📌 **Merksatz:** Nur der Block der **ersten zutreffenden** Bedingung wird ausgeführt. Achte auf **Doppelpunkt** und **Einrückung**. `==` vergleicht, `=` weist zu.\n",
    "\n",
    "| Fehler im Code | Meldung von Python | Abhilfe |\n",
    "|:--|:--|:--|\n",
    "| Doppelpunkt vergessen: `if zahl > 0` | `SyntaxError: expected ':'` | `:` ans Zeilenende |\n",
    "| Block nicht eingerückt | `IndentationError: expected an indented block …` | Block 4 Leerzeichen einrücken |\n",
    "| Zeile ohne Grund eingerückt | `IndentationError: unexpected indent` | Einrückung entfernen |\n",
    "| `=` statt `==` in der Bedingung | `SyntaxError: invalid syntax. Maybe you meant '==' …` | `==` schreiben |\n",
    "| Bedingung hinter `else`: `else zahl < 0:` | `SyntaxError: expected ':'` | `elif` statt `else` |\n",
    "| `elif`-Bedingungen in falscher Reihenfolge | keine, aber falsches Ergebnis | Reihenfolge prüfen |\n",
    "\n",
    "## 2 Programme testen\n",
    "Ein Programm ohne Fehlermeldung ist noch lange nicht richtig. Man **testet** es: mit verschiedenen Eingaben ausführen und die Ausgabe mit dem vergleichen, was herauskommen **soll**. Eine Eingabe mit erwarteter Ausgabe heißt **Testfall**. Die erwartete Ausgabe überlegst du **vorher**.\n",
    "\n",
    "1. **Jeder Zweig mindestens einmal.**\n",
    "2. **Die Grenzfälle**, also die Werte direkt an einer Grenze. Bei `alter < 18` sind das 17 und 18.\n",
    "\n",
    "Beispiel: Ein Programm soll ausgeben, ob eine Zahl positiv, negativ oder null ist.\n",
    "\n",
    "| Eingabe | erwartete Ausgabe | Warum dieser Test? |\n",
    "|:-:|:--|:--|\n",
    "| `5` | `Die Zahl ist positiv` | Zweig „positiv“ |\n",
    "| `-3` | `Die Zahl ist negativ` | Zweig „negativ“ |\n",
    "| `0` | `Die Zahl ist null` | Zweig „null“, zugleich die Grenze |\n",
    "| `1` und `-1` | positiv bzw. negativ | direkt neben der Grenze |\n",
    "\n",
    "> 📌 **Merksatz:** Ein **Testfall** besteht aus einer Eingabe und der vorher überlegten erwarteten Ausgabe. Teste jeden Zweig und jeden Grenzfall."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 📝 Übungen: Schritt für Schritt selbstständig\n",
    "Das **Musterbeispiel** zeigt dir das Vorgehen beim Debugging. Danach werden die Übungen schrittweise schwieriger, die Hilfen werden weniger.\n",
    "\n",
    "### 🧩 Musterbeispiel (vorgemacht) – Bestanden?\n",
    "Das Programm soll ab 50 Punkten „bestanden“ ausgeben, sonst „nicht bestanden“. Es enthält **zwei Fehler**. Führe die Zelle aus."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "punkte = int(input(\"Punkte: \"))\n",
    "if punkte >= 50\n",
    "    print(\"bestanden\")\n",
    "else punkte < 50:\n",
    "    print(\"nicht bestanden\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So gehst du vor:\n",
    "1. **Letzte Zeile der Meldung lesen:** `SyntaxError: expected ':'` in Zeile 2. Am Ende von `if punkte >= 50` fehlt der Doppelpunkt. Ergänzen, neu starten.\n",
    "2. **Nächste Meldung:** Wieder `expected ':'`, jetzt in Zeile 4. Hinter `else` darf keine Bedingung stehen. `else` heißt ohnehin „in allen anderen Fällen“, also einfach `else:`.\n",
    "3. **Testen** mit vorher überlegten Testfällen:\n",
    "\n",
    "| Eingabe | erwartete Ausgabe | Warum? |\n",
    "|:-:|:--|:--|\n",
    "| `80` | `bestanden` | Zweig „bestanden“ |\n",
    "| `20` | `nicht bestanden` | Zweig „nicht bestanden“ |\n",
    "| `50` | `bestanden` | Grenzfall, wegen `>=` |\n",
    "| `49` | `nicht bestanden` | direkt neben der Grenze |\n",
    "\n",
    "Die korrigierte Fassung:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "punkte = int(input(\"Punkte: \"))\n",
    "if punkte >= 50:\n",
    "    print(\"bestanden\")\n",
    "else:\n",
    "    print(\"nicht bestanden\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 🐞 Übung 1 – Fehler finden (Debugging)\n",
    "Das Programm soll ausgeben, ob eine Zahl positiv, negativ oder null ist. Es enthält **drei Fehler**.\n",
    "1. Finde die Fehler **bevor** du es ausführst. Notiere jeweils Zeile und Fehler.\n",
    "2. Führe es aus. Python meldet immer nur den **ersten** Fehler. Behebe ihn und starte neu, wie im Musterbeispiel.\n",
    "3. Teste dein korrigiertes Programm mit den Testfällen aus Teil 2.\n",
    "\n",
    "> 💡 **Tipp:** Zwei der drei Fehler stehen in derselben Zeile."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "zahl = int(input(\"Zahl eingeben: \"))\n",
    "if zahl = 0\n",
    "    print(\"Die Zahl ist null\")\n",
    "elif zahl > 0:\n",
    "print(\"Die Zahl ist positiv\")\n",
    "else:\n",
    "    print(\"Die Zahl ist negativ\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Die Fehler:**\n",
    "\n",
    "…\n",
    "\n",
    "### 🔮 Übung 2 – FizzBuzz lesen\n",
    "Lies das Programm, **ohne** es auszuführen.\n",
    "1. Was gibt es für `zahl = 17` aus? Begründe mit den Bedingungen.\n",
    "2. Sage die Ausgabe für `zahl = 9`, `10` und `30` voraus.\n",
    "3. Warum wird `zahl % 15 == 0` **zuerst** geprüft?\n",
    "\n",
    "Ändere danach den Wert in Zeile 1 und prüfe deine Vorhersagen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "zahl = 17\n",
    "if zahl % 15 == 0:\n",
    "    print(\"FizzBuzz\")\n",
    "elif zahl % 3 == 0:\n",
    "    print(\"Fizz\")\n",
    "elif zahl % 5 == 0:\n",
    "    print(\"Buzz\")\n",
    "else:\n",
    "    print(zahl)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Meine Vorhersagen und Begründungen:**\n",
    "\n",
    "…"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3 Mehrfachauswahl: `CASE OF`\n",
    "Oft wird **ein und derselbe Wert** mit mehreren festen Möglichkeiten verglichen, zum Beispiel eine Note in Worten. Mit `if` und `elif` steht in jeder Zeile wieder `note == …`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "note = int(input(\"Note (1-6): \"))\n",
    "if note == 1:\n",
    "    print(\"sehr gut\")\n",
    "elif note == 2:\n",
    "    print(\"gut\")\n",
    "elif note == 3:\n",
    "    print(\"befriedigend\")\n",
    "elif note == 4:\n",
    "    print(\"ausreichend\")\n",
    "elif note == 5:\n",
    "    print(\"mangelhaft\")\n",
    "elif note == 6:\n",
    "    print(\"ungenügend\")\n",
    "else:\n",
    "    print(\"Das ist keine gültige Note.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Unabhängig von einer Programmiersprache beschreibt man eine **Mehrfachauswahl** so:\n",
    "```\n",
    "CASE note OF\n",
    "    1: Ausgabe \"sehr gut\"\n",
    "    2: Ausgabe \"gut\"\n",
    "    ...\n",
    "    6: Ausgabe \"ungenügend\"\n",
    "    OTHERWISE: Ausgabe \"Das ist keine gültige Note.\"\n",
    "END CASE\n",
    "```\n",
    "`OTHERWISE` („andernfalls“) ist der **Auffangfall**, wenn keiner der Werte passt.\n",
    "\n",
    "> 📌 **Definition:** Bei einer **Mehrfachauswahl** (`CASE OF`) wird **ein Ausdruck** mit mehreren **festen Werten** verglichen. Ausgeführt wird der Fall, dessen Wert passt. Passt keiner, wird der Auffangfall ausgeführt.\n",
    "\n",
    "### In Python: `match` und `case`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "note = int(input(\"Note (1-6): \"))\n",
    "match note:\n",
    "    case 1:\n",
    "        print(\"sehr gut\")\n",
    "    case 2:\n",
    "        print(\"gut\")\n",
    "    case 3:\n",
    "        print(\"befriedigend\")\n",
    "    case 4:\n",
    "        print(\"ausreichend\")\n",
    "    case 5:\n",
    "        print(\"mangelhaft\")\n",
    "    case 6:\n",
    "        print(\"ungenügend\")\n",
    "    case _:\n",
    "        print(\"Das ist keine gültige Note.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Zeile 2:** `match note:` legt fest, **welcher Wert** verglichen wird. Doppelpunkt, dann einrücken.\n",
    "- **Zeilen 3–14:** Jedes `case` nennt einen festen Wert. Beim ersten passenden Fall wird der Block darunter ausgeführt, die übrigen werden übersprungen.\n",
    "- **Zeilen 15–16:** `case _` ist der **Auffangfall**. Der Unterstrich passt zu jedem Wert. Er entspricht `else` und steht als **letzter** Fall.\n",
    "\n",
    "Das funktioniert genauso mit Texten. **🔮 Vorhersage:** Was gibt die Zelle aus?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "operator = \"-\"\n",
    "match operator:\n",
    "    case \"+\":\n",
    "        print(\"Addition\")\n",
    "    case \"-\":\n",
    "        print(\"Subtraktion\")\n",
    "    case _:\n",
    "        print(\"Unbekannter Operator\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> 📌 **Merksatz:** `CASE OF` eignet sich, wenn **ein Ausdruck mit mehreren festen Werten** verglichen wird. In Python heißt das `match`/`case`, `case _` ist der Auffangfall. Für **Bereiche** („unter 6 Jahren“) und Bedingungen mit `and`/`or` bleibt `if`/`elif`/`else` die richtige Wahl.\n",
    "\n",
    "> ⚠️ **Stolperstein:** `match` gibt es erst seit Python 3.10. Steht `case _` nicht am Ende, meldet Python einen `SyntaxError`, weil die Fälle darunter nie erreicht würden."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 📝 Übung 3 – Taschenrechner mit CASE OF (Lücken füllen)\n",
    "Der Taschenrechner fragt zwei Zahlen und einen Operator (`+`, `-`, `*`, `/`) ab. Bei einer Division durch 0 und bei einem unbekannten Operator gibt er eine verständliche Meldung aus. Ersetze jedes `___`. Die Zelle läuft erst, wenn alle Lücken gefüllt sind.\n",
    "\n",
    "```\n",
    "Erste Zahl: 7\n",
    "Operator (+ - * /): /\n",
    "Zweite Zahl: 2\n",
    "Ergebnis: 3.5\n",
    "```\n",
    "Teste mit allen vier Operatoren, mit `7 / 0` und mit einem unbekannten Operator wie `^`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = float(input(\"Erste Zahl: \"))\n",
    "op = input(\"Operator (+ - * /): \")      # Text, wird nicht umgewandelt\n",
    "b = float(input(\"Zweite Zahl: \"))\n",
    "match ___:\n",
    "    case \"+\":\n",
    "        print(\"Ergebnis:\", a + b)\n",
    "    case \"-\":\n",
    "        print(\"Ergebnis:\", a - b)\n",
    "    case ___:\n",
    "        print(\"Ergebnis:\", a * b)\n",
    "    case \"/\":\n",
    "        if ___:\n",
    "            print(\"Ergebnis:\", a / b)\n",
    "        else:\n",
    "            print(\"Division durch 0 ist nicht erlaubt!\")\n",
    "    case ___:\n",
    "        print(\"Unbekannter Operator\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 📝 Übung 4 – Eintrittspreis (mit Gerüst)\n",
    "Im Freibad gelten diese Preise:\n",
    "- Kinder unter 6 Jahren: Eintritt frei\n",
    "- 6 bis 17 Jahre: 2,50 Euro\n",
    "- ab 18 Jahren: 4,00 Euro, mit Schüler- oder Studierendenausweis 3,00 Euro\n",
    "\n",
    "Das Programm fragt zuerst das Alter. **Nur** ab 18 fragt es zusätzlich nach dem Ausweis (`ja`/`nein`).\n",
    "\n",
    "1. Lege **zuerst** eine Tabelle mit Testfällen an, die alle Zweige und Grenzfälle abdeckt.\n",
    "2. Ersetze dann die Kommentare durch Programmzeilen und teste mit deiner Tabelle.\n",
    "\n",
    "| Eingaben | erwartete Ausgabe | Warum dieser Test? |\n",
    "|:--|:--|:--|\n",
    "| | | |\n",
    "| | | |\n",
    "| | | |\n",
    "| | | |\n",
    "| | | |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Alter einlesen\n",
    "# if: unter 6 → Eintritt frei\n",
    "# elif: unter 18 → 2,50 Euro\n",
    "# else:\n",
    "#     Ausweis abfragen (nur hier!)\n",
    "#     innere Verzweigung: ja → 3,00 Euro, sonst → 4,00 Euro"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 🚀 Zusatzaufgabe – Taschenrechner erweitern (selbstständig)\n",
    "Kopiere deinen Taschenrechner aus Übung 3 und erweitere ihn um die Operatoren `//`, `%` und `**`. Auch bei `//` und `%` darf nicht durch 0 geteilt werden. Lege zuerst die Testfälle fest. Kontrolle: `7 // 2` → 3.0, `7 % 2` → 1.0, `7 ** 2` → 49.0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Zusatzaufgabe – erweiterter Taschenrechner"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 📌 Das Wichtigste in Kürze\n",
    "- Fehlermeldungen von unten lesen, ersten Fehler beheben, neu starten.\n",
    "- **Testfall** = Eingabe + vorher überlegte erwartete Ausgabe. Jeden Zweig und jeden Grenzfall testen.\n",
    "- Bei `elif` den **speziellsten** Fall zuerst prüfen (FizzBuzz).\n",
    "- **Mehrfachauswahl** `CASE OF`: ein Wert, mehrere feste Möglichkeiten. In Python `match`/`case`, Auffangfall `case _` am Ende.\n",
    "- Vor einer Division prüfen, ob durch 0 geteilt wird.\n",
    "\n",
    "Zum Weiterüben: `DS04_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
}