{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# DS 10 – Zeichenketten: Texte Zeichen für Zeichen\n",
    "**Informatik 10 – MINT-Zweig | Datenstrukturen**\n",
    "\n",
    "## Lernziele\n",
    "Ich kann\n",
    "- eine Zeichenkette als Folge (Sequenz) von Zeichen beschreiben und den Index eines Zeichens angeben,\n",
    "- mit `text[index]` auf einzelne Zeichen zugreifen und mit `len(text)` die Länge bestimmen,\n",
    "- Zeichenketten verketten und Ausgaben mit f-Strings bequem zusammensetzen,\n",
    "- mit einer Schleife alle Zeichen einer Zeichenkette durchlaufen,\n",
    "- `in`, `.upper()`, `.lower()`, `.isalpha()` und `.isdigit()` anwenden,\n",
    "- einen `IndexError` erklären und vermeiden."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "sprachhilfe"
    ]
   },
   "source": [
    "## 🗣️ Sprachhilfe\n",
    "- „Das Zeichen am Index … ist …, weil ab 0 gezählt wird.“\n",
    "- „Die Schleife durchläuft nacheinander alle Zeichen. In jedem Durchlauf prüft sie, ob …, und erhöht dann …“\n",
    "- „Der `IndexError` entsteht, weil der Text nur … Zeichen hat. Gültig sind die Indizes 0 bis … .“"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Worum es geht\n",
    "Namen, Passwörter, Nachrichten: Sehr viele Daten in Programmen sind Texte. Bisher hast du Texte nur als Ganzes benutzt. Oft muss ein Programm aber **in einen Text hineinschauen**: Wie lang ist das Passwort? Enthält es eine Ziffer? Mit welchem Buchstaben beginnt der Name? Dafür lernst du heute, wie Python einen Text sieht: als Reihe einzelner Zeichen, jedes an einer festen Position."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1 Eine Zeichenkette ist eine Folge von Zeichen\n",
    "Für Python besteht ein Text aus einzelnen **Zeichen**, die der Reihe nach hintereinander stehen, wie Perlen auf einer Schnur. Ein Zeichen ist ein Buchstabe, eine Ziffer, ein Satzzeichen oder auch ein Leerzeichen. Die Position eines Zeichens heißt **Index**. Gezählt wird ab **0**:\n",
    "\n",
    "| Index | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |\n",
    "|---|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|\n",
    "| Zeichen | `I` | `n` | `f` | `o` | `r` | `m` | `a` | `t` | `i` | `k` |\n",
    "\n",
    "Die Zeichenkette `\"Informatik\"` hat 10 Zeichen, aber der größte Index ist 9. Man kann sich den Index als Abstand vom Anfang vorstellen: Das erste Zeichen ist 0 Schritte vom Anfang entfernt.\n",
    "\n",
    "> 📌 **Merksatz:** Eine **Zeichenkette** (`str`) ist eine **Sequenz von Zeichen**, z. B. `\"Informatik\"`. Jedes Zeichen hat eine **Position (Index)**, beginnend bei `0`.\n",
    "\n",
    "### Auf einzelne Zeichen zugreifen\n",
    "Den Index schreibst du in **eckigen Klammern** hinter die Zeichenkette. Vergleiche die Ausgabe mit der Tabelle."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "text = \"Informatik\"\n",
    "print(text[0])\n",
    "print(text[2])\n",
    "print(text[9])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`text[2]` ist das **dritte** Zeichen, `f`. In den eckigen Klammern darf auch eine Variable oder Rechnung stehen, zum Beispiel `text[i]` oder `text[i + 1]`.\n",
    "\n",
    "### Die Länge einer Zeichenkette\n",
    "Wie viele Zeichen ein Text hat, verrät die Funktion `len` (englisch *length*, „Länge“). Auch das Leerzeichen zählt mit. `\"\"` ist die **leere Zeichenkette** mit der Länge 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "text = \"Informatik\"\n",
    "print(len(text))\n",
    "print(len(\"Ada Lovelace\"))\n",
    "print(len(\"\"))\n",
    "\n",
    "letzter_index = len(text) - 1\n",
    "print(letzter_index)\n",
    "print(text[letzter_index])\n",
    "print(text[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Weil ab 0 gezählt wird, hat das **letzte Zeichen** immer den Index `len(text) - 1`. Kürzer geht es mit einem **negativen Index**, der von hinten zählt: `text[-1]` ist das letzte Zeichen, `text[-2]` das vorletzte.\n",
    "\n",
    "> 📌 **Merksatz:** Die **Länge** erhält man mit `len(text)`. Das letzte Zeichen hat den Index `len(text) - 1` oder kurz `-1`.\n",
    "\n",
    "### ⚠️ Stolperstein: Der Index ist zu groß\n",
    "Führe die Zelle aus und lies die Fehlermeldung."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "text = \"Informatik\"\n",
    "print(text[10])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`IndexError: string index out of range` heißt: „Der Index liegt außerhalb des gültigen Bereichs.“ Gültig sind bei 10 Zeichen nur die Indizes 0 bis 9 (und −1 bis −10). Prüfe bei diesem Fehler: Wie lang ist der Text, und welcher Index wurde benutzt?\n",
    "\n",
    "### 🔮 Übung 1 – Zeichen bestimmen\n",
    "Gib **ohne** Computer an, was jede Zeile ausgibt. Eine Zeile führt zu einem Fehler: welche, und warum? Schreibe deine Vorhersage in die Textzelle und führe den Code erst danach aus."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "wort = \"Python\"\n",
    "print(wort[1])\n",
    "print(len(wort))\n",
    "print(wort[len(wort) - 1])\n",
    "print(wort[-2])\n",
    "print(wort[6])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Meine Vorhersage:**\n",
    "\n",
    "…"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2 Zeichenketten verketten\n",
    "Mit `+` hängst du Zeichenketten aneinander. Verkettung und Index-Zugriff lassen sich kombinieren."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vorname = \"Ada\"\n",
    "nachname = \"Lovelace\"\n",
    "name = vorname + \" \" + nachname\n",
    "print(name)\n",
    "initialen = vorname[0] + nachname[0]\n",
    "print(initialen)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ohne das `\" \"` in der Mitte stünde `AdaLovelace` da. Ada Lovelace gilt übrigens als erste Programmiererin der Welt.\n",
    "\n",
    "### 🧰 Werkzeug: f-Strings\n",
    "Texte mit Zahlen mit `+` zusammenzusetzen ist mühsam: Jede Zahl muss mit `str(...)` umgewandelt werden. Bequemer ist ein **f-String**: ein `f` direkt vor dem ersten Anführungszeichen, und im Text Variablen oder Rechnungen in **geschweiften Klammern** `{...}`. Zeile 3 und Zeile 4 erzeugen dieselbe Ausgabe."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = \"Alex\"\n",
    "alter = 15\n",
    "print(f\"{name} ist {alter} Jahre alt.\")\n",
    "print(name + \" ist \" + str(alter) + \" Jahre alt.\")\n",
    "print(f\"{name} hat {len(name)} Buchstaben.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vergisst du das `f`, erscheinen die geschweiften Klammern unverändert in der Ausgabe.\n",
    "\n",
    "> 📌 **Merksatz:** Die **Verkettung** (Konkatenation) zweier Zeichenketten erfolgt mit `+`. Ein **f-String** `f\"... {wert} ...\"` setzt Werte direkt in einen Text ein."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3 Alle Zeichen durchlaufen\n",
    "Mit einer `for`-Schleife bearbeitest du nacheinander **jedes Zeichen**. Statt `range(...)` schreibst du hinter `in` einfach die Zeichenkette."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for zeichen in \"Bit\":\n",
    "    print(zeichen)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Die Schleifenvariable `zeichen` bekommt im ersten Durchlauf `\"B\"`, dann `\"i\"`, dann `\"t\"`. Der Name `zeichen` ist frei gewählt.\n",
    "\n",
    "### Zeichen zählen\n",
    "**🔮 Vorhersage:** Welche Zahl gibt das Programm aus? Achte auf das große `A`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "wort = \"Anna\"\n",
    "anzahl = 0\n",
    "for zeichen in wort:\n",
    "    if zeichen == \"n\":\n",
    "        anzahl = anzahl + 1\n",
    "print(\"Anzahl n:\", anzahl)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Zeile 2:** Die Zählvariable `anzahl` startet bei 0.\n",
    "- **Zeilen 3–5:** Die Schleife läuft über alle vier Zeichen. Nur wenn das aktuelle Zeichen ein `n` ist, wird `anzahl` um 1 erhöht.\n",
    "- **Zeile 6:** Erst nach der Schleife (nicht eingerückt) wird das Ergebnis ausgegeben.\n",
    "\n",
    "Das große `A` am Anfang wird **nicht** gezählt, denn `\"A\"` und `\"a\"` sind für Python verschiedene Zeichen.\n",
    "\n",
    "| Schritt | Zeile | Anweisung | `zeichen` | `anzahl` |\n",
    "|:-:|:-:|:--|:-:|:-:|\n",
    "| 1 | 1 | `wort = \"Anna\"` | – | – |\n",
    "| 2 | 2 | `anzahl = 0` | – | `0` |\n",
    "| 3 | 3 | `for zeichen in wort:` | `\"A\"` | `0` |\n",
    "| 4 | 4 | `if zeichen == \"n\":` | `\"A\"` | `0` |\n",
    "| 5 | 3 | `for zeichen in wort:` | `\"n\"` | `0` |\n",
    "| 6 | 4 | `if zeichen == \"n\":` | `\"n\"` | `0` |\n",
    "| 7 | 5 | `anzahl = anzahl + 1` | `\"n\"` | `1` |\n",
    "| 8 | 3 | `for zeichen in wort:` | `\"n\"` | `1` |\n",
    "| 9 | 4 | `if zeichen == \"n\":` | `\"n\"` | `1` |\n",
    "| 10 | 5 | `anzahl = anzahl + 1` | `\"n\"` | `2` |\n",
    "| 11 | 3 | `for zeichen in wort:` | `\"a\"` | `2` |\n",
    "| 12 | 4 | `if zeichen == \"n\":` | `\"a\"` | `2` |\n",
    "| 13 | 3 | `for zeichen in wort:` | `\"a\"` | `2` |\n",
    "| 14 | 6 | `print(\"Anzahl n:\", anzahl)` | `\"a\"` | `2` |\n",
    "\n",
    "### Einen neuen Text aufbauen\n",
    "Man beginnt mit der leeren Zeichenkette `\"\"` und hängt in jedem Durchlauf etwas an. **🔮 Vorhersage:** Was kommt heraus?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "neu = \"\"\n",
    "for zeichen in \"Bit\":\n",
    "    neu = neu + zeichen + zeichen\n",
    "print(neu)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aus `\"\"` wird `\"BB\"`, dann `\"BBii\"` und schließlich `\"BBiitt\"`.\n",
    "\n",
    "### Schleife über die Indizes\n",
    "Brauchst du auch die **Position**, lässt du die Schleife über alle Indizes laufen. `range(len(text))` liefert genau die gültigen Indizes 0, 1, …, `len(text) - 1`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "text = \"Bit\"\n",
    "for i in range(len(text)):\n",
    "    print(i, text[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> 📌 **Merksatz:** `for zeichen in text:` durchläuft nacheinander alle **Zeichen**. `for i in range(len(text)):` durchläuft alle **Indizes**, das Zeichen dazu ist `text[i]`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4 Zeichen prüfen und umwandeln\n",
    "\n",
    "### Ist ein Zeichen enthalten?\n",
    "Mit `in` prüfst du, ob ein Zeichen oder ein Textstück vorkommt. Das Ergebnis ist `True` oder `False`. Besonders praktisch ist `in` mit einer Zeichenkette aller „erlaubten“ Zeichen, etwa `\"aeiou\"` für die Vokale."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"a\" in \"Banane\")\n",
    "print(\"x\" in \"Banane\")\n",
    "print(\"nan\" in \"Banane\")\n",
    "print(\"B\" in \"banane\")\n",
    "\n",
    "buchstabe = \"e\"\n",
    "if buchstabe in \"aeiou\":\n",
    "    print(buchstabe, \"ist ein Vokal.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Groß- und Kleinschreibung\n",
    "Für Python sind `\"Ja\"`, `\"ja\"` und `\"JA\"` drei verschiedene Zeichenketten. Ist die Schreibweise egal, wandelt man alles in Klein- oder Großbuchstaben um."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "text = \"Hallo Welt\"\n",
    "print(text.upper())\n",
    "print(text.lower())\n",
    "print(text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`text` selbst bleibt **unverändert**: `.upper()` und `.lower()` erzeugen eine neue Zeichenkette. Neu ist die Schreibweise mit dem Punkt **hinter** dem Text. Solche Funktionen heißen **Methoden**.\n",
    "\n",
    "> 📌 **Definition Methode:** Eine **Methode** ist eine Funktion, die zu einem Wert gehört. Man ruft sie mit einem Punkt hinter dem Wert auf: `text.upper()`. Die Klammern dürfen leer sein, aber nicht fehlen.\n",
    "\n",
    "### ⚠️ Stolperstein: `text.lower()` allein ändert nichts\n",
    "**🔮 Vorhersage:** Was gibt die Zelle aus? Wie musst du Zeile 2 ändern, damit `hallo` herauskommt?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "text = \"Hallo\"\n",
    "text.lower()\n",
    "print(text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Buchstabe oder Ziffer?\n",
    "- `text.isalpha()` ist `True`, wenn **alle** Zeichen Buchstaben sind (auch Umlaute und ß),\n",
    "- `text.isdigit()` ist `True`, wenn **alle** Zeichen Ziffern sind."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Hallo\".isalpha())\n",
    "print(\"Hallo Welt\".isalpha())\n",
    "print(\"2026\".isdigit())\n",
    "print(\"-5\".isdigit())\n",
    "print(\"3.5\".isdigit())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`\"Hallo Welt\"` enthält ein Leerzeichen, und das ist kein Buchstabe. Bei `\"-5\"` und `\"3.5\"` sind Minuszeichen und Punkt keine Ziffern. Mit `.isdigit()` kann ein Programm eine Eingabe prüfen, bevor es sie mit `int(...)` umwandelt, und so den `ValueError` vermeiden.\n",
    "\n",
    "> 📌 **Merksatz:** `x in text` prüft, ob `x` enthalten ist. `.upper()` und `.lower()` liefern eine **neue** Zeichenkette, darum `text = text.lower()`. `.isalpha()` und `.isdigit()` prüfen auf Buchstaben bzw. Ziffern."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 📝 Übungen: Schritt für Schritt selbstständig\n",
    "Die Übungen werden schrittweise schwieriger. Vorgemacht hast du schon zwei Muster gesehen: **Zeichen zählen** (`\"Anna\"`) und **einen neuen Text aufbauen** (`\"BBiitt\"`). Bei Übung 2 füllst du Lücken `___` aus, bei Übung 3 steht nur noch das Gerüst als Kommentar, bei Übung 4 nur die Kopfzeile und die Tests, die Zusatzaufgabe schreibst du allein.\n",
    "\n",
    "## 📝 Übung 2 – Zeichen-Steckbrief (Lücken füllen)\n",
    "Schreibe ein Programm, das ein Wort einliest und ausgibt: die Länge, das erste und das letzte Zeichen und das Wort rückwärts. So könnte es aussehen:\n",
    "\n",
    "```\n",
    "Wort eingeben: Python\n",
    "Länge: 6\n",
    "Erstes Zeichen: P\n",
    "Letztes Zeichen: n\n",
    "Rückwärts: nohtyP\n",
    "```\n",
    "\n",
    "> 💡 **Tipp:** Für das Rückwärts-Wort baust du in einer Schleife einen neuen Text auf wie bei `\"BBiitt\"`. Der Trick: Hänge jedes Zeichen **vorne** an, also `zeichen + rueckwaerts` statt `rueckwaerts + zeichen`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "wort = input(\"Wort eingeben: \")\n",
    "print(\"Länge:\", ___)\n",
    "print(\"Erstes Zeichen:\", wort[___])\n",
    "print(\"Letztes Zeichen:\", wort[___])\n",
    "\n",
    "rueckwaerts = \"\"\n",
    "for zeichen in wort:\n",
    "    rueckwaerts = ___\n",
    "print(\"Rückwärts:\", rueckwaerts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 📝 Übung 3 – Vokale zählen (mit Gerüst)\n",
    "Schreibe ein Programm, das einen Satz einliest und mit einer Schleife zählt, wie viele Vokale (a, e, i, o, u) darin vorkommen. Auch großgeschriebene Vokale sollen mitgezählt werden. Kontrolle: „Informatik macht Spaß“ hat 6 Vokale.\n",
    "\n",
    "> 💡 **Tipp:** Kombiniere die Schleife über alle Zeichen, die Zählvariable aus dem Beispiel `\"Anna\"` und die Prüfung `zeichen in \"aeiou\"`. Gegen das Problem mit den Großbuchstaben hilft `.lower()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "satz = input(\"Satz eingeben: \")\n",
    "# Zählvariable auf 0 setzen\n",
    "# für jedes Zeichen im Satz (in Kleinbuchstaben):\n",
    "#     wenn das Zeichen in \"aeiou\" vorkommt:\n",
    "#         Zählvariable um 1 erhöhen\n",
    "# nach der Schleife: Anzahl ausgeben"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 📝 Übung 4 – Passwort prüfen (Kopfzeile und Tests vorgegeben)\n",
    "Ein Passwort gilt hier als sicher, wenn es **mindestens 8 Zeichen** lang ist und **mindestens eine Ziffer** enthält. Schreibe eine Funktion `ist_sicher(passwort)`, die `True` oder `False` zurückgibt. Kopfzeile und Testaufrufe stehen schon da.\n",
    "\n",
    "> 💡 **Tipp:** Zähle die Ziffern wie die Vokale in Übung 3, prüfe aber mit `zeichen.isdigit()`. Verknüpfe am Ende beide Bedingungen mit `and`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ist_sicher(passwort):\n",
    "    pass   # hier deine Programmzeilen\n",
    "\n",
    "print(ist_sicher(\"abc1\"), \"erwartet: False\")          # zu kurz\n",
    "print(ist_sicher(\"sommerferien\"), \"erwartet: False\")  # keine Ziffer\n",
    "print(ist_sicher(\"sommer2026\"), \"erwartet: True\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 🚀 Zusatzaufgabe – Palindrom (selbstständig)\n",
    "Ein **Palindrom** ist ein Wort, das vorwärts und rückwärts gelesen gleich ist, z. B. „Anna“ oder „Rentner“. Schreibe eine Funktion `ist_palindrom(wort)`, die `True` oder `False` zurückgibt. Groß- und Kleinschreibung soll keine Rolle spielen. Teste mit „Anna“, „Rentner“ und „Informatik“."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Zusatzaufgabe – ist_palindrom(wort)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ➕ Zusatzwissen: Ausschnitte (Slicing)\n",
    "Für die Aufgaben brauchst du das nicht. Mit `text[start:ende]` schneidest du einen **Ausschnitt** heraus. Das Zeichen am Index `start` gehört dazu, das am Index `ende` **nicht** mehr. `text[::-1]` durchläuft den Text rückwärts."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "text = \"Informatik\"\n",
    "print(text[0:4])\n",
    "print(text[2:6])\n",
    "print(text[::-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 📌 Das Wichtigste in Kürze\n",
    "- Eine **Zeichenkette** ist eine **Sequenz von Zeichen**. Jedes Zeichen hat einen **Index**, gezählt ab 0.\n",
    "- `text[i]` liefert das Zeichen am Index `i`; `text[-1]` ist das letzte Zeichen.\n",
    "- `len(text)` liefert die Länge. Gültige Indizes reichen von 0 bis `len(text) - 1`, sonst gibt es einen **IndexError**.\n",
    "- Mit `+` verkettet man Zeichenketten. Ein **f-String** `f\"... {wert} ...\"` setzt Werte bequem in einen Text ein.\n",
    "- `for zeichen in text:` durchläuft alle Zeichen, `for i in range(len(text)):` alle Indizes.\n",
    "- `x in text` prüft, ob `x` enthalten ist. `.upper()` und `.lower()` liefern eine neue Zeichenkette; `.isalpha()` und `.isdigit()` prüfen auf Buchstaben bzw. Ziffern.\n",
    "\n",
    "Zum Weiterüben: `DS10_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
}