{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# DS 1 – Einstieg: Variablen, Eingabe und Ausgabe\n",
    "**Informatik 10 – MINT-Zweig | Textuelle Programmierung und Datenstrukturen**\n",
    "\n",
    "## Lernziele\n",
    "Ich kann\n",
    "- mit `print()` Texte und Zahlen auf dem Bildschirm ausgeben,\n",
    "- Variablen anlegen, ihnen Werte zuweisen und mit ihnen rechnen,\n",
    "- die Datentypen `int`, `float`, `str` und `bool` unterscheiden,\n",
    "- mit `input()` Eingaben einlesen und mit `int()` und `float()` in Zahlen umwandeln,\n",
    "- eine Fehlermeldung lesen und die Ursache des Fehlers finden."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "sprachhilfe"
    ]
   },
   "source": [
    "## 🗣️ Sprachhilfe\n",
    "- *„alter ist 15.“* → „Der Variablen `alter` wird der Wert 15 zugewiesen.“\n",
    "- *„Das Programm fragt nach dem Namen.“* → „Die Eingabeanweisung liest den Namen ein und speichert ihn als Zeichenkette in der Variablen `name`.“\n",
    "- *„Da kommt 14 raus.“* → „Zur Eingabe 7 gibt das Programm den Wert 14 aus.“"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Worum es geht\n",
    "Ein Programm ist eine Liste von Anweisungen, die der Computer der Reihe nach ausführt, von oben nach unten. In der Blockprogrammierung hast du Bausteine zusammengeschoben, in Python schreibst du Text. Heute lernst du die drei wichtigsten Dinge, die fast jedes Programm braucht: Es **gibt etwas aus**, es **merkt sich Werte** und es **liest Eingaben** ein.\n",
    "\n",
    "## 1 Das erste Programm: Ausgaben mit `print`\n",
    "`print` heißt „drucken“, gemeint ist: auf dem Bildschirm anzeigen. Was angezeigt werden soll, steht in den **runden Klammern**, ein Text in **Anführungszeichen**. Python führt die Zeilen **nacheinander von oben nach unten** aus."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Hallo Welt!\")\n",
    "print(\"Guten Morgen!\")\n",
    "print(\"Heute lernen wir Python.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**🧪 Probiere es aus:** Ändere die Texte. Was passiert, wenn du die letzte Zeile an den Anfang verschiebst?\n",
    "\n",
    "### Text oder Zahl?\n",
    "**🔮 Vorhersage:** Was geben die beiden ersten Zeilen aus?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(3 + 4)\n",
    "print(\"3 + 4\")\n",
    "print(\"Ich bin\", 15, \"Jahre alt.\")\n",
    "print(\"In fünf Jahren bin ich\", 15 + 5, \"Jahre alt.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Zeile 1:** Ohne Anführungszeichen ist `3 + 4` eine Rechnung, Python gibt `7` aus.\n",
    "- **Zeile 2:** In Anführungszeichen ist es ein Text, der genau so ausgegeben wird.\n",
    "- **Zeilen 3–4:** Mehrere Dinge trennt man durch **Kommas**. Python setzt je ein Leerzeichen dazwischen.\n",
    "\n",
    "> 📌 **Merksatz:** Mit `print(...)` gibt man Werte auf dem Bildschirm aus. Texte stehen in Anführungszeichen, Zahlen und Rechnungen ohne. Mehrere Werte trennt man durch Kommas.\n",
    "\n",
    "### ⚠️ Wenn etwas schiefgeht\n",
    "Beim Abtippen passieren Fehler, auch Profis jeden Tag. Die Fehlermeldung ist ein Hinweis, wo das Problem liegt. Führe beide Zellen aus."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Hallo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(Hallo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. `SyntaxError: unterminated string literal (detected at line 1)`: Die Schreibweise stimmt nicht, der Text ist nicht abgeschlossen. Python nennt sogar die Zeile.\n",
    "2. `NameError: name 'Hallo' is not defined`: Ohne Anführungszeichen hält Python `Hallo` für einen **Namen**, und den gibt es nicht.\n",
    "\n",
    "Häufige Tippfehler am Anfang: vergessenes Anführungszeichen oder Klammer, `Print` statt `print` (Groß- und Kleinschreibung zählt!) und deutsche Anführungszeichen „…“ statt `\"…\"`. Schau bei einer Fehlermeldung zuerst die genannte Zeile an und die Zeile davor."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2 Variablen: Werte speichern\n",
    "Programme müssen sich Dinge merken: einen Namen, einen Punktestand, einen Preis. Stell dir eine **Variable** wie eine **beschriftete Schachtel** vor: Außen steht der Name, z. B. `alter`, innen liegt ein Wert, z. B. `15`.\n",
    "\n",
    "> 📌 **Definition:** Eine **Variable** ist ein benannter Speicherplatz im Arbeitsspeicher, in dem ein Wert abgelegt wird. Über ihren Namen kann das Programm den Wert lesen und verändern."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "alter = 15\n",
    "print(alter)\n",
    "print(\"Ich bin\", alter, \"Jahre alt.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Zeile 1:** `alter` bekommt den Wert `15`. Auf dem Bildschirm passiert nichts.\n",
    "- **Zeile 2:** `alter` steht ohne Anführungszeichen, Python schaut in die Schachtel und gibt `15` aus.\n",
    "\n",
    "### Das Gleichheitszeichen ist ein Zuweisungszeichen\n",
    "`=` heißt in Python **nicht** „ist gleich“, sondern **„bekommt den Wert“**. Zuerst wird die rechte Seite ausgerechnet, dann kommt das Ergebnis in die Variable links. Darum ist `alter = alter + 1` sinnvoll, obwohl es in Mathe falsch wäre."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "alter = 15\n",
    "print(alter)\n",
    "alter = alter + 1\n",
    "print(alter)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Das **Ablaufprotokoll** zeigt nach jeder Zeile den Wert der Variablen:\n",
    "\n",
    "| Schritt | Zeile | ausgeführte Anweisung | `alter` danach |\n",
    "|:-:|:-:|:--|:-:|\n",
    "| 1 | 1 | `alter = 15` | `15` |\n",
    "| 2 | 2 | `print(alter)` | `15` |\n",
    "| 3 | 3 | `alter = alter + 1` | `16` |\n",
    "| 4 | 4 | `print(alter)` | `16` |\n",
    "\n",
    "Der alte Wert `15` ist nach Zeile 3 weg, er wurde **überschrieben**.\n",
    "\n",
    "> 📌 **Merksatz:** Mit dem **Zuweisungsoperator** `=` wird einer Variablen ein Wert zugewiesen, z. B. `alter = 15`. Zuerst wird die rechte Seite ausgewertet, dann wird das Ergebnis in der Variablen links gespeichert.\n",
    "\n",
    "### Gute Namen für Variablen\n",
    "- Erlaubt sind Buchstaben, Ziffern und `_`. Ein Name darf **nicht mit einer Ziffer beginnen** und **keine Leerzeichen** enthalten.\n",
    "- `alter` und `Alter` sind zwei verschiedene Namen.\n",
    "- Wähle **sprechende Namen**: `preis` statt `p`, `anzahl_artikel` statt `aa`. Verzichte auf Umlaute: `groesse` statt `größe`.\n",
    "\n",
    "> ⚠️ **Stolperstein:** Vertippst du dich beim Namen, meldet Python `NameError: name 'Alter' is not defined. Did you mean: 'alter'?`\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": [
    "punkte = 10\n",
    "print(punkte)\n",
    "punkte = punkte + 5\n",
    "punkte = punkte * 2\n",
    "print(\"Endstand:\", punkte)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Meine Vorhersage:**\n",
    "\n",
    "…"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3 Datentypen: Zahlen, Texte und Wahrheitswerte\n",
    "Die Art eines Wertes heißt **Datentyp**. Davon hängt ab, was man mit dem Wert machen kann: Mit Zahlen kann man rechnen, mit Texten nicht.\n",
    "\n",
    "| Datentyp | Bedeutung | Beispiele |\n",
    "|:--|:--|:--|\n",
    "| `int` | ganze Zahl (*integer*) | `15`, `-3`, `0`, `2026` |\n",
    "| `float` | Kommazahl (*floating point number*) | `1.68`, `-0.5`, `3.0` |\n",
    "| `str` | Zeichenkette, also Text (*string*) | `\"Alex\"`, `\"Hallo Welt!\"`, `\"15\"` |\n",
    "| `bool` | Wahrheitswert (nach George Boole) | `True`, `False` |\n",
    "\n",
    "- Kommazahlen schreibt man mit **Punkt**: `1.68`, nicht `1,68`.\n",
    "- Alles in Anführungszeichen ist Text, auch `\"15\"`.\n",
    "- `True` und `False` schreibt man groß und ohne Anführungszeichen.\n",
    "\n",
    "Mit `type(...)` fragst du Python nach dem Datentyp:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = \"Alex\"\n",
    "alter = 15\n",
    "groesse = 1.68\n",
    "volljaehrig = False\n",
    "print(type(name))\n",
    "print(type(alter))\n",
    "print(type(groesse))\n",
    "print(type(volljaehrig))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> 📌 **Merksatz:** Python unterscheidet u. a. die Datentypen `int` (Ganzzahl), `float` (Kommazahl), `str` (Zeichenkette) und `bool` (Wahrheitswert).\n",
    "\n",
    "### Rechnen mit Zahlen\n",
    "`+`, `-`, `*` (mal) und `/` (geteilt). Es gilt **Punkt vor Strich**, Klammern zuerst. Das Ergebnis von `/` ist **immer** ein `float`, auch wenn die Division aufgeht."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 7\n",
    "b = 2\n",
    "print(a + b)\n",
    "print(a - b)\n",
    "print(a * b)\n",
    "print(a / b)\n",
    "print(2 + 3 * 4)\n",
    "print((2 + 3) * 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ⚠️ Stolperstein: Komma statt Punkt\n",
    "**🔮 Vorhersage:** Was gibt die Zelle aus?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "preis = 2,50\n",
    "print(preis)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Keine Fehlermeldung, aber Python hat zwei Zahlen gespeichert, `2` und `50`. Richtig ist `preis = 2.50`.\n",
    "\n",
    "### ✏️ Übung 2 – Datentypen bestimmen\n",
    "Gib zu jedem Wert den Datentyp an. Überprüfe danach mit `type(...)` in der Codezelle.\n",
    "\n",
    "| Wert | `42` | `\"42\"` | `4.2` | `True` | `\"True\"` | `-7` | `7 / 7` | `\"Hallo\"` |\n",
    "|:--|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|\n",
    "| Datentyp | | | | | | | | |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(type(42))\n",
    "# TODO: die übrigen sieben Werte prüfen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4 Eingaben mit `input`\n",
    "Mit `input(...)` kann die Nutzerin oder der Nutzer etwas eingeben. `input` zeigt zuerst den Text in den Klammern an (die **Eingabeaufforderung**) und **wartet**, bis jemand etwas eintippt und die Eingabetaste drückt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = input(\"Wie heißt du? \")\n",
    "print(\"Hallo\", name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> 💡 **Tipp:** Setze ans Ende der Eingabeaufforderung ein Leerzeichen, sonst klebt die Eingabe am Fragezeichen.\n",
    "\n",
    "### Die Eingabe ist immer ein Text\n",
    "**🔮 Vorhersage:** Gib `7` ein. Was erwartest du?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "zahl = input(\"Gib eine Zahl ein: \")\n",
    "print(zahl + zahl)\n",
    "print(type(zahl))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python rechnet nicht `7 + 7 = 14`, sondern gibt `77` aus. Was jemand eintippt, ist für Python **immer eine Zeichenkette**, und `+` hängt zwei Zeichenketten aneinander: `\"7\" + \"7\"` ergibt `\"77\"`.\n",
    "\n",
    "> 📌 **Merksatz:** Mit `input(...)` liest man eine Eingabe ein. **Die Eingabe ist immer vom Typ `str`!**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5 Typumwandlung: aus Text wird eine Zahl\n",
    "\n",
    "| Befehl | wandelt um in | Beispiel | Ergebnis |\n",
    "|:--|:--|:--|:--|\n",
    "| `int(...)` | ganze Zahl | `int(\"7\")` | `7` |\n",
    "| `float(...)` | Kommazahl | `float(\"2.5\")` | `2.5` |\n",
    "| `str(...)` | Zeichenkette | `str(15)` | `\"15\"` |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lieblingszahl = input(\"Gib deine Lieblingszahl ein: \")\n",
    "print(\"Deine Eingabe war:\", lieblingszahl, \"- Typ:\", type(lieblingszahl))\n",
    "\n",
    "lieblingszahl_int = int(lieblingszahl)\n",
    "print(\"Deine Zahl mal 2 ist:\", lieblingszahl_int * 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Eingabe und Umwandlung in einer Zeile\n",
    "Meistens schreibt man beides in **eine** Zeile. Lies sie **von innen nach außen**: Zuerst liefert `input(...)` den Text `\"15\"`, dann macht `int(...)` daraus die Zahl `15`. Am Ende stehen **zwei** schließende Klammern. Für Kommazahlen nimmst du `float`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "alter = int(input(\"Wie alt bist du? \"))\n",
    "print(\"Nächstes Jahr bist du\", alter + 1)\n",
    "\n",
    "groesse = float(input(\"Wie groß bist du in Metern? \"))\n",
    "print(\"In Zentimetern sind das\", groesse * 100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> 📌 **Merksatz:** Soll eine Eingabe als Zahl weiterverarbeitet werden, muss sie umgewandelt werden: `int(...)` bzw. `float(...)` (**Typumwandlung**).\n",
    "\n",
    "> ⚠️ **Stolperstein:** Gibt jemand `sieben` ein, meldet `int(...)` einen `ValueError: invalid literal for int() with base 10: 'sieben'`. Ebenso bei `int(\"2.5\")` und `float(\"2,5\")`. Schau dann nach, **was eingegeben wurde**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6 Texte zusammensetzen\n",
    "Mit Kommas setzt `print` immer ein Leerzeichen dazwischen. Soll direkt nach einem Namen ein Komma oder Punkt folgen, hängst du Texte mit `+` **aneinander** (verketten). Leerzeichen musst du dann selbst in die Anführungszeichen schreiben."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = \"Alex\"\n",
    "print(\"Hallo, \" + name + \"!\")\n",
    "print(\"Hallo,\", name, \"!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ⚠️ Stolperstein: Text plus Zahl\n",
    "Mit `+` lassen sich nur **Texte mit Texten** verbinden. Führe die Zelle aus."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "alter = 15\n",
    "print(\"Du bist \" + alter + \" Jahre alt.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lies die Fehlermeldung **von unten nach oben**:\n",
    "1. **Letzte Zeile:** `TypeError: can only concatenate str (not \"int\") to str`, also „kann nur `str` (nicht `int`) an `str` anhängen“.\n",
    "2. **Darüber:** die Zeile, in der der Fehler passiert ist, und Zeichen `^`, die auf die Stelle zeigen.\n",
    "\n",
    "Richtig ist `print(\"Du bist \" + str(alter) + \" Jahre alt.\")`.\n",
    "\n",
    "| Fehler | Bedeutung | typische Ursache |\n",
    "|:--|:--|:--|\n",
    "| `SyntaxError` | Schreibweise falsch | Anführungszeichen oder Klammer fehlt |\n",
    "| `NameError` | Name unbekannt | Tippfehler, Variable noch nicht angelegt, Anführungszeichen vergessen |\n",
    "| `TypeError` | Datentyp passt nicht | Zahl und Text mit `+` verbunden |\n",
    "| `ValueError` | Wert passt nicht | `int(\"sieben\")`, `float(\"2,5\")` |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 📝 Übungen: Schritt für Schritt selbstständig\n",
    "Die Übungen werden schrittweise schwieriger. Das **Musterbeispiel** ist ganz vorgemacht. Übung 3 ist eine Fehlersuche, bei Übung 4 füllst du Lücken `___` aus, bei Übung 5 steht nur noch ein Gerüst aus Kommentaren, die Zusatzaufgabe schreibst du allein. Gehe jedes Mal in drei Schritten vor:\n",
    "\n",
    "| Schritt | Frage |\n",
    "|:-:|:--|\n",
    "| 1 | **Eingabe:** Was muss das Programm abfragen? Text oder Zahl (`int`/`float`)? |\n",
    "| 2 | **Verarbeitung:** Was muss gerechnet werden? |\n",
    "| 3 | **Ausgabe:** Was soll auf dem Bildschirm stehen? |\n",
    "\n",
    "### 🧩 Musterbeispiel (vorgemacht) – Kinobesuch\n",
    "Aufgabe: Das Programm fragt nach dem Namen und nach der Anzahl der Kinokarten. Eine Karte kostet 9.50 €. Es gibt den Gesamtpreis in einem Satz aus.\n",
    "\n",
    "1. **Eingabe:** Der Name ist ein Text, also nur `input(...)`. Die Anzahl ist eine ganze Zahl, also `int(input(...))`.\n",
    "2. **Verarbeitung:** `gesamt = anzahl * 9.50`.\n",
    "3. **Ausgabe:** Der Name soll direkt vor einem Komma stehen, deshalb `+`. Die Zahl `gesamt` muss dafür mit `str(...)` umgewandelt werden.\n",
    "\n",
    "Lies den Code Zeile für Zeile und führe ihn aus, z. B. mit `Alex` und `3`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Schritt 1: Eingabe\n",
    "name = input(\"Wie heißt du? \")\n",
    "anzahl = int(input(\"Wie viele Karten? \"))\n",
    "\n",
    "# Schritt 2: Verarbeitung\n",
    "gesamt = anzahl * 9.50\n",
    "\n",
    "# Schritt 3: Ausgabe\n",
    "print(\"Danke, \" + name + \"! Das macht \" + str(gesamt) + \" Euro.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 🐞 Übung 3 – Fehler finden\n",
    "Das Programm soll nach zwei Zahlen fragen und ihre Summe ausgeben. Es enthält **drei Fehler**. Finde sie, erkläre jeweils, welche Fehlermeldung oder welches falsche Verhalten sie auslösen, und schreibe das Programm in der zweiten Zelle richtig auf. Tipp: Ein Fehler erzeugt keine Fehlermeldung, sondern ein falsches Ergebnis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fehlerhafter Code – erst lesen, dann korrigieren\n",
    "# zahl1 = input(\"Erste Zahl: )\n",
    "# zahl2 = input(\"Zweite Zahl: \")\n",
    "# print(\"Die Summe ist\", Zahl1 + zahl2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Korrigierte Fassung (Kontrolle: 3 und 4 ergeben 7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Die drei Fehler:**\n",
    "\n",
    "…\n",
    "\n",
    "### 📝 Übung 4 – Steckbrief (Lücken füllen)\n",
    "Das Programm fragt Name, Alter (als Zahl!) und Lieblingsfach ab und gibt einen vollständigen Satz aus. In der letzten Zeile steht das **doppelte Alter**: Daran siehst du, ob das Alter wirklich als Zahl gespeichert ist. Ersetze jedes `___`.\n",
    "\n",
    "```\n",
    "Wie heißt du? Alex\n",
    "Wie alt bist du? 15\n",
    "Was ist dein Lieblingsfach? Informatik\n",
    "Hallo, ich bin Alex, 15 Jahre alt und mein Lieblingsfach ist Informatik.\n",
    "Doppeltes Alter: 30\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Schritt 1: Eingabe\n",
    "name = input(\"Wie heißt du? \")\n",
    "alter = ___(input(\"Wie alt bist du? \"))\n",
    "fach = input(\"Was ist dein Lieblingsfach? \")\n",
    "\n",
    "# Schritt 3: Ausgabe\n",
    "print(\"Hallo, ich bin \" + name + \", \" + ___(alter)\n",
    "      + \" Jahre alt und mein Lieblingsfach ist \" + ___ + \".\")\n",
    "print(\"Doppeltes Alter:\", ___)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 📝 Übung 5 – Einfacher Rechner (mit Gerüst)\n",
    "Das Programm liest zwei Zahlen ein und gibt **Summe, Differenz und Produkt** aus. Ersetze die Kommentare durch Programmzeilen. Kontrolle: 7.5 und 2 ergeben 9.5, 5.5 und 15.0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Schritt 1: erste Zahl einlesen und in eine Kommazahl umwandeln\n",
    "# Schritt 1: zweite Zahl einlesen und umwandeln\n",
    "# Schritt 2 und 3: Summe ausgeben\n",
    "#                  Differenz ausgeben\n",
    "#                  Produkt ausgeben"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 🚀 Zusatzaufgabe – Gesamtpreis (selbstständig)\n",
    "Frage einen Preis in Euro (als Kommazahl) und eine Anzahl an Artikeln (als ganze Zahl) ab und berechne den Gesamtpreis. Runde die Ausgabe auf zwei Stellen. Kontrolle: 1.99 € und 3 Artikel ergeben 5.97 Euro.\n",
    "\n",
    "> 🧰 **Werkzeug:** `round(wert, stellen)` rundet auf eine bestimmte Anzahl Nachkommastellen: `round(3.14159, 2)` ergibt `3.14`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Zusatzaufgabe – Gesamtpreis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 📌 Das Wichtigste in Kürze\n",
    "- `print(...)` gibt Werte aus. Texte stehen in Anführungszeichen, mehrere Werte trennt man durch Kommas.\n",
    "- Eine **Variable** ist ein benannter Speicherplatz. `=` heißt „bekommt den Wert“: erst rechts rechnen, dann links speichern.\n",
    "- Datentypen: `int`, `float` (mit Punkt!), `str`, `bool`. `/` liefert immer einen `float`.\n",
    "- `input(...)` liefert **immer** einen Text. Zum Rechnen umwandeln mit `int(...)` oder `float(...)`.\n",
    "- Texte verkettet man mit `+`, Zahlen vorher mit `str(...)` umwandeln.\n",
    "- Fehlermeldungen von unten nach oben lesen: `SyntaxError`, `NameError`, `TypeError`, `ValueError`.\n",
    "\n",
    "Zum Weiterüben: `DS01_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
}