{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# DS 9 – Übungsstunde: Funktionen lesen, testen und erweitern\n",
    "**Informatik 10 – MINT-Zweig | Textuelle Programmierung und Datenstrukturen**\n",
    "\n",
    "## Lernziele\n",
    "Ich kann\n",
    "- gegebene Funktionen lesen und ihr Verhalten vorhersagen und erklären,\n",
    "- einen Fehler in einer Funktion durch geschicktes Testen finden und beheben,\n",
    "- Funktionen schreiben, die andere Funktionen aufrufen,\n",
    "- eine vorhandene Funktion zu einer neuen Funktion erweitern,\n",
    "- mit `math.pi` die Kreiszahl π verwenden."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "sprachhilfe"
    ]
   },
   "source": [
    "## 🗣️ Sprachhilfe\n",
    "- „Der Aufruf `verarbeite(6, 3)` ruft die Hilfsfunktion `ist_teilbar(6, 3)` auf. Sie liefert `True`, deshalb gibt `verarbeite` den Wert … zurück.“\n",
    "- „Ich teste mit dem Wert …, weil das ein Sonderfall / der Grenzwert der Bedingung ist.“\n",
    "- „Erwartet habe ich …, herausgekommen ist … . Also steckt der Fehler in Zeile …, weil …“"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1 Das brauchst du: Funktionen wiederholen\n",
    "Führe die Zelle aus. Erkläre dann mit den Fachbegriffen **Definition**, **Parameter**, **Argument**, **Aufruf** und **Rückgabewert**, was hier passiert."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def quadrat(zahl):\n",
    "    return zahl * zahl\n",
    "\n",
    "print(quadrat(3))\n",
    "print(quadrat(10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `def quadrat(zahl):` **definiert** die Funktion `quadrat` mit dem **Parameter** `zahl`. Der eingerückte Rumpf wird erst beim Aufruf ausgeführt.\n",
    "- `return zahl * zahl` gibt das Ergebnis als **Rückgabewert** zurück und beendet die Funktion.\n",
    "- `quadrat(3)` und `quadrat(10)` sind zwei **Aufrufe** derselben Funktion mit verschiedenen **Argumenten**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Funktionen rufen Funktionen auf\n",
    "Im Rumpf einer Funktion darf man auch **andere Funktionen** aufrufen. So kann eine größere Funktion kleinere **Hilfsfunktionen** benutzen.\n",
    "\n",
    "**🔮 Vorhersage:** Was gibt die letzte Zeile aus? Überlege zuerst, dann führe die Zelle aus."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def quadrat(zahl):\n",
    "    return zahl * zahl\n",
    "\n",
    "def summe_der_quadrate(a, b):\n",
    "    return quadrat(a) + quadrat(b)\n",
    "\n",
    "print(summe_der_quadrate(3, 4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Zeilen 1–2:** die bekannte Funktion `quadrat`.\n",
    "- **Zeilen 4–5:** `summe_der_quadrate` rechnet selbst nichts mit `*`. Sie ruft zweimal `quadrat` auf und addiert die beiden Rückgabewerte.\n",
    "- **Zeile 7:** Der Aufruf springt in `summe_der_quadrate` mit `a = 3` und `b = 4`. Dort springt `quadrat(a)` in die Funktion `quadrat` und kommt mit `9` zurück, `quadrat(b)` liefert `16`. Zum Schluss wird `9 + 16 = 25` zurückgegeben.\n",
    "\n",
    "Der Vorteil: Jede Funktion erledigt eine kleine, klar umrissene Aufgabe. Ist `quadrat` einmal getestet, kann man sich darauf verlassen, wo immer man sie benutzt.\n",
    "\n",
    "> 📌 **Merksatz:** Funktionen können **andere Funktionen aufrufen**. Eine größere Funktion nutzt dann kleinere **Hilfsfunktionen**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2 Code lesen und erklären\n",
    "Bevor du ein fremdes Programm ausführst, lohnt es sich, es zu **lesen** und vorherzusagen, was passiert.\n",
    "\n",
    "> 💡 **Tipp:** `a % b` ist der **Rest** der Division (`7 % 3` ergibt `1`), `a // b` die **ganzzahlige Division** (`7 // 3` ergibt `2`). Ist der Rest `0`, geht die Division auf. Lies verschachtelte Aufrufe von innen nach außen und schreibe dir für jeden Aufruf die Werte der Parameter auf.\n",
    "\n",
    "### 🔍 Übung 1 – Code lesen\n",
    "Lies den Code in der nächsten Zelle, **ohne** ihn auszuführen.\n",
    "1. Beschreibe in eigenen Worten, was die Funktion `verarbeite` macht.\n",
    "2. Gib an, was `print(verarbeite(6, 3))` und `print(verarbeite(5, 3))` ausgeben.\n",
    "\n",
    "Schreibe deine Antwort in die Textzelle darunter. Führe den Code erst danach aus und überprüfe deine Vorhersage."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ist_teilbar(a, b):\n",
    "    return a % b == 0\n",
    "\n",
    "def verarbeite(x, y):\n",
    "    if ist_teilbar(x, y):\n",
    "        return x // y\n",
    "    else:\n",
    "        return x * y\n",
    "\n",
    "print(verarbeite(6, 3))\n",
    "print(verarbeite(5, 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Meine Erklärung und Vorhersage:**\n",
    "\n",
    "…"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3 Fehler finden durch Testen\n",
    "Manche Fehler erzeugen keine Fehlermeldung: Das Programm läuft, aber das Ergebnis ist falsch. Solche Fehler findest du nur durch **Testen** mit Werten, deren richtiges Ergebnis du kennst.\n",
    "\n",
    "### 🧰 Werkzeug: das Modul `math`\n",
    "Python bringt viele mathematische Werte und Funktionen im **Modul** `math` mit. Du schreibst einmal am Programmanfang `import math`, so wie `import random` beim Würfeln. Danach steht die Kreiszahl als `math.pi` zur Verfügung."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "print(math.pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 📝 Übung 2 – Kreisumfang\n",
    "Die Funktion soll den Umfang eines Kreises berechnen (Formel: U = 2 · π · r). Sie gibt aber ein falsches Ergebnis zurück. Finde den Fehler und behebe ihn. Teste die verbesserte Funktion, auch mit dem Sonderfall `radius = 0`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "def kreisumfang(radius):\n",
    "    umfang = 2 * radius\n",
    "    return umfang\n",
    "\n",
    "# Test: sollte bei radius = 5 etwa 31.4 ergeben\n",
    "print(kreisumfang(5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Der Fehler:**\n",
    "\n",
    "…"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 📝 Übung 3 – Grenzfälle testen\n",
    "Ein Online-Shop gibt **ab** einem Einkaufswert von 50 Euro 10 % Rabatt. Die Funktion `rabatt_preis` soll den Preis nach Abzug des Rabatts zurückgeben.\n",
    "1. Rechne **zuerst von Hand** aus, was für 20, 50 und 100 Euro herauskommen muss. Trage die Werte hinter `erwartet:` ein.\n",
    "2. Führe die Tests aus. Welcher Test schlägt fehl?\n",
    "3. Erkläre den Fehler und verbessere die Funktion."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def rabatt_preis(preis):\n",
    "    if preis > 50:\n",
    "        return preis * 0.9\n",
    "    else:\n",
    "        return preis\n",
    "\n",
    "print(rabatt_preis(20), \"erwartet: \")\n",
    "print(rabatt_preis(50), \"erwartet: \")\n",
    "print(rabatt_preis(100), \"erwartet: \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Welcher Test schlägt fehl, und warum?**\n",
    "\n",
    "…\n",
    "\n",
    "> 📌 **Merksatz:** Falsche Ergebnisse ohne Fehlermeldung findet man durch **Testen** mit Werten, deren Ergebnis man **vorher** kennt. Besonders wichtig sind **Sonder- und Grenzfälle** wie `0` oder der Grenzwert einer Bedingung."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4 Ein Programm aus mehreren Funktionen\n",
    "Die Übungen dieser Stunde werden schrittweise selbstständiger: In Übung 1 liest du nur, in Übung 2 und 3 verbesserst du fertigen Code, in Übung 4 füllst du ein Gerüst aus, und die Zusatzaufgabe schreibst du allein. Vorbild für Übung 4 ist das vorgemachte Beispiel `summe_der_quadrate` aus Teil 1.\n",
    "\n",
    "### 📝 Übung 4 – Rechteck (mit Gerüst)\n",
    "Schreibe drei Funktionen:\n",
    "- `flaeche_rechteck(a, b)` gibt die Fläche eines Rechtecks mit den Seitenlängen `a` und `b` zurück,\n",
    "- `umfang_rechteck(a, b)` gibt den Umfang dieses Rechtecks zurück,\n",
    "- `beschreibe_rechteck(a, b)` nutzt die beiden Funktionen oben und liefert einen Satz, den das Hauptprogramm ausgibt, z. B. für die Seiten 4 und 5:\n",
    "\n",
    "  „Ein Rechteck mit den Seiten 4 und 5 hat die Fläche 20 und den Umfang 18.“\n",
    "\n",
    "> 💡 **Tipp:** Schreibe zuerst die beiden kleinen Funktionen und teste jede einzeln (Kontrolle: Fläche 20, Umfang 18). Erst wenn sie stimmen, schreibst du `beschreibe_rechteck`. Sie ruft die beiden anderen auf, so wie `summe_der_quadrate` oben `quadrat` aufruft. Den Satz setzt du mit `+` zusammen. Zahlen musst du dafür mit `str(...)` in Text umwandeln."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Gerüst:** Ersetze jedes `___`. Führe die Zelle zuerst nur mit Schritt 1 aus und prüfe die Kontrollwerte, bevor du Schritt 2 bearbeitest."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Schritt 1: die beiden Hilfsfunktionen\n",
    "def flaeche_rechteck(a, b):\n",
    "    return ___\n",
    "\n",
    "def umfang_rechteck(a, b):\n",
    "    return ___\n",
    "\n",
    "print(flaeche_rechteck(4, 5), umfang_rechteck(4, 5), \"erwartet: 20 18\")\n",
    "\n",
    "# Schritt 2: beschreibe_rechteck ruft die beiden Hilfsfunktionen auf\n",
    "def beschreibe_rechteck(a, b):\n",
    "    flaeche = ___\n",
    "    umfang = ___\n",
    "    return (\"Ein Rechteck mit den Seiten \" + str(a) + \" und \" + str(b)\n",
    "            + \" hat die Fläche \" + ___ + \" und den Umfang \" + ___ + \".\")\n",
    "\n",
    "print(beschreibe_rechteck(4, 5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 🚀 Zusatzaufgabe – Maximum von drei Zahlen (selbstständig)\n",
    "Jetzt ohne Gerüst. In DS 8 hast du `maximum(a, b)` geschrieben. Ergänze eine Funktion `maximum3(a, b, c)`, die die größte von **drei** Zahlen zurückgibt. Benutze dafür `maximum`: `maximum3` selbst soll ohne `if` auskommen. Teste mit mindestens drei Aufrufen, bei denen die größte Zahl jeweils an einer anderen Stelle steht."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def maximum(a, b):\n",
    "    if a > b:\n",
    "        return a\n",
    "    else:\n",
    "        return b\n",
    "\n",
    "# TODO: maximum3(a, b, c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 📌 Das Wichtigste in Kürze\n",
    "- Programme **lesen**: von innen nach außen auswerten und für jeden Aufruf die Werte der Parameter notieren.\n",
    "- Funktionen können **andere Funktionen aufrufen**. Große Aufgaben zerlegt man so in kleine **Hilfsfunktionen**, die man einzeln testet.\n",
    "- Falsche Ergebnisse ohne Fehlermeldung findet man durch **Testen** mit Werten, deren Ergebnis man vorher kennt.\n",
    "- Besonders wichtig sind Tests mit **Sonder- und Grenzfällen** wie `0` oder dem Grenzwert einer Bedingung.\n",
    "- Mit `import math` steht die Kreiszahl als `math.pi` zur Verfügung.\n",
    "\n",
    "Zum Weiterüben: `DS09_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
}