{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# DS 11 – Listen: viele Werte unter einem Namen\n",
    "**Informatik 10 – MINT-Zweig | Datenstrukturen**\n",
    "\n",
    "## Lernziele\n",
    "Ich kann\n",
    "- eine Liste (ein Feld) als Datenstruktur beschreiben, die mehrere Elemente der Reihe nach zu einer Einheit zusammenfasst,\n",
    "- zwischen dem **Index** und dem **Element** an dieser Stelle unterscheiden,\n",
    "- über den Index lesend und schreibend auf einzelne Listenelemente zugreifen,\n",
    "- Elemente mit `append`, `insert`, `pop` und `remove` hinzufügen und entfernen,\n",
    "- mit einer Schleife alle Elemente einer Liste durchlaufen,\n",
    "- die Fehlermeldung `IndexError` erklären und den Fehler beheben."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "sprachhilfe"
    ]
   },
   "source": [
    "## 🗣️ Sprachhilfe\n",
    "- *„Die 5 ist an Stelle 1.“* → „Das Listenelement am Index 1 hat den Wert 5.“\n",
    "- *„Ich mach die 3 zur 5.“* → „Das Listenelement am Index 1 wird von 3 auf 5 verändert.“\n",
    "- *„Die 6 kommt hinten dran.“* → „Mit `append` wird das Element 6 am Ende der Liste hinzugefügt.“\n",
    "- *„Da kommt ein Fehler.“* → „Beim Zugriff auf die ungültige Listenposition 5 erhalte ich die Fehlermeldung `IndexError`.“"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1 Warum Listen?\n",
    "Speicherst du fünf Noten in `note1` bis `note5`, hat das zwei Schwächen: Kommt eine sechste Note dazu, brauchst du eine neue Variable **und** musst jede Rechnung ändern. Außerdem kann keine Schleife über `note1` bis `note5` laufen, denn für Python sind das fünf unabhängige Namen.\n",
    "\n",
    "Mit einer **Liste** speicherst du alle Noten in **einer** Variablen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "noten = [2, 3, 1, 4, 2]\n",
    "print(noten)\n",
    "print(type(noten))\n",
    "\n",
    "staedte = [\"Saarbrücken\", \"Trier\", \"Mainz\"]\n",
    "leer = []\n",
    "print(staedte)\n",
    "print(leer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Eine Liste schreibt man in **eckigen Klammern**, die Werte werden durch Kommas getrennt. Der Datentyp heißt `list`.\n",
    "- Die Werte heißen **Elemente**. Sie stehen in fester Reihenfolge, wie die Waggons eines Zuges: Eine Liste ist eine **lineare** Datenstruktur.\n",
    "- Zeichenketten in einer Liste zeigt Python mit `'…'` an. Das ist nur die Anzeige.\n",
    "- Die leere Liste `[]` legt man an und füllt sie später nach und nach.\n",
    "\n",
    "In anderen Sprachen wie Java heißt diese Datenstruktur **Feld** (*array*) und hat meist eine feste Länge. Eine Python-Liste kann wachsen und schrumpfen.\n",
    "\n",
    "> 📌 **Merksatz:** Eine **Liste** (in Python: `list`) fasst mehrere **Elemente zu einer Einheit** zusammen, z. B. `noten = [2, 3, 1, 4, 2]`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2 Index und Element\n",
    "Denk an die Schließfächer in deiner Schule: Jedes Fach hat eine **Nummer** an der Tür, und darin liegt ein **Inhalt**. Wer „Fach 2“ sagt, meint die Nummer, nicht den Inhalt. Bei einer Liste heißt die Nummer **Index** (ab 0 gezählt wie bei Zeichenketten), der Inhalt **Element**.\n",
    "\n",
    "| Index | 0 | 1 | 2 | 3 | 4 |\n",
    "|---|:-:|:-:|:-:|:-:|:-:|\n",
    "| Element | `2` | `3` | `1` | `4` | `2` |\n",
    "\n",
    "### Lesender Zugriff\n",
    "Den Index schreibst du in eckigen Klammern hinter den Namen der Liste."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "noten = [2, 3, 1, 4, 2]\n",
    "print(noten[0])\n",
    "print(noten[2])\n",
    "print(len(noten))\n",
    "print(noten[len(noten) - 1])\n",
    "print(noten[-1], noten[-2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `noten[2]` liefert die `1`, also das **dritte** Element. Die Zahl in den eckigen Klammern ist der Index, nicht der Wert!\n",
    "- Das Element `2` kommt zweimal vor: am Index 0 und am Index 4.\n",
    "- Die Liste hat fünf Elemente, das letzte hat den Index `len(noten) - 1`, also 4. Kürzer: `noten[-1]`.\n",
    "\n",
    "> 📌 **Merksatz:** Jedes Element besitzt einen **Index**, beginnend bei `0`. Der Index ist **nicht** dasselbe wie der gespeicherte Wert! **Lesender Zugriff:** `liste[index]`. Die Anzahl der Elemente liefert `len(liste)`.\n",
    "\n",
    "### 🔮 Übung 1 – Index oder Element?\n",
    "Gegeben ist `zahlen = [3, 0, 4, 1, 2]`. Bestimme **ohne Computer** die Werte und trage sie in die Tabelle ein. An welchem Index steht das Element `4`? Prüfe danach in der Codezelle.\n",
    "\n",
    "| `zahlen[1]` | `len(zahlen)` | `zahlen[-1]` | `zahlen[zahlen[0]]` | Index von `4` |\n",
    "|:-:|:-:|:-:|:-:|:-:|\n",
    "| | | | | |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "zahlen = [3, 0, 4, 1, 2]\n",
    "# TODO: Prüfe deine Vorhersage mit print(...)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3 Schreibender Zugriff: ein Element ändern\n",
    "Ein Schließfach kann man ausräumen und neu füllen, die Nummer bleibt gleich. Steht der Zugriff mit Index **links** vom `=`, wird das Element **überschrieben**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "noten = [2, 3, 1, 4, 2]\n",
    "noten[1] = 5\n",
    "print(noten)\n",
    "noten[2] = noten[2] + 1\n",
    "print(noten)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Zeile 2:** Das Element am Index 1 bekommt den Wert `5`. Der alte Wert `3` ist weg.\n",
    "- **Zeile 4:** Wie bei `x = x + 1` wird zuerst rechts gerechnet: `noten[2]` ist `1`, plus 1 ergibt `2`.\n",
    "\n",
    "Die Länge der Liste ändert sich dabei nicht.\n",
    "\n",
    "> 📌 **Merksatz:** **Schreibender Zugriff:** `liste[index] = neuer_wert` überschreibt das Element an dieser Position.\n",
    "\n",
    "### ⚠️ Stolpersteine\n",
    "Führe die drei Zellen aus und lies jeweils die letzte Zeile der Fehlermeldung."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1. Eine Zeichenkette kann man nicht stellenweise ändern.\n",
    "wort = \"Hallo\"\n",
    "wort[0] = \"B\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 2. Den Index 5 gibt es bei fünf Elementen nicht.\n",
    "noten = [2, 3, 1, 4, 2]\n",
    "print(noten[5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3. Auch durch eine Zuweisung wird die Liste nicht länger.\n",
    "noten = [2, 3, 1, 4, 2]\n",
    "noten[5] = 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. `TypeError: 'str' object does not support item assignment`: Zeichenketten kann man nur lesen. Listen sind dagegen **veränderbar**.\n",
    "2. `IndexError: list index out of range`: Gültig sind nur die Indizes 0 bis 4 (und −1 bis −5).\n",
    "3. `IndexError: list assignment index out of range`: Zum Hinzufügen braucht man `append` (Teil 4).\n",
    "\n",
    "Häufigste Ursache: Man zählt aus Gewohnheit ab 1 und schreibt `liste[len(liste)]`. Prüfe bei einem `IndexError` immer: Wie lang ist die Liste gerade, und welchen Index habe ich benutzt?\n",
    "\n",
    "> 📌 **Merksatz:** Ein Zugriff auf einen ungültigen Index führt zu einem `IndexError`. Bei einer Liste mit `n` Elementen sind nur die Indizes `0` bis `n - 1` gültig."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4 Listen verändern: Elemente hinzufügen und entfernen\n",
    "Eine Liste kann wachsen und schrumpfen. Dafür gibt es **Methoden**, die man mit einem Punkt anhängt, wie `text.upper()` bei Zeichenketten.\n",
    "\n",
    "### `append` und `insert`\n",
    "`liste.append(wert)` hängt ein Element **am Ende** an. `liste.insert(index, wert)` fügt es an einer **beliebigen Stelle** ein: Alle Elemente ab dieser Stelle rücken eine Position nach rechts."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "noten = [2, 5, 1, 4, 2]\n",
    "noten.append(6)\n",
    "print(noten)\n",
    "\n",
    "einkauf = [\"Brot\", \"Milch\", \"Eier\"]\n",
    "einkauf.insert(1, \"Käse\")\n",
    "print(einkauf)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Die 6 steht jetzt am Index 5. Der Käse steht am Index 1, die Milch ist von Index 1 auf Index 2 gerückt.\n",
    "\n",
    "### `pop` und `remove`\n",
    "`liste.pop(index)` entfernt das Element **am Index**, ohne Index das **letzte**. `pop` gibt das entfernte Element zurück, so wie eine Funktion mit `return`. `liste.remove(wert)` sucht ein **Element mit diesem Wert** und entfernt das erste Vorkommen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "einkauf = [\"Brot\", \"Käse\", \"Milch\", \"Eier\"]\n",
    "letztes = einkauf.pop()\n",
    "print(letztes)\n",
    "print(einkauf)\n",
    "erstes = einkauf.pop(0)\n",
    "print(erstes)\n",
    "print(einkauf)\n",
    "\n",
    "einkauf = [\"Brot\", \"Käse\", \"Milch\", \"Käse\"]\n",
    "einkauf.remove(\"Käse\")\n",
    "print(einkauf)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| Methode | Wirkung | in den Klammern steht |\n",
    "|:--|:--|:--|\n",
    "| `liste.append(wert)` | hängt `wert` ans Ende an | ein Element |\n",
    "| `liste.insert(i, wert)` | fügt `wert` am Index `i` ein | ein Index und ein Element |\n",
    "| `liste.pop()` | entfernt das letzte Element und gibt es zurück | nichts |\n",
    "| `liste.pop(i)` | entfernt das Element am Index `i` und gibt es zurück | ein Index |\n",
    "| `liste.remove(wert)` | entfernt das erste Element mit dem Wert `wert` | ein Element |\n",
    "\n",
    "> ⚠️ **Stolperstein:** Ist der Wert nicht in der Liste, meldet `remove` einen `ValueError: list.remove(x): x not in list`. Aus einer leeren Liste kann `pop` nichts entfernen: `IndexError: pop from empty list`.\n",
    "\n",
    "> 📌 **Merksatz:** `append` hängt an, `insert` fügt ein, `pop` entfernt am **Index**, `remove` entfernt ein **Element** mit einem bestimmten Wert.\n",
    "\n",
    "### 🔮 Übung 2 – Listen-Vorhersage\n",
    "Lies das Programm, **ohne** es auszuführen. Zeichne die Liste `tiere` nach jeder Zeile als Reihe von Kästchen mit dem Index darüber. Gib dann die Ausgabe an und prüfe am Computer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tiere = [\"Hund\", \"Katze\", \"Maus\"]\n",
    "tiere.append(\"Igel\")\n",
    "tiere[0] = \"Pferd\"\n",
    "tiere.insert(2, \"Esel\")\n",
    "tiere.remove(\"Katze\")\n",
    "x = tiere.pop()\n",
    "print(tiere)\n",
    "print(x)\n",
    "print(len(tiere))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Die Liste nach jeder Zeile und meine Vorhersage:**\n",
    "\n",
    "…"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5 Listen mit Schleifen durchlaufen\n",
    "Über die Elemente einer Liste läufst du wie über die Zeichen einer Zeichenkette. Brauchst du auch den **Index**, läufst du mit `range(len(liste))` über alle gültigen Indizes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "staedte = [\"Saarbrücken\", \"Trier\", \"Mainz\", \"Koblenz\"]\n",
    "for stadt in staedte:\n",
    "    print(\"Ich fahre nach\", stadt)\n",
    "\n",
    "for i in range(len(staedte)):\n",
    "    print(i, staedte[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**🧪 Probiere es aus:** Ändere die zweite Schleife zu `for i in range(1, len(staedte) + 1):`. Was gibt das Programm aus, bevor es abbricht? Welche Indizes erzeugt `range` jetzt, und welcher davon ist ungültig?\n",
    "\n",
    "### Eine Liste mit einer Schleife füllen\n",
    "Ein sehr häufiges Muster: mit einer **leeren Liste** beginnen und in der Schleife ein Element nach dem anderen anhängen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "quadratzahlen = []\n",
    "for zahl in range(1, 6):\n",
    "    quadratzahlen.append(zahl * zahl)\n",
    "print(quadratzahlen)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Stünde `print` eingerückt in der Schleife, würde die Liste fünfmal ausgegeben, jedes Mal ein Stück länger.\n",
    "\n",
    "> 📌 **Merksatz:** `for element in liste:` durchläuft die Elemente, `for i in range(len(liste)):` durchläuft die Indizes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 📝 Übungen: Schritt für Schritt selbstständig\n",
    "Vorgemacht ist das Muster **Eine Liste mit einer Schleife füllen** (`quadratzahlen`). Bei Übung 3 füllst du Lücken `___` aus, bei Übung 4 steht ein Gerüst aus Kommentaren, die Zusatzaufgabe schreibst du allein.\n",
    "\n",
    "## 📝 Übung 3 – Einkaufsliste (Lücken füllen)\n",
    "Lege eine leere Liste an. Frage nacheinander 5 Artikelnamen ab (mit `input()` in einer Schleife) und füge sie mit `append()` hinzu. Gib die vollständige Liste am Ende aus."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "einkaufsliste = ___\n",
    "for i in range(___):\n",
    "    artikel = input(\"Artikel eingeben: \")\n",
    "    einkaufsliste.___(artikel)\n",
    "print(einkaufsliste)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 📝 Übung 4 – Index vs. Wert (mit Gerüst)\n",
    "Gegeben ist `staedte = [\"Saarbrücken\", \"Trier\", \"Mainz\", \"Koblenz\"]`.\n",
    "1. Gib den Wert am Index 2 aus.\n",
    "2. Ändere den Wert am Index 0 zu `\"Saarlouis\"` und gib die Liste aus.\n",
    "3. Gib den **Index** der Stadt `\"Mainz\"` aus.\n",
    "\n",
    "> 🧰 **Werkzeug:** `liste.index(wert)` liefert den Index des ersten Elements mit diesem Wert. Ist der Wert nicht in der Liste, kommt ein `ValueError`. In DS 12 programmierst du so eine Suche selbst."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "staedte = [\"Saarbrücken\", \"Trier\", \"Mainz\", \"Koblenz\"]\n",
    "\n",
    "# 1. den Wert am Index 2 ausgeben\n",
    "\n",
    "# 2. den Wert am Index 0 zu \"Saarlouis\" ändern und die Liste ausgeben\n",
    "\n",
    "# 3. den Index von \"Mainz\" ausgeben (erwartet: 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 🚀 Zusatzaufgabe – Liste umkehren (selbstständig)\n",
    "Erzeuge aus `zahlen = [1, 2, 3, 4, 5]` mit einer Schleife eine **neue** Liste mit den Elementen in umgekehrter Reihenfolge. Verwende keine eingebaute Funktion zum Umkehren. Kontrolle: `[5, 4, 3, 2, 1]`.\n",
    "\n",
    "> 💡 **Tipp:** `range(4, -1, -1)` erzeugt 4, 3, 2, 1, 0. Die mittlere Zahl ist die Grenze, die **nicht** mehr erreicht wird."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "zahlen = [1, 2, 3, 4, 5]\n",
    "\n",
    "# Zusatzaufgabe – Liste per Schleife umkehren"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 📌 Das Wichtigste in Kürze\n",
    "- Eine **Liste** (ein **Feld**) fasst mehrere **Elemente** in einer festen Reihenfolge zu einer Einheit zusammen: `noten = [2, 3, 1, 4, 2]`.\n",
    "- Jedes Element hat einen **Index**, beginnend bei 0. Index und Element sind verschiedene Dinge: `noten[2]` ist das Element am Index 2.\n",
    "- **Lesen:** `liste[i]`. **Schreiben:** `liste[i] = wert`. `liste[-1]` ist das letzte Element.\n",
    "- `len(liste)` liefert die Anzahl der Elemente. Gültige Indizes sind `0` bis `len(liste) - 1`, sonst kommt ein `IndexError`.\n",
    "- `append` hängt an, `insert` fügt ein, `pop` entfernt am Index, `remove` entfernt ein Element mit einem bestimmten Wert.\n",
    "- `for element in liste:` durchläuft die Elemente, `for i in range(len(liste)):` durchläuft die Indizes.\n",
    "\n",
    "Zum Weiterüben: `DS11_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
}