Move strings to own notebook and add more details.

03kapitel/033 Tupel.ipynb

@@ -268,6 +268,106 @@
     "for index, zahl in enumerate(liste):\n",
     "    print(f\"{index+1}. Zahl ist {zahl}\")"
    ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Ein weiterer Anwendungsfall, der häufig auftritt, ist das Zusammenfassen mehrerer Listen zu einer, sodass jedes Element einer Position aus allen Listen in eine Tupel an entsprechender Stelle der neuen Liste gesetzt wird. Es sollen also alle ersten Elemente aller Listen in Form eines Tupels als erstes Element der neuen Liste gesetzt werden, dann alle zweiten Elemente als Tupel als zweites Element der neuen Liste, usw..\n",
+    "\n",
+    "**Beispiel:** Die Listen `[0, 1, 2]`, `['A', 'B', 'C']` und `['X', 'Y', 'Z']` sollen in einer neuen Liste folgendermaßen zusammengefasst werden: `[(0, 'A', 'X'), (1, 'B', 'Y'), (2, 'C', 'Z')]`\n",
+    "\n",
+    "Dies lässt sich sehr einfach mit der Built-In-Funktion `zip` realisieren, die beliebig viele Listen als Argumente übergeben bekommt und ein Zip-Objekt zurückgibt, das sich in eine Liste umwandeln lässt, die die jeweiligen Elemente als Tupel enthält, so wie oben gewünscht."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "liste1 = [0, 1, 2]\n",
+    "liste2 = ['A', 'B', 'C']\n",
+    "liste3 = ['X', 'Y', 'Z']\n",
+    "\n",
+    "neue_liste = list(zip(liste1, liste2, liste3))\n",
+    "\n",
+    "print(neue_liste)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "`zip` wird am häufigsten genutzt, um mehrere Listen parallel zu durchlaufen."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "liste1 = [0, 1, 2]\n",
+    "liste2 = ['A', 'B', 'C']\n",
+    "liste3 = ['X', 'Y', 'Z']\n",
+    "\n",
+    "for elem_aus_liste1, elem_aus_liste2, elem_aus_liste3 in zip(liste1, liste2, liste3):\n",
+    "    print(f'Die Listen enthalten folgende Elemente: Liste 1: {elem_aus_liste1}, Liste 2: {elem_aus_liste2}, Liste 3: {elem_aus_liste3}')"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Möglich wird dies, weil man in Python die einzelnen Elemente eines Tupels direkt an einzelne Variablen zuweisen kann."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "mein_tupel = (1, 2, 3)\n",
+    "elem1, elem2, elem3 = mein_tupel\n",
+    "print(elem1)\n",
+    "print(elem2)\n",
+    "print(elem3)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Genauso wird in der obigen `for`-Schleifen mit `zip` pro Position der entsprechende Tupel entnommen und an die Schleifenvariablen der `for`-Schleife aufgeteilt. Die beiden untenstehenden Vorgehensweisen sind also gleich, wenn die zweite auch die schnellere und gebräuchlichere ist."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "liste1 = [0, 1, 2]\n",
+    "liste2 = ['A', 'B', 'C']\n",
+    "liste3 = ['X', 'Y', 'Z']\n",
+    "\n",
+    "print('1. Vorgehensweise mit explizitem Zwischenspeichern und Auspacken des Tupels:')\n",
+    "for tupel_elem in zip(liste1, liste2, liste3):\n",
+    "    elem_aus_liste1, elem_aus_liste2, elem_aus_liste3 = tupel_elem\n",
+    "    print(f'Die Listen enthalten folgende Elemente: Liste 1: {elem_aus_liste1}, Liste 2: {elem_aus_liste2}, Liste 3: {elem_aus_liste3}')\n",
+    "\n",
+    "\n",
+    "\n",
+    "print('\\n2. Vorgehensweise mit direktem Auspacken des Tupels ohne Zwischenspeichern (gebräuchlichere Variante)')\n",
+    "for elem_aus_liste1, elem_aus_liste2, elem_aus_liste3 in zip(liste1, liste2, liste3):\n",
+    "    print(f'Die Listen enthalten folgende Elemente: Liste 1: {elem_aus_liste1}, Liste 2: {elem_aus_liste2}, Liste 3: {elem_aus_liste3}')"
+   ]
   }
  ],
  "metadata": {

03kapitel/034 Comprehensions.ipynb

@@ -89,102 +89,6 @@
     "print(neue_liste)"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "slideshow": {
-     "slide_type": "slide"
-    }
-   },
-   "source": [
-    "### 3.8 Listen und Strings\n",
-    "\n",
-    "Gelegentlich möchte man einen String in einzelne Wörter zerlegen und diese als\n",
-    "Liste zurückgeliefert bekommen. Hierzu dient die Operation <code>split</code>, die \n",
-    "in Dot-Notation im Datentyp String enthalten ist."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "pycharm": {
-     "is_executing": false,
-     "name": "#%%\n"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "text =\"Software Entwicklung macht Spaß\"\n",
-    "liste = text.split()\n",
-    "print(liste)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "slideshow": {
-     "slide_type": "slide"
-    }
-   },
-   "source": [
-    "Normalerweise verwendet <code>split</code> ein *Whitespace*-Zeichen (d.h. Leerzeichen, Tabulator, neue Zeile,...)\n",
-    "als Trennzeichen für die Zerlegung. Es kann jedoch auch eine andere Zeichenkette festgelegt werden. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "pycharm": {
-     "is_executing": false,
-     "name": "#%%\n"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "text = \"der, die, das, wieso, weshalb, warum\"\n",
-    "liste = text.split(\", \")\n",
-    "print(liste)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Hinweis: Mehrere unterschiedliche Trennzeichen sind mit der Standard-<code>split</code>-Funktion nicht realisierbar. \n",
-    "Dazu benötigt man *reguläre Ausdrücke*, die zu einem späteren Zeitpunkt eingeführt werden."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "slideshow": {
-     "slide_type": "slide"
-    }
-   },
-   "source": [
-    "Soll umgekehrt aus einer Liste von einzelnen Wörtern ein String zusammengesetzt werden, kann die \n",
-    "Funktion <code>join</code> genutzt werden. Sie wird in der Dot-Notation mit einem String verwendet,\n",
-    "der die einzufügenden Trennzeichen enthält."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "pycharm": {
-     "is_executing": false,
-     "name": "#%%\n"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "liste = [\"das\", \"ist\", \"das\", \"Haus\", \"vom\", \"Nikolaus\"]\n",
-    "text = \"\".join(liste)\n",
-    "print(text)"
-   ]
-  },
   {
    "cell_type": "markdown",
    "metadata": {

03kapitel/035 Strings.ipynb

@@ -0,0 +1,251 @@
+{
+ "cells": [
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "# Software Entwicklung \n",
+    "\n",
+    "## Kapitel 3: Listen und Tupel\n",
+    "\n",
+    "### 3.8 Strings\n",
+    "\n",
+    "Zeichenketten bzw. Strings sind in Python nichts anderes als spezielle Listen, deren Elemente Zeichen sind. Man kann also quasi alles mit Strings anstellen, das man mit Listen auch anstellen kann. So kann man durch eine Zeichenkette Zeichen für Zeichen iterieren. Werte werden als Zeichenketten deklariert, indem man eine Zeichenkette in einfache oder doppelte Anführungszeichen stellt."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "is_executing": false,
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "zeichenkette = 'Dies ist eine Zeichenkette.'\n",
+    "\n",
+    "for zeichen in zeichenkette:\n",
+    "    print(zeichen)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "Eine Zeichenkette lässt sich sehr leicht umdrehen, genau wie eine Liste."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "is_executing": false,
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "zeichenkette = 'Dies ist eine Zeichenkette.'\n",
+    "print(zeichenkette[::-1])"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "Auch lassen sich Zeichen an bestimmten Positionen extrahieren bzw. Teilstrings mittels Slicing wie bei Listen extrahieren."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "is_executing": false,
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "zeichenkette = 'Dies ist eine Zeichenkette.'\n",
+    "print(zeichenkette[5])\n",
+    "print(zeichenkette[5:-2])"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "Gelegentlich möchte man einen String in einzelne Wörter zerlegen und diese als\n",
+    "Liste zurückgeliefert bekommen. Hierzu dient die Operation <code>split</code>, die \n",
+    "in Dot-Notation im Datentyp String enthalten ist."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "is_executing": false,
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "text =\"Software Entwicklung macht Spaß\"\n",
+    "liste = text.split()\n",
+    "print(liste)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "Normalerweise verwendet <code>split</code> ein *Whitespace*-Zeichen (d.h. Leerzeichen, Tabulator, neue Zeile,...)\n",
+    "als Trennzeichen für die Zerlegung. Es kann jedoch auch eine andere Zeichenkette festgelegt werden. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "is_executing": false,
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "text = \"der, die, das, wieso, weshalb, warum\"\n",
+    "liste = text.split(\", \")\n",
+    "print(liste)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Hinweis: Mehrere unterschiedliche Trennzeichen sind mit der Standard-<code>split</code>-Funktion nicht realisierbar. \n",
+    "Dazu benötigt man *reguläre Ausdrücke*, die zu einem späteren Zeitpunkt eingeführt werden."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "slideshow": {
+     "slide_type": "slide"
+    }
+   },
+   "source": [
+    "Soll umgekehrt aus einer Liste von einzelnen Wörtern ein String zusammengesetzt werden, kann die \n",
+    "Funktion <code>join</code> genutzt werden. Sie wird in der Dot-Notation mit einem String verwendet,\n",
+    "der die einzufügenden Trennzeichen enthält."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "is_executing": false,
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "liste = [\"das\", \"ist\", \"das\", \"Haus\", \"vom\", \"Nikolaus\"]\n",
+    "text = \" \".join(liste)\n",
+    "print(text)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Zudem bieten Strings viele weitere, hilfreiche Funktionen an, die deren Verarbeitung enorm erleichtern. Hier folgt ein kleiner Auszug."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "zeichenkette = \"das ist das Haus vom Nikolaus.\"\n",
+    "\n",
+    "print(f'Beginnt die Zeichenkette mit dem Teilstring \\'das ist\\'? {zeichenkette.startswith(\"das ist\")}')\n",
+    "print(f'Endet die Zeichenkette auf dem Teilstring \\'aus.\\'? {zeichenkette.endswith(\"aus.\")}')\n",
+    "print(f'Setze den ersten Buchstaben groß und alle anderen klein: {zeichenkette.capitalize()}')\n",
+    "print(f'Klein geschriebene Zeichenkette: {zeichenkette.lower()}')\n",
+    "print(f'Groß geschriebene Zeichenkette: {zeichenkette.upper()}')\n",
+    "\n",
+    "zeichenkette_mit_whitespaces = '      Ich bin eine Zeichenkette.\\n'\n",
+    "print(f'Zeichenkette mit Whitespaces am Anfang und Ende: {zeichenkette_mit_whitespaces} Wenn ein \\\\n am Ende der Zeichenkette steht, steht dieser Satz in einer neuen Zeile.')\n",
+    "print(f'Entferne Whitespaces vom Anfang und Ende: {zeichenkette_mit_whitespaces.strip()} Wenn ein \\\\n am Ende der Zeichenkette steht, steht dieser Satz in einer neuen Zeile.')\n",
+    "\n",
+    "zahl_als_string = '123'\n",
+    "print(f'Könnte man die Zahl zu einer Dezimalzahl konvertieren? {zahl_als_string.isdecimal()}')\n",
+    "print(int(zahl_als_string))"
+   ]
+  }
+ ],
+ "metadata": {
+  "celltoolbar": "Slideshow",
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.9"
+  },
+  "pycharm": {
+   "stem_cell": {
+    "cell_type": "raw",
+    "metadata": {
+     "collapsed": false
+    },
+    "source": []
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}