diff --git a/notebooks/seminar08.ipynb b/notebooks/seminar08.ipynb
index 5fd6ce520942c9a02987f7122d7ad39010a0e368..f69fdb4acbf795229a49e2e4887a094d72e189a3 100644
--- a/notebooks/seminar08.ipynb
+++ b/notebooks/seminar08.ipynb
@@ -19,7 +19,31 @@
"metadata": {},
"outputs": [],
"source": [
- "pass"
+ "# klappt nur, wenn das Python-Modul BeautifulSoup installiert ist\n",
+ "from collections import Counter\n",
+ "import requests\n",
+ "from bs4 import BeautifulSoup\n",
+ "\n",
+ "# wir wollen häufige n-Gramme finden - hier n anpassen \n",
+ "n = 6\n",
+ "\n",
+ "# sollte für jede beliebige Webseite funktionieren - hier anpassen\n",
+ "link = \"https://de.wikipedia.org/w/index.php?title=Berlin&printable=yes\"\n",
+ "\n",
+ "# Webseite herunterladen und Text extrahieren\n",
+ "text = BeautifulSoup(requests.get(link).text, \"lxml\").get_text()\n",
+ "\n",
+ "# n-Gramme zählen\n",
+ "ctr = Counter()\n",
+ "for i in range(0, len(text) - n + 1):\n",
+ " ngram = text[i:i+n]\n",
+ " # Zeichenketten mit Leerzeichen ignorieren\n",
+ " if ' ' not in ngram:\n",
+ " ctr[ngram] += 1\n",
+ "\n",
+ "# die Top-10 ausgeben\n",
+ "for ngram, frequ in ctr.most_common(10):\n",
+ " print(frequ, ngram, sep='\\t')"
]
},
{
@@ -180,7 +204,7 @@
]
},
{
- "cell_type": "raw",
+ "cell_type": "markdown",
"metadata": {},
"source": [
"Alternativ können wir einen negativen Index nutzen, der rückwärts vom Ende der Zeichenkette her zählt. Der Ausdruck `fruit[-1]` ergibt das letzte Zeichen, `fruit[-2]` das vorletzte Zeichen, usw.:"
@@ -409,7 +433,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "Das \"object\" in diesem Beispiel ist die Zeichenkette und das \"item\" das Zeichen, welches wir zuweisen wollten. Momentan können wir uns unter einem Objekt das gleiche wie einen Wert vorstellen, aber wir werden später (in [Abschnitt 10.10](seminar10.ipynb#Objekte-und-Werte)) genauer kennenlernen, was Objekte sind.\n",
+ "Das Objekt (\"object\") in diesem Beispiel ist die Zeichenkette und das Element (\"item\") das Zeichen, welches wir zuweisen wollten. Momentan können wir uns unter einem Objekt das gleiche wie einen Wert vorstellen, aber wir werden später (in [Abschnitt 10.10](seminar10.ipynb#Objekte-und-Werte)) genauer kennenlernen, was Objekte sind.\n",
"\n",
"Der Grund für den Fehler ist, dass Zeichenketten **unveränderbar** (*immutable*) sind. Das heisst, wie können eine existierende Zeichenkette nicht verändern. Das beste, was wir machen können, ist eine neue Zeichenkette zu erzeugen, die eine Variante des Originals ist:"
]
@@ -528,12 +552,523 @@
"Schreiben Sie die Funktion jetzt so um, dass sie die Version von `find` mit den drei Parametern aus dem vorherigen Abschnitt verwendet. "
]
},
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### 8.8 Methoden für Zeichenketten\n",
+ "\n",
+ "Für Zeichenketten stellt Python eine Menge nützlicher Methoden bereit. Eine Methode ist ähnlich wie eine Funktion - sie erwartet Argumente und gibt Werte zurück - aber die Syntax ist anders. Beispielsweise erwartet die Funktion `upper` eine Zeichenkette und gibt eine neue Zeichenkette zurück, in der alle Buchstaben GROSS geschrieben sind.\n",
+ "\n",
+ "Anstatt der Funktions-Syntax `upper(word)` nutzt die Methode jedoch die Syntax `word.upper()`:\n"
+ ]
+ },
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
- "source": []
+ "source": [
+ "word = 'banana'\n",
+ "new_word = word.upper()\n",
+ "new_word"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "In dieser Form der Punkt-Notation wird der Name der Methode - `upper` - und der Name der Zeichenkette, auf die die Funktion angewendet werden soll - `word` - angegeben. Die leeren Klammern zeigen, dass diese Methode keine Argumente erwartet.\n",
+ "\n",
+ "Dies wird **Aufruf** (*invocation*) der Methode genannt. In diesem Beispiel würden wir sagen, dass wir `upper` auf `word` aufrufen. \n",
+ "\n",
+ "Wie sich herausstellt, gibt es eine Zeichenketten-Methode namens `find`, die sehr ähnlich zu der Funktion ist, die wir geschrieben haben:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "word = 'banana'\n",
+ "index = word.find('a')\n",
+ "index"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "In diesem Beispiel rufen wir `find` auf `word` auf und reichen den Buchstaben, den wir suchen, als Argument an `find` weiter.\n",
+ "\n",
+ "Tatsächlich ist die `find`-Methode allgemeiner als unsere Funktion, denn sie kann auch Teilzeichenketten finden, nicht nur einzelne Zeichen:\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "word.find('na')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Standardmäßig beginnt `find` mit der Suche am Anfang der Zeichenkette, aber wir können ein zweites Argument übergeben, welches den Index angibt, an dem die Suche starten soll:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "word.find('na', 3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Das ist ein Beispiel für ein **optionales Argument**. `find` kann auch ein drittes Argument übergeben werde, der Index, bis zu dem es höchstens suchen darf:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "name = 'bob'\n",
+ "name.find('b', 1, 2)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "In diesem Beispiel schlägt die Suche fehl, denn im Index-Bereich von 1 bis 2 (ohne 2) gibt es kein `b`. Dadurch, dass `find` bis zum zweiten zweiten Index sucht, das Zeichen an dessen Stelle aber nicht mit einschliesst, arbeitet es konsistent zum Segment-Operator."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### 8.9 Der `in`-Operator\n",
+ "\n",
+ "Das Wort `in` ist ein Boolescher Operator, der zwei Zeichenketten erwartet und `True` zurückgibt, wenn die erste Zeichenkette eine Zeilzeichenkette der zweiten ist:\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "'a' in 'banana'"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "'seed' in 'banana'"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Beispielsweise gibt die folgende Funktion alle Buchstaben von `word1` aus, die auch in `word2` enthalten sind:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def in_both(word1, word2):\n",
+ " for letter in word1:\n",
+ " if letter in word2:\n",
+ " print(letter)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Mit gut gewählten Variablennamen, liest sich Python-Code manchmal wie englischer Text. Wir könnten diese Schleife lesen als *\"for (each) letter in (the first) word, if (the) letter (appears) in (the second) word, print (the) letter.\"*\n",
+ "\n",
+ "Hier ist das was passiert, wenn wir Äpfel mit Birnen vergleichen"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "in_both(\"Apfel\", \"Birne\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### 8.10 Zeichenketten vergleichen\n",
+ "\n",
+ "Die Vergleichs-Operatoren funktionieren auch mit Zeichenketten. Um zu prüfen, ob zwei Zeichenketten gleich sind, können wir einfach folgendes machen:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "if word == 'banana':\n",
+ " print(\"All right, bananas.\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Andere Vergleichsoperatoren sind nützlich, um Wörter alphabetisch zu ordnen:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "if word < 'banana':\n",
+ " print('Your word, ' + word + ', comes before banana.')\n",
+ "elif word > 'banana':\n",
+ " print('Your word, ' + word + ', comes after banana.')\n",
+ "else:\n",
+ " print('All right, bananas.')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Passen Sie den Wert von `word` an, so dass der obige Code die drei verschiedenen Texte ausgibt.\n",
+ "\n",
+ "Python behandelt Groß- und Kleinbuchstaben anders, als wir Menschen es tun würden. Alle Großbuchstaben kommen vor allem Kleinbuchstaben, so dass \n",
+ "\n",
+ "`Your word, Pineapple, comes before banana.` \n",
+ "\n",
+ "gilt. Eine Möglichkeit, dieses Problem zu umgehen, besteht darin, Zeichenketten in ein Standard-Format umzuwandeln - beispielsweise alles in Kleinbuchstaben - und sie erst dann zu vergleichen. \n",
+ "\n",
+ "Im Deutschen kommt noch hinzu, dass die Umlaute nicht richtig einsortiert werden. Eigentlich würden wir z.B. erwarten, dass `ä` vor `b` einsortiert wird, aber das ist nicht der Fall: "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "'älter' < 'bald'"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Darauf müssen wir bei Vergleichen achten. (Es gibt die Möglichkeit, durch Verwendung des `locale`-Pakets die Sortierung, z.B. von Listen, zu korrigieren.) "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### 8.11 Debugging\n",
+ "\n",
+ "Wenn wir Indexe nutzen, um die Werte einer Folge zu durchlaufen, ist es oft schwierig, den Anfang und das Ende des Durchlaufs richtig hinzubekommen. Hier ist eine Funktion, die zwei Wörter vergleichen soll und `True` zurückliefern soll, wenn eines der Wörter gleich dem anderen Wort ist, wenn es rückwärts geschrieben wird: "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def is_reverse(word1, word2):\n",
+ " if len(word1) != len(word2):\n",
+ " return False\n",
+ " \n",
+ " i = 0\n",
+ " j = len(word2)\n",
+ "\n",
+ " while j > 0:\n",
+ " if word1[i] != word2[j]:\n",
+ " return False\n",
+ " i = i+1\n",
+ " j = j-1\n",
+ "\n",
+ " return True"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Leider enthält die Funktion einen Fehler.\n",
+ "\n",
+ "Die erste `if`-Verzweigung prüft, ob beide Wörter gleich lang sind. Falls nicht, können wir direkt `False` zurückgeben. Ansonsten können wir für den Rest der Funktion annemen, dass die beiden Wörter die gleiche Länge haben. Das ist ein Beispiel für das [Wächter-Muster aus Abschnitt 6.8](seminar06.ipynb#6.8-Typen-pr%C3%BCfen).\n",
+ "\n",
+ "`i` und `j` sind Indizes: `i` durchläuft `word1` vorwärts und `j` durchläuft `word2` rückwärts. Wenn wir zwei Buchstaben finden, die nicht gleich sind, dann können wir sofort `False` zurückgeben. Wenn die Schleife komplett durchlaufen wird und alle Buchstaben passen, dann geben wir `True` zurück. \n",
+ "\n",
+ "Wenn wir diese Funktion mit den Wörtern `pots` und `stop` testen, dann erwarten wir, dass `True` zurückgegeben wird, aber wir erhalten einen `IndexError`: "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "is_reverse(\"pots\", \"stop\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Eine sinnvolle Möglichkeit, solche Fehler zu debuggen, ist, sich die Werte der Indizes direkt vor der Stelle auszugeben, an der der Fehler auftritt: "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def is_reverse(word1, word2):\n",
+ " if len(word1) != len(word2):\n",
+ " return False\n",
+ " \n",
+ " i = 0\n",
+ " j = len(word2)\n",
+ "\n",
+ " while j > 0:\n",
+ " print(i,j) # for debugging\n",
+ " \n",
+ " if word1[i] != word2[j]:\n",
+ " return False\n",
+ " i = i+1\n",
+ " j = j-1\n",
+ "\n",
+ " return True"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Wenn wir jetzt das Programm starten, erhalten wir mehr Information:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "is_reverse(\"pots\", \"stop\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Im ersten Durchlauf der Schleife ist der Wert von `j` gleich 4, was ausserhalb des Index-Bereiches der Zeichenkette `pots` ist. Der Index des letzten Zeichens ist 3, so dass der Startwert für `j` gleich `len(word2)-1` sein sollte.\n",
+ "\n",
+ "Wenn wir den Fehler beheben und das Programm nochmal starten, erhalten wir:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "is_reverse(\"pots\", \"stop\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "(Beheben Sie den Fehler und probieren Sie es aus!)\n",
+ "\n",
+ "Dieses Mal erhalten wir die richtige Antwort, aber es sieht so aus, als ob die Schleife nur dreimal ausgeführt wurde, was seltsam ist. Um eine eine Idee davon zu bekommen, was passiert, ist es nützlich, ein Zustandsdiagramm zu zeichen. Der Rahmen während der ersten Iteration ist in der folgenden Abbildung zu sehen:\n",
+ "\n",
+ "\n",
+ "\n",
+ "\n",
+ "Ich habe mir die Freiheit genommen, die Variablen im Rahmen etwas zu verschieben und gepunktete Linien hinzuzufügen, so dass man leicht sieht, dass `i` und `j` jeweils auf Zeichen in `word1` und `word2` zeigen.\n",
+ "\n",
+ "Führen Sie, ausgehend von diesem Diagramm, das Programm auf Papier aus und ändern Sie die Werte von `i` und `j` während jeder Iteration. Finden Sie den zweiten Fehler in der Funktion und reparieren Sie sie."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### 8.12 Glossar\n",
+ "\n",
+ "Legen wir uns eine Liste mit den wichtigsten Begriffen an, die wir im Kapitel 8 gelernt haben:\n",
+ "\n",
+ "- Objekt:\n",
+ "- Folge:\n",
+ "- Element:\n",
+ "- Index:\n",
+ "- Segment:\n",
+ "- leere Zeichenkette:\n",
+ "- unveränderbar:\n",
+ "- Durchlauf:\n",
+ "- Suche:\n",
+ "- Zähler:\n",
+ "- Aufruf:\n",
+ "- optionales Argument:\n",
+ "\n",
+ "Ergänzen Sie die Liste in eigenen Worten. Das ist eine gute Erinnerungs- und Übungsmöglichkeit."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### 8.13 Ãœbung\n",
+ "\n",
+ "#### Aufgabe 1\n",
+ "\n",
+ "Lesen Sie die Dokumentation für die Zeichenketten-Methoden auf der Seite https://docs.python.org/3/library/stdtypes.html#string-methods (sie müssen ggf. herunterscrollen bis zum Abschnitt \"4.7.1. String Methods\"). Probieren Sie einige der Methoden aus, um sich mit ihnen vertraut zu machen. Die Methoden `strip` und `replace` sind besonders nützlich. \n",
+ "\n",
+ "Die Dokumentation nutzt eine Syntax, die eventuell verwirrend für Sie ist. Beispielsweise zeigen in `find(sub[, start[, end]])` die eckige Klammern optionale Argumente an. Das bedeutet, dass `sub` benötigt wird, aber `start` optional ist und wenn wir `start` angeben, dann ist `end` optional.\n",
+ "\n",
+ "#### Aufgabe 2\n",
+ "Es gibt eine Zeichenketten-Methode mit Namen `count`, die ähnlich der Funktion im [Abschnitt 8.7](#8.7-Schleifen-ausf%C3%BChren-und-z%C3%A4hlen) ist. Lesen Sie die Dokumentation dieser Methode und schreiben Sie einen Aufruf, der die Anzahl an `a`'s in `banana` zählt.\n",
+ "\n",
+ "#### Aufgabe 3\n",
+ "Einem Zeichenketten-Segment können wir einen dritten Wert übergeben, der die \"Schrittgröße\" angibt, d.h. die Anzahl an Schritten zwischen zwei aufeinanderfolgenden Zeichen. Eine Schrittgröße von 2 bedeutet, dass jedes zweite Zeichen ausgewählt wird; 3 bedeutet, dass jedes dritte Zeichen ausgewählt wird, etc.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "fruit = 'banana'\n",
+ "fruit[0:5:2]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Eine Schrittgröße von -1 durchläuft das Wort rückwärts, so dass das Segment `[::-1]` eine umgekehrte Zeichenkette erzeugt.\n",
+ "\n",
+ "Nutzen Sie diese Möglichkeit, um eine einzeilige Variante von `is_palindrome` aus der [3. Aufgabe von Kapitel 6](seminar06.ipynb#Aufgabe-3) zu schreiben.\n",
+ "\n",
+ "#### Aufgabe 4\n",
+ "\n",
+ "Die folgenden Funktionen sind eigentlich dafür gedacht, zu prüfen, ob eine Zeichenkette Kleinbuchstaben enthält, aber ein paar der Funktionen sind kaputt. Beschreiben Sie für jede Funktion, was die Funktion tatsächlich tut (unter der Annahme, dass das übergebene Argument eine Zeichenkette ist): "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def any_lowercase1(s):\n",
+ " for c in s:\n",
+ " if c.islower():\n",
+ " return True\n",
+ " else:\n",
+ " return False\n",
+ "\n",
+ "def any_lowercase2(s):\n",
+ " for c in s:\n",
+ " if 'c'.islower():\n",
+ " return 'True'\n",
+ " else:\n",
+ " return 'False'\n",
+ "\n",
+ "def any_lowercase3(s):\n",
+ " for c in s:\n",
+ " flag = c.islower()\n",
+ " return flag\n",
+ "\n",
+ "def any_lowercase4(s):\n",
+ " flag = False\n",
+ " for c in s:\n",
+ " flag = flag or c.islower()\n",
+ " return flag\n",
+ "\n",
+ "def any_lowercase5(s):\n",
+ " for c in s:\n",
+ " if not c.islower():\n",
+ " return False\n",
+ " return True"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### Aufgabe 6\n",
+ "\n",
+ "Eine [Cäsar-Chiffre](https://de.wikipedia.org/wiki/Caesar-Verschl%C3%BCsselung) ist eine schwache Form der Verschlüsselung, bei der jeder Buchstabe um eine feste Anzahl an Zeichen \"verschoben\" wird. Einen Buchstaben zu verschieben heisst, ihn durch das Alphabet zu schieben, wobei wir, falls notwendig, wieder am Anfang anfangen, so dass 'A' um drei verschoben 'D' ergibt und 'Z' um 1 verschoben 'A' ergibt. \n",
+ "\n",
+ "\n",
+ "\n",
+ "([Security](https://xkcd.com/538/), Randall Munroe)\n",
+ "\n",
+ "Um ein Wort zu verschieben, verschieben wir jeden Buchstaben um die gleiche Anzahl. Beispielsweise ist \"cheer\" verschoben um 7 gleich \"jolly\" und \"melon\" verschoben um -10 ist gleich \"cubed\". Im Film [2001: Odyssee im Weltraum](https://de.wikipedia.org/wiki/2001:_Odyssee_im_Weltraum) heisst der Bordcomputer \"HAL\", was \"IBM\" verschoben um -1 entspricht.\n",
+ "\n",
+ "\n",
+ "\n",
+ "([Cryteria](https://commons.wikimedia.org/wiki/File:HAL9000.svg))\n",
+ "\n",
+ "Schreiben Sie eine Funktion `rotate_word`, die eine Zeichenkette und eine ganze Zahl als Argument erwartet und eine neue Zeichenkette zurückgibt, die die Zeichen der ersten Zeichenkette verschoben um den angegebenen Betrag enthält. \n",
+ "\n",
+ "Sie können die eingebaute Funktion `ord` nutzen, die den Unicode-Wert eines Zeichens zurückgibt, und die Funktion `chr`, die einen Unicode-Wert wieder in ein Zeichen umwandelt. Die Zeichen des Alphabets (ausser den Umlauten) sind alphabetisch kodiert, so dass beispielsweise gilt:\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ord('c') - ord('a')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Denn `'c'` ist der 2. Buchstabe des Alphabets. Passen Sie aber auf: die Zahlenwerte für die Großbuchstaben sind anders.\n",
+ "\n",
+ "Potentiell anstößige Witze im Internet sind manchmal mittels ROT13 kodiert, was einer Cäsar-Chiffre mit einer Verschiebung um 13 Zeichen entspricht. Falls Sie sich nicht leicht gekränkt fühlen, finden Sie einige der Witze und dekodieren Sie sie. \n",
+ "\n",
+ "(Musterlösung: http://thinkpython2.com/code/rotate.py)"
+ ]
},
{
"cell_type": "markdown",