{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# DS 8 – Funktionen: Programme aus Bausteinen\n",
    "**Informatik 10 – MINT-Zweig | Textuelle Programmierung und Datenstrukturen**\n",
    "\n",
    "## Lernziele\n",
    "Ich kann\n",
    "- eine Funktion mit `def` definieren und sie aufrufen,\n",
    "- Funktionen mit Parametern schreiben und ihnen beim Aufruf Argumente übergeben,\n",
    "- mit `return` einen Rückgabewert zurückgeben und damit weiterrechnen,\n",
    "- erklären, warum `print` in einer Funktion etwas anderes ist als `return`,\n",
    "- beschreiben, was bei einem Funktionsaufruf Schritt für Schritt passiert,\n",
    "- eine Funktion mit mehreren Aufrufen testen."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "sprachhilfe"
    ]
   },
   "source": [
    "## 🗣️ Sprachhilfe\n",
    "Beispiel: die Funktion `f` mit dem Parameter `x` und dem Rumpf `return x * x + 1`. Der Aufruf `f(4)` liefert 17.\n",
    "- *„Zur Eingabe 4 bekomme ich die 17.“* → „Wenn ich der Funktion die Zahl 4 gebe, liefert sie mir die 17 als Ergebnis.“ → „Wenn die Funktion `f` mit dem Wert 4 für den Parameter `x` aufgerufen wird, berechnet sie das Ergebnis 17 und gibt es zurück.“\n",
    "- „Der Funktion wird der Wert 4 übergeben. Die Funktion berechnet 4 · 4 + 1 und gibt 17 zurück.“"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Worum es geht\n",
    "Du hast schon viele Funktionen benutzt: `print(...)`, `input(...)`, `int(...)`, `round(...)`. Du schreibst ihren Namen, gibst ihnen in Klammern Werte mit und bekommst ein Ergebnis. Wie sie innen arbeiten, musst du nicht wissen. Heute schreibst du **eigene Funktionen**. So schreibst du eine Rechnung, die du oft brauchst, nur einmal auf. Die Idee kennst du aus Mathe: $f(x) = x^2$ macht aus 4 die 16 und aus 7 die 49.\n",
    "\n",
    "## 1 Eine eigene Funktion definieren\n",
    "Dein Programm soll an mehreren Stellen eine Trennlinie ausgeben. Statt sie jedes Mal abzutippen, gibst du der Anweisung einen Namen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def trennlinie():\n",
    "    print(\"--------------------\")\n",
    "\n",
    "print(\"Einkaufsliste\")\n",
    "trennlinie()\n",
    "print(\"Milch, Brot, Käse\")\n",
    "trennlinie()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Zeile 1:** `def` (englisch *define*, „festlegen“) beginnt eine **Funktionsdefinition**: Name, runde Klammern, **Doppelpunkt**. Die Klammern sind leer, weil die Funktion keine Werte braucht.\n",
    "- **Zeile 2:** Die eingerückten Zeilen unter `def` bilden den **Funktionsrumpf**, wie bei `if` und `for`.\n",
    "- **Zeile 4:** Hier beginnt das **Hauptprogramm**. Beim Lesen von Zeile 1 und 2 hat Python noch **nichts ausgegeben**, es hat sich nur gemerkt, was `trennlinie` bedeutet.\n",
    "- **Zeilen 5 und 7:** `trennlinie()` ist ein **Funktionsaufruf**. Erst jetzt wird der Rumpf ausgeführt, und das zweimal, obwohl die Linie nur einmal im Programm steht.\n",
    "\n",
    "Eine Funktion ist wie ein **Rezept**: Die Definition schreibt das Rezept auf, davon wird noch niemand satt. Erst beim Aufruf wird gekocht, so oft man möchte.\n",
    "\n",
    "> 📌 **Merksatz:** Eine **Funktion** fasst eine Folge von Anweisungen unter einem Namen zusammen und macht sie wiederverwendbar. **Definition:** `def funktionsname(parameter1, parameter2):` gefolgt vom eingerückten **Funktionsrumpf**.\n",
    "\n",
    "### ⚠️ Stolpersteine\n",
    "Führe beide Zellen aus und lies die letzte Zeile der Fehlermeldung."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def trennlinie():\n",
    "print(\"--------------------\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "trennlinie2()\n",
    "\n",
    "def trennlinie2():\n",
    "    print(\"--------------------\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. `IndentationError: expected an indented block after function definition on line 1`: Nach `def` wird ein eingerückter Block erwartet. Fehlt der Doppelpunkt, kommt `SyntaxError: expected ':'`.\n",
    "2. `NameError: name 'trennlinie2' is not defined`: Python liest von oben nach unten. Eine Funktion muss **definiert sein, bevor** sie aufgerufen wird. Schreibe die Definitionen deshalb an den Anfang. Und vergiss beim Aufruf die Klammern nicht."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2 Parameter: der Funktion Werte mitgeben\n",
    "Eine Begrüßung soll jedes Mal einen anderen Namen enthalten. Dafür schreibst du in die Klammern einen **Parameter**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gruesse(name):\n",
    "    print(\"Hallo, \" + name + \"!\")\n",
    "\n",
    "gruesse(\"Alex\")\n",
    "gruesse(\"Sam\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Zeile 1:** `name` ist ein **Parameter**: eine Variable der Funktion, die ihren Wert erst beim Aufruf bekommt, wie eine noch leere Schachtel.\n",
    "- **Zeile 4:** `\"Alex\"` ist das **Argument**. Python legt es in den Parameter, als stünde dort `name = \"Alex\"`, und führt dann den Rumpf aus.\n",
    "\n",
    "### Mehrere Parameter\n",
    "Mehrere Parameter werden durch Kommas getrennt. Die Argumente werden **der Reihe nach** verteilt. **🔮 Vorhersage:** Was gibt die letzte Zeile aus?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gruesse(gruss, name):\n",
    "    print(gruss + \", \" + name + \"!\")\n",
    "\n",
    "gruesse(\"Hallo\", \"Alex\")\n",
    "gruesse(\"Servus\", \"Sam\")\n",
    "gruesse(\"Sam\", \"Moin\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Zeile 6 sind die Argumente vertauscht. Python bemerkt das nicht: `gruss` bekommt `\"Sam\"`, `name` bekommt `\"Moin\"`.\n",
    "\n",
    "> 📌 **Merksatz:** **Parameter** sind die „Eingabewerte“ einer Funktion. Beim Aufruf werden ihnen konkrete **Argumente** übergeben, und zwar in derselben Reihenfolge.\n",
    "\n",
    "### ⚠️ Stolperstein: falsche Anzahl\n",
    "Führe die Zelle aus. Was passiert bei `gruesse(\"Alex\", \"Sam\")`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gruesse(name):\n",
    "    print(\"Hallo, \" + name + \"!\")\n",
    "\n",
    "gruesse()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`TypeError: gruesse() missing 1 required positional argument: 'name'` heißt: „Der Funktion fehlt 1 benötigtes Argument.“ Bei zu vielen Argumenten: `takes 1 positional argument but 2 were given`.\n",
    "\n",
    "**🧪 Probiere es aus:** Rufe `gruesse` mit deinem eigenen Namen auf. Was passiert bei `gruesse(15)`? Erkläre die Fehlermeldung mit dem, was du über das Verketten mit `+` weißt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Probiere es hier aus"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3 Rückgabewert: die Funktion liefert ein Ergebnis\n",
    "`gruesse` gibt etwas auf dem Bildschirm aus, danach ist das Ergebnis für das Programm verloren. Bei `round` ist das anders: `zahl = round(3.14159, 2)` **gibt** `3.14` **zurück**, und es landet in `zahl`. Das geht auch mit eigenen Funktionen, mit `return`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def quadrat(zahl):\n",
    "    ergebnis = zahl * zahl\n",
    "    return ergebnis\n",
    "\n",
    "print(quadrat(4))\n",
    "print(quadrat(7))\n",
    "\n",
    "x = quadrat(10)\n",
    "print(\"x ist jetzt:\", x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Zeile 3:** `return ergebnis` gibt den Wert an die Stelle zurück, an der die Funktion aufgerufen wurde: der **Rückgabewert**.\n",
    "- **Zeile 5:** Von innen nach außen lesen: `quadrat(4)` liefert `16`, der Aufruf wird durch diesen Wert ersetzt. Es steht gewissermaßen `print(16)` da.\n",
    "- **Zeile 8:** Diesmal wird der Rückgabewert `100` in `x` gespeichert.\n",
    "\n",
    "Eine Funktion mit Parametern und Rückgabewert ist wie eine **Maschine**: Oben wirft man das Argument 4 hinein, die Maschine arbeitet, unten kommt 16 heraus.\n",
    "\n",
    "Weil ein Aufruf wie `quadrat(3)` am Ende für einen Wert steht, darf er überall stehen, wo ein Wert stehen darf: in Rechnungen, Bedingungen oder als Argument. Mit `return` **endet die Funktion sofort**. Ein Rückgabewert muss auch keine Zahl sein."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def quadrat(zahl):\n",
    "    return zahl * zahl\n",
    "\n",
    "summe = quadrat(3) + quadrat(4)\n",
    "print(\"3*3 + 4*4 =\", summe)\n",
    "if quadrat(5) > 20:\n",
    "    print(\"5*5 ist größer als 20.\")\n",
    "\n",
    "def begruessung(name, gruss):\n",
    "    return gruss + \", \" + name + \"!\"\n",
    "\n",
    "print(begruessung(\"Alex\", \"Hallo\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> 📌 **Merksatz:** Mit `return wert` gibt eine Funktion einen **Rückgabewert** an die aufrufende Stelle zurück und beendet die Funktion. Der **Funktionsaufruf** (z. B. `ergebnis = quadrat(4)`) ist zu unterscheiden von der **Funktionsdefinition** (`def quadrat(zahl):` mit Rumpf).\n",
    "\n",
    "### 🔮 Übung 1 – Vorhersage\n",
    "Lies das Programm, **ohne** es auszuführen. Schreibe auf, was es ausgibt. Überprüfe danach."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def verdopple(zahl):\n",
    "    return 2 * zahl\n",
    "\n",
    "a = verdopple(3)\n",
    "b = verdopple(a) + 1\n",
    "print(a, b)\n",
    "print(verdopple(verdopple(5)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Meine Vorhersage:**\n",
    "\n",
    "…"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4 Was beim Aufruf passiert\n",
    "Ein Funktionsaufruf unterbricht die Reihenfolge von oben nach unten: Python **springt** in die Funktion, führt den Rumpf aus und **springt** mit dem Rückgabewert **zurück**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def quadrat(zahl):\n",
    "    ergebnis = zahl * zahl\n",
    "    return ergebnis\n",
    "\n",
    "x = quadrat(10)\n",
    "y = quadrat(3) + 1\n",
    "print(x, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. **Zeile 1:** Python merkt sich die Funktion. Zeilen 2 und 3 werden jetzt **nicht** ausgeführt.\n",
    "2. **Zeile 5:** Sprung in die Funktion mit `zahl = 10`. Zeile 2 rechnet `ergebnis = 100`, Zeile 3 gibt `100` zurück. `x` bekommt `100`.\n",
    "3. **Zeile 6:** Sprung mit `zahl = 3`, Rückgabewert `9`. Zurück in Zeile 6: `9 + 1 = 10` wird in `y` gespeichert.\n",
    "4. **Zeile 7:** Ausgabe von `x` und `y`.\n",
    "\n",
    "Ablaufprotokoll **innerhalb der Funktion**:\n",
    "\n",
    "| Schritt | Zeile | Anweisung | `zahl` | `ergebnis` |\n",
    "|:-:|:-:|:--|:-:|:-:|\n",
    "| 1 | 2 | `ergebnis = zahl * zahl` | `10` | `100` |\n",
    "| 2 | 3 | `return ergebnis` | `10` | `100` |\n",
    "| 3 | 2 | `ergebnis = zahl * zahl` | `3` | `9` |\n",
    "| 4 | 3 | `return ergebnis` | `3` | `9` |\n",
    "\n",
    "### Variablen in der Funktion bleiben in der Funktion\n",
    "`zahl` und `ergebnis` gibt es nur, solange die Funktion läuft. Man nennt sie **lokale Variablen**. Aus der Maschine kommt nur heraus, was mit `return` zurückgegeben wird. Führe die Zelle aus."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def quadrat(zahl):\n",
    "    ergebnis = zahl * zahl\n",
    "    return ergebnis\n",
    "\n",
    "x = quadrat(10)\n",
    "print(ergebnis)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5 `print` oder `return`?\n",
    "Der häufigste Fehler mit Funktionen. **🔮 Vorhersage:** Was steht in `a`, was in `b`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def quadrat_mit_print(zahl):\n",
    "    print(zahl * zahl)\n",
    "\n",
    "def quadrat_mit_return(zahl):\n",
    "    return zahl * zahl\n",
    "\n",
    "a = quadrat_mit_print(4)\n",
    "b = quadrat_mit_return(4)\n",
    "print(\"a ist\", a)\n",
    "print(\"b ist\", b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Zeile 7:** `quadrat_mit_print(4)` zeigt sofort `16` an, hat aber kein `return`. Darum bekommt `a` den besonderen Wert **`None`** (englisch für „nichts“).\n",
    "- **Zeile 8:** `quadrat_mit_return(4)` zeigt nichts an, liefert aber `16` zurück.\n",
    "\n",
    "Will man weiterrechnen, bricht die `print`-Variante sogar ab:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def quadrat_mit_print(zahl):\n",
    "    print(zahl * zahl)\n",
    "\n",
    "summe = quadrat_mit_print(3) + quadrat_mit_print(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`TypeError: unsupported operand type(s) for +: 'NoneType' and 'NoneType'`: `None + None` kann Python nicht rechnen. Taucht `NoneType` in einer Fehlermeldung auf, fehlt sehr oft ein `return`.\n",
    "\n",
    "| | `print(...)` in der Funktion | `return ...` |\n",
    "|:--|:--|:--|\n",
    "| Was passiert? | Der Wert wird auf dem Bildschirm angezeigt. | Der Wert wird an die Stelle des Aufrufs zurückgegeben. |\n",
    "| Wer bekommt den Wert? | die Person vor dem Bildschirm | das Programm |\n",
    "| Was liefert der Aufruf? | `None` | den Wert hinter `return` |\n",
    "| Weiterrechnen möglich? | nein | ja |\n",
    "\n",
    "> 📌 **Merksatz:** Eine Funktion ohne `return` liefert `None` zurück. `print` zeigt einen Wert nur an. Soll das Programm mit dem Ergebnis weiterarbeiten, muss die Funktion es mit `return` zurückgeben.\n",
    "\n",
    "> 💡 **Faustregel:** Eine Funktion, die etwas **berechnet**, gibt ihr Ergebnis mit `return` zurück. Das **Ausgeben** mit `print` erledigt das Hauptprogramm.\n",
    "\n",
    "### 🔍 Übung 2 – print oder return?\n",
    "Das Programm soll Minuten in Sekunden umrechnen. Es läuft ohne Fehlermeldung, aber die Ausgabe ist seltsam.\n",
    "1. Gib an, was das Programm ausgibt.\n",
    "2. Erkläre, warum die Ausgabe nicht stimmt.\n",
    "3. Verbessere die Funktion."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def minuten_zu_sekunden(minuten):\n",
    "    print(minuten * 60)\n",
    "\n",
    "dauer = minuten_zu_sekunden(5)\n",
    "print(\"Das sind\", dauer, \"Sekunden.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ausgabe und Erklärung:**\n",
    "\n",
    "…"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6 Funktionen testen\n",
    "Eine Funktion kann man beliebig oft mit verschiedenen Argumenten aufrufen. Das ist praktisch zum **Testen**:\n",
    "1. **Vorher** von Hand ausrechnen, was herauskommen muss.\n",
    "2. Die Funktion mit diesen Werten aufrufen.\n",
    "3. Vergleichen. Weicht ein Ergebnis ab, steckt ein Fehler in der Funktion oder in deiner Rechnung.\n",
    "\n",
    "Teste auch Sonderfälle wie `0`, negative Zahlen oder Kommazahlen. Dort verstecken sich Fehler am häufigsten."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def quadrat(zahl):\n",
    "    return zahl * zahl\n",
    "\n",
    "print(quadrat(4), \"erwartet: 16\")\n",
    "print(quadrat(0), \"erwartet: 0\")\n",
    "print(quadrat(-3), \"erwartet: 9\")\n",
    "print(quadrat(1.5), \"erwartet: 2.25\")\n",
    "print(quadrat(-3) == 9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 📝 Übungen: Schritt für Schritt selbstständig\n",
    "Die Übungen werden schrittweise schwieriger. Das **Musterbeispiel** ist ganz vorgemacht. Bei Übung 3 füllst du nur Lücken `___` aus, bei Übung 4 steht nur noch das Gerüst, die Zusatzaufgabe schreibst du allein. Gehe jedes Mal in denselben vier Schritten vor:\n",
    "\n",
    "| Schritt | Frage |\n",
    "|:-:|:--|\n",
    "| 1 | **Welche Werte** braucht die Funktion? → Parameter |\n",
    "| 2 | **Was soll herauskommen?** → Rückgabewert |\n",
    "| 3 | **Wie rechnet man es aus?** → Rumpf |\n",
    "| 4 | **Stimmt es?** → Testen mit vorher ausgerechneten Werten |\n",
    "\n",
    "### 🧩 Musterbeispiel (vorgemacht) – Fläche eines Dreiecks\n",
    "Aufgabe: Schreibe eine Funktion `dreieck_flaeche(grundseite, hoehe)`, die die Fläche eines Dreiecks zurückgibt. Formel: A = g · h / 2.\n",
    "\n",
    "1. **Welche Werte?** Die Grundseite und die Höhe. Also zwei Parameter: `grundseite` und `hoehe`.\n",
    "2. **Was soll herauskommen?** Die Fläche, also eine Zahl. Sie wird mit `return` zurückgegeben, nicht mit `print` ausgegeben.\n",
    "3. **Wie rechnet man?** Die Formel wird fast wörtlich übernommen: `grundseite * hoehe / 2`.\n",
    "4. **Stimmt es?** Vorher von Hand: g = 4, h = 3 ergibt 4 · 3 / 2 = 6. g = 10, h = 5 ergibt 25. Sonderfall: h = 0 ergibt 0.\n",
    "\n",
    "Lies den Code Zeile für Zeile und führe ihn aus."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Schritt 1 und 2: Name, Parameter und Rückgabewert festlegen\n",
    "def dreieck_flaeche(grundseite, hoehe):\n",
    "    # Schritt 3: rechnen und das Ergebnis zurückgeben\n",
    "    flaeche = grundseite * hoehe / 2\n",
    "    return flaeche\n",
    "\n",
    "# Schritt 4: testen mit vorher ausgerechneten Werten\n",
    "print(dreieck_flaeche(4, 3), \"erwartet: 6\")\n",
    "print(dreieck_flaeche(10, 5), \"erwartet: 25\")\n",
    "print(dreieck_flaeche(7, 0), \"erwartet: 0\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Weil `/` immer eine Kommazahl liefert, erscheint `6.0` statt `6`. Das ist richtig.\n",
    "\n",
    "### 📝 Übung 3 – Celsius in Fahrenheit (Lücken füllen)\n",
    "In den USA misst man Temperaturen in Grad Fahrenheit: °F = °C · 9/5 + 32. Die Funktion `celsius_zu_fahrenheit(grad_celsius)` soll den Wert in Fahrenheit **zurückgeben**.\n",
    "\n",
    "Gehe wie im Musterbeispiel vor:\n",
    "1. **Welche Werte?** Eine Temperatur in Grad Celsius, der Parameter heißt `grad_celsius`.\n",
    "2. **Was soll herauskommen?** Die Temperatur in Fahrenheit.\n",
    "3. **Wie rechnet man?** Übersetze die Formel in Python. Das Malzeichen ist `*`.\n",
    "4. **Stimmt es?** Die Testaufrufe stehen schon da: Wasser gefriert bei 0 °C = 32 °F und siedet bei 100 °C = 212 °F.\n",
    "\n",
    "Ersetze jedes `___` durch den richtigen Ausdruck. Solange noch ein `___` dasteht, meldet Python `NameError: name '___' is not defined`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def celsius_zu_fahrenheit(grad_celsius):\n",
    "    fahrenheit = ___\n",
    "    return ___\n",
    "\n",
    "print(celsius_zu_fahrenheit(0), \"erwartet: 32\")\n",
    "print(celsius_zu_fahrenheit(100), \"erwartet: 212\")\n",
    "print(celsius_zu_fahrenheit(20), \"erwartet: 68\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 📝 Übung 4 – Maximum von zwei Zahlen (mit Gerüst)\n",
    "Schreibe eine Funktion `maximum(a, b)`, die die größere von zwei Zahlen zurückgibt. Verwende **nicht** `max()`, sondern eine Verzweigung.\n",
    "\n",
    "1. **Welche Werte?** Zwei Zahlen, `a` und `b`.\n",
    "2. **Was soll herauskommen?** Die größere der beiden Zahlen.\n",
    "3. **Wie rechnet man?** Vergleiche mit `if a > b:` und gib im passenden Zweig `a` oder `b` zurück. Eine Funktion darf mehrere `return` haben.\n",
    "4. **Stimmt es?** Rechne vorher aus, was bei den Testaufrufen herauskommen muss, und trage es hinter `erwartet:` ein. Teste auch mit zwei gleichen Zahlen.\n",
    "\n",
    "Das Gerüst gibt die Kopfzeile und die Kommentare vor. Ersetze die Kommentare durch Programmzeilen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def maximum(a, b):\n",
    "    # wenn a größer als b ist:\n",
    "    #     a zurückgeben\n",
    "    # sonst:\n",
    "    #     b zurückgeben\n",
    "    pass\n",
    "\n",
    "print(maximum(3, 9), \"erwartet: \")\n",
    "print(maximum(17, 5), \"erwartet: \")\n",
    "print(maximum(4, 4), \"erwartet: \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 🚀 Zusatzaufgabe – Gerade Zahlen (selbstständig)\n",
    "1. Schreibe eine Funktion `ist_gerade(zahl)`, die `True` zurückgibt, wenn die Zahl gerade ist, sonst `False`. Der Rückgabewert ist also vom Typ `bool`.\n",
    "2. Nutze die Funktion in einer `for`-Schleife, um alle geraden Zahlen von 1 bis 20 auszugeben.\n",
    "\n",
    "Gehe wieder in den vier Schritten vor. Hinweis: Eine Zahl ist gerade, wenn beim Teilen durch 2 der Rest `0` bleibt (`%`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Zusatzaufgabe – ist_gerade(zahl) und Anwendung in einer Schleife"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 📌 Das Wichtigste in Kürze\n",
    "- Eine **Funktion** fasst Anweisungen unter einem Namen zusammen: `def name(parameter):` mit eingerücktem Rumpf. Ausgeführt wird sie erst beim **Aufruf**.\n",
    "- **Parameter** bekommen beim Aufruf die **Argumente**, der Reihe nach.\n",
    "- `return wert` gibt einen **Rückgabewert** zurück und beendet die Funktion. Ohne `return` liefert sie `None`.\n",
    "- `print` zeigt nur an, `return` gibt dem Programm den Wert. Wer berechnet, gibt zurück.\n",
    "- Variablen in der Funktion sind **lokal**.\n",
    "- Testen: vorher das erwartete Ergebnis ausrechnen, auch Sonderfälle wie `0` und negative Zahlen prüfen.\n",
    "\n",
    "Zum Weiterüben: `DS08_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
}