diff --git a/notebooks/seminar03extra.ipynb b/notebooks/seminar03extra.ipynb
index 91029266945dadaa32f83231594bb7dc4982e138..4f31ba5e55ce4712b9c3cbbeda38e16328e1376a 100644
--- a/notebooks/seminar03extra.ipynb
+++ b/notebooks/seminar03extra.ipynb
@@ -70,10 +70,10 @@
    "source": [
     "\n",
     "1. In der ersten Zeile wird das `re`-Modul importiert. Das muss einmal am Anfang unseres Programms passieren. Hier im Jupyter-Notebook reicht es, wenn das Modul in einem Block importiert wird - sobald der Block ausgeführt wurde, kann es in allen folgenden Blöcken verwendet werden.\n",
-    "2. In der nächsten Zeile wird -mittels der Punkt-Notation- die `findall`-Funktion im `re`-Modul aufgerufen.\n",
+    "2. In der nächsten Zeile wird - mittels der Punkt-Notation - die `findall`-Funktion im `re`-Modul aufgerufen.\n",
     "3. Der Funktion werden zwei Argumente übergeben: `r'f[a-z]*'` und `'which foot or hand fell fastest'`.\n",
     "4. Das erste Argument ist ein regulärer Ausdruck. Reguläre Ausdrücke werden in Hochkommata `''` eingeschlossen und beginnen mit einem `r`. \n",
-    "5. Das heißt der eigentliche reguläre Ausdruck lautet `f[a-z]*`. Dieser Ausdruck beschreibt Zeichenketten, die mit einem `f` beginnen und von beliebig vielen - auch 0! - (`*`) Kleinbuchstaben (`[a-z]`) gefolgt werden. Dabei beschreibt der Ausdruck `[a-z]` in eckigen Klammern ein Zeichen, welches die Werte `a` bis `z` haben darf, das `*` dahinter besagt, dass dieses Zeichen beliebig oft wiederholt werden darf.\n",
+    "5. Das heißt, der eigentliche reguläre Ausdruck lautet `f[a-z]*`. Dieser Ausdruck beschreibt Zeichenketten, die mit einem `f` beginnen und von beliebig vielen - auch 0! - (`*`) Kleinbuchstaben (`[a-z]`) gefolgt werden. Dabei beschreibt der Ausdruck `[a-z]` in eckigen Klammern ein Zeichen, welches die Werte `a` bis `z` haben darf, das `*` dahinter besagt, dass dieses Zeichen beliebig oft wiederholt werden darf.\n",
     "6. Das zweite Argument (`'which foot or hand fell fastest'`) ist die Zeichenkette, in der wir nach Teilzeichenketten suchen, die auf den übergebenen regulären Ausdruck passen.\n",
     "\n",
     "Das Ergebnis des Aufrufs von `findall` ist eine Liste der Teilzeichenketten, die auf das Muster passen - in unserem Beispiel sind das die Zeichenketten `foot`, `fell` und `fastest`. \n",
@@ -166,6 +166,234 @@
     "Es gibt noch viele andere gute Tutorials zu regulären Ausdrücken, z.B. [hier](https://ryanstutorials.net/regular-expressions-tutorial/) oder [hier](https://www.python-kurs.eu/re.php). Sie können auch eine dieser Anleitungen durcharbeiten, wenn Sie damit besser zurechtkommen."
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 3.4 weitere nützliche Funktionen des `re`-Moduls\n",
+    "\n",
+    "Sie haben in den Tutorials einige regulären Ausdrücke kennengelernt. Nun können wir weitere Funktionen des `re`-Moduls benutzen. Im Folgenden werden mehrere Funktionen vorgestellt. Anschließend können Sie diese in Übungen testen.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 3.4.1 Suchen und Matchen \n",
+    "\n",
+    "Die Funktion `findall(regex,string)` haben sie schon kennengelernt:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import re\n",
+    "re.findall(r'f[a-z]*', 'which foot or hand fell fastest')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Zudem gibt es eine Funktion  `search(regex,string)`. Die Argumente sind diesselben wie bei `findall`.\n",
+    "Diese Funktion durchsucht eine Zeichenkette *string* nach dem Vorkommen eines Teilstrings, der auf den regulären Ausdruck *regex* passt. Der erste gefundene Teilstring wird zurückgeliefert. Die Rückgabe ist ein sogennantes *match-Objekt*."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import re\n",
+    "object1 = re.search(r'f[a-z]*', 'which foot or hand fell fastest')\n",
+    "\n",
+    "object2 = re.search(r'f[a-z]*', 'The regex did not match anything.')\n",
+    "\n",
+    "print(object1,\"\\n\",object2)\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Ein *match-Objekt* enthält die Methoden `group()`, `span()`, `start()` und `end()`, die man im folgenden Beispiel im selbsterklärenden Einsatz sieht: "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "object1 = re.search(r'f[a-z]*', 'which foot or hand fell fastest')\n",
+    "print(object1.group())\n",
+    "print(object1.span())\n",
+    "print(object1.start())\n",
+    "print(object1.end())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Es gibt zuletzt noch eine dritte Funktion `match(regex,string)`. Diese Funktion checkt, ob ein Teilstring, der auf den regulären Ausdruck *regex* passt, am Anfang der Zeichenkette *string* vorkommt, Die Rückgabe ist wieder ein *match-Objekt*."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "object1 = re.match(r'f[a-z]*', 'foot or hand fell fastest')\n",
+    "object2 = re.match(r'f[a-z]*', 'which foot or hand fell fastest')\n",
+    "print(object2)\n",
+    "print(object1)\n",
+    "print(object1.group())\n",
+    "print(object1.span())\n",
+    "print(object1.start())\n",
+    "print(object1.end())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 3.4.1 Ãœbung:\n",
+    "\n",
+    "Denken Sie sich eine Zeichenkette und einen regulären Ausdruck aus, die die Unterschiede der drei kennengelernten Funktionen wiedergibt. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 3.4.2 Ersetzen  "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Das `re`-Modul stellt nicht nur Funktionen zum Durchsuchen von Zeichenketten zur Verfügung. Mit der Funktion `re.sub(regex, replacement, string)` kann man Teilstrings ersetzen. Jede Übereinstimmung des regulären Ausdrucks *regex* in der Zeichenkette *string* wird durch die Zeichenkette *replacement* ersetzt."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "re.sub(r'f[a-z]*', 'beer', 'which foot or hand fell fastest')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 3.4.3 Kompilieren\n",
+    "\n",
+    "Wenn man bestimmte reguläre Ausdrücke mehrmals benutzen möchte, kann man die Funktion `compile(regex)` benutzen. Diese Funktion kompiliert einen regulären Ausdruck *regex* in eine regex-Objekt. Dieses kann man dann für weitere Funktionen nutzen."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "regex_1 = re.compile(r'f[a-z]*')\n",
+    "\n",
+    "print(regex_1.findall('which foot or hand fell fastest'))\n",
+    "\n",
+    "print(regex_1.search('which foot or hand fell fastest'))\n",
+    "\n",
+    "print(regex_1.match('which foot or hand fell fastest'))\n",
+    "\n",
+    "print(regex_1.sub('beer','which foot or hand fell fastest'))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Aufgaben\n",
+    "\n",
+    "#### Aufgabe 1\n",
+    "Schreiben Sie eine Funktion, die eine Zeichenkette als Parameter entgegennimmt und überprüft, ob die Zeichenkette nur Kleinbuchstaben und Zahlen enthält. \n",
+    "Benutzen Sie reguläre Ausdrücke und die obigen Funktionen."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Aufgabe 2\n",
+    "\n",
+    "Schreiben Sie eine Funktion, die eine Zeichenkette als Parameter entgegennimmt und überprüft, ob die Zeichenkette einen Teilstring enthält, der aus einem \"a\" und nachfolgend aus mindestens einem \"b\" besteht. (z.B. \"abb\", \"abbbbb\", \"abbbbbbbbbbbbbbbb\"). \n",
+    "Benutzen Sie reguläre Ausdrücke und die obigen Funktionen.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Aufgabe 3\n",
+    "\n",
+    "Schreiben Sie eine Funktion, die eine Zeichenkette als Parameter entgegennimmt und alle darin enthaltenen Leerzeichen durch ein Minus ersetzt. \n",
+    "Benutzen Sie reguläre Ausdrücke und die obigen Funktionen."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Aufgabe 4\n",
+    "\n",
+    "Schreiben Sie eine Funktion, die eine Zeichenkette *s* und eine natürliche Zahl  *n* als Parameter entgegennimmt und alle Wörter der Länge n aus der Zeichenkette *s* entfernt. \n",
+    "Benutzen Sie reguläre Ausdrücke und die obigen Funktionen."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
diff --git a/notebooks/seminar08.ipynb b/notebooks/seminar08.ipynb
index 131dd48fec0c275374553b363251ea380b11987f..b8eb120182de361283b2cccb0b8ba30068735a7a 100644
--- a/notebooks/seminar08.ipynb
+++ b/notebooks/seminar08.ipynb
@@ -1294,12 +1294,16 @@
     "def rotate_letter (s,n):\n",
     "    if s.isupper():\n",
     "        start= ord('A')\n",
+    "        print(start)\n",
     "    elif s.islower():\n",
     "        start=ord('a')\n",
+    "        print(start)\n",
     "    else:\n",
     "        return s\n",
     "    letter=ord(s)-start\n",
+    "    print(letter)\n",
     "    new=(letter+n)%26+start\n",
+    "    print(new)\n",
     "    return chr(new)\n",
     "\n",
     "\n",
@@ -1309,7 +1313,7 @@
     "        neu=neu+rotate_letter(letter,n)\n",
     "    return neu\n",
     "        \n",
-    "rotate_word(\"cheer\",7)"
+    "rotate_word(\"ab\",7)"
    ]
   },
   {