From bef43c44e19ff58fe188610b8b715b6ea28f135f Mon Sep 17 00:00:00 2001
From: schwabmi <michel.j.schwab@gmail.com>
Date: Mon, 1 Feb 2021 10:53:08 +0100
Subject: [PATCH] MB changes updated
---
notebooks/seminar08.ipynb | 317 ++++++++++++++++++++++++++++----------
1 file changed, 239 insertions(+), 78 deletions(-)
diff --git a/notebooks/seminar08.ipynb b/notebooks/seminar08.ipynb
index 727a3a1..d5927e6 100644
--- a/notebooks/seminar08.ipynb
+++ b/notebooks/seminar08.ipynb
@@ -4,24 +4,29 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "# Seminar Problemorientierte Programmierung"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## 8 Zeichenketten\n",
+ "# 8 Zeichenketten\n",
"[Chapter 8: Strings](http://greenteapress.com/thinkpython2/html/thinkpython2009.html)\n",
"\n",
"Zeichenketten sind anders als ganze Zahlen, Gleitkommazahlen und Boolesche Werte. Eine Zeichenkette ist eine **Folge** (*sequence*), d.h. eine geordnete Menge einzelner Werte. In diesem Kapitel lernen wir, wie wir auf die Zeichen zugreifen können, aus denen eine Zeichenkette besteht und lernen einige der Funktionen kennen, die für Zeichenketten bereitgestellt werden.\n",
"\n",
"\n",
"\n",
- "[VIM](https://browserling.smugmug.com/Weekly-Comic-About-Programmers/i-fkJRphx/L), comic.browserling.com\n",
- "\n",
- "\n",
- "### Ihre Lernziele:\n",
+ "[VIM](https://browserling.smugmug.com/Weekly-Comic-About-Programmers/i-fkJRphx/L), comic.browserling.com"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "<h1>Inhaltsverzeichnis<span class=\"tocSkip\"></span></h1>\n",
+ "<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#Ihre-Lernziele:\" data-toc-modified-id=\"Ihre-Lernziele:-1\"><span class=\"toc-item-num\">1 </span>Ihre Lernziele:</a></span></li><li><span><a href=\"#Exkurs:-Was-mir-an-Python-gefällt\" data-toc-modified-id=\"Exkurs:-Was-mir-an-Python-gefällt-2\"><span class=\"toc-item-num\">2 </span>Exkurs: Was mir an Python gefällt</a></span></li><li><span><a href=\"#Eine-Zeichenkette-ist-eine-Folge\" data-toc-modified-id=\"Eine-Zeichenkette-ist-eine-Folge-3\"><span class=\"toc-item-num\">3 </span>Eine Zeichenkette ist eine Folge</a></span></li><li><span><a href=\"#len\" data-toc-modified-id=\"len-4\"><span class=\"toc-item-num\">4 </span><code>len</code></a></span></li><li><span><a href=\"#Durchlauf-mit-einer-for-Schleife\" data-toc-modified-id=\"Durchlauf-mit-einer-for-Schleife-5\"><span class=\"toc-item-num\">5 </span>Durchlauf mit einer <code>for</code>-Schleife</a></span></li><li><span><a href=\"#Zeichenketten-Segmente\" data-toc-modified-id=\"Zeichenketten-Segmente-6\"><span class=\"toc-item-num\">6 </span>Zeichenketten-Segmente</a></span></li><li><span><a href=\"#Zeichenketten-sind-unveränderbar\" data-toc-modified-id=\"Zeichenketten-sind-unveränderbar-7\"><span class=\"toc-item-num\">7 </span>Zeichenketten sind unveränderbar</a></span></li><li><span><a href=\"#Suche\" data-toc-modified-id=\"Suche-8\"><span class=\"toc-item-num\">8 </span>Suche</a></span></li><li><span><a href=\"#Schleifen-ausführen-und-zählen\" data-toc-modified-id=\"Schleifen-ausführen-und-zählen-9\"><span class=\"toc-item-num\">9 </span>Schleifen ausführen und zählen</a></span></li><li><span><a href=\"#Methoden-für-Zeichenketten\" data-toc-modified-id=\"Methoden-für-Zeichenketten-10\"><span class=\"toc-item-num\">10 </span>Methoden für Zeichenketten</a></span></li><li><span><a href=\"#Der-in-Operator\" data-toc-modified-id=\"Der-in-Operator-11\"><span class=\"toc-item-num\">11 </span>Der <code>in</code>-Operator</a></span><ul class=\"toc-item\"><li><span><a href=\"#8.10-Zeichenketten-vergleichen\" data-toc-modified-id=\"8.10-Zeichenketten-vergleichen-11.1\"><span class=\"toc-item-num\">11.1 </span>8.10 Zeichenketten vergleichen</a></span></li></ul></li><li><span><a href=\"#Debugging\" data-toc-modified-id=\"Debugging-12\"><span class=\"toc-item-num\">12 </span>Debugging</a></span></li><li><span><a href=\"#Glossar\" data-toc-modified-id=\"Glossar-13\"><span class=\"toc-item-num\">13 </span>Glossar</a></span></li><li><span><a href=\"#Übung\" data-toc-modified-id=\"Übung-14\"><span class=\"toc-item-num\">14 </span>Übung</a></span><ul class=\"toc-item\"><li><span><a href=\"#Aufgabe-1\" data-toc-modified-id=\"Aufgabe-1-14.1\"><span class=\"toc-item-num\">14.1 </span>Aufgabe 1</a></span></li><li><span><a href=\"#Aufgabe-2\" data-toc-modified-id=\"Aufgabe-2-14.2\"><span class=\"toc-item-num\">14.2 </span>Aufgabe 2</a></span></li><li><span><a href=\"#Aufgabe-3\" data-toc-modified-id=\"Aufgabe-3-14.3\"><span class=\"toc-item-num\">14.3 </span>Aufgabe 3</a></span></li><li><span><a href=\"#Aufgabe-4\" data-toc-modified-id=\"Aufgabe-4-14.4\"><span class=\"toc-item-num\">14.4 </span>Aufgabe 4</a></span></li><li><span><a href=\"#Aufgabe-6\" data-toc-modified-id=\"Aufgabe-6-14.5\"><span class=\"toc-item-num\">14.5 </span>Aufgabe 6</a></span></li></ul></li></ul></div>"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Ihre Lernziele:\n",
"\n",
"Beschreiben Sie in 2-3 Stichpunkten kurz was Sie im Seminar heute lernen wollen. Klicken Sie dazu doppelt auf diesen Text und bearbeiten Sie dann den Text:\n",
"\n",
@@ -76,7 +81,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "### 8.1 Eine Zeichenkette ist eine Folge\n",
+ "## Eine Zeichenkette ist eine Folge\n",
"\n",
"Eine Zeichenkette ist eine Folge von Zeichen. Wir können auf die einzelnen Zeichen mit Hilfe des Klammer-Operators zugreifen:"
]
@@ -180,7 +185,7 @@
"\n",
"([Evan-Amos](https://commons.wikimedia.org/wiki/File:Banana-Single.jpg))\n",
"\n",
- "### 8.2 `len`\n",
+ "## `len`\n",
"\n",
"`len` ist eine eingebaute Funktion, die die Anzahl der Zeichen einer Zeichenkette zurückgibt; sie haben die `len`-Funktion bereits im 3. Seminar kennengelernt und für die erste Hausaufgabe verwendet:\n"
]
@@ -258,7 +263,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "### 8.3 Durchlauf mit einer `for`-Schleife\n",
+ "## Durchlauf mit einer `for`-Schleife\n",
"\n",
"In vielen Berechnungen müssen wir eine Zeichenkette Zeichen für Zeichen verarbeiten. Oft beginnen wir mit dem ersten Zeichen und wählen dann in jedem Schritt das nächste Zeichen aus, machen etwas damit und fahren fort bis zum Ende der Zeichenkette. Diese Art von Prozess wird **Durchlauf** (*traversal*) genannt. Eine Möglichkeit einen Durchlauf zu programmieren, ist mit Hilfe einer `while`-Schleife:\n",
"\n"
@@ -352,7 +357,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "### 8.4 Zeichenketten-Segmente\n",
+ "## Zeichenketten-Segmente\n",
"\n",
"Ein Teil einer Zeichenkette wird **Segment** (*slice*) gennannt. Ein Segment können wir ähnlich wie ein einzelnes Zeichen auswählen:\n"
]
@@ -443,7 +448,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "### 8.5 Zeichenketten sind unveränderbar\n",
+ "## Zeichenketten sind unveränderbar\n",
"\n",
"Es ist verlockend, den `[]`-Operator auf der linken Seite einer Zuweisung zu verwenden, um ein Zeichen innerhalb einer Zeichenkette zu verändern. Beispielsweise:"
]
@@ -489,7 +494,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "### 8.6 Suche\n",
+ "## Suche\n",
"\n",
"Was macht die folgende Funktion? Probieren Sie es aus!\n"
]
@@ -539,9 +544,9 @@
"source": [
"\n",
"\n",
- "([Recent Searches](https://xkcd.com/1678/), Randall Munroe)\n",
+ "([Recent Searches](https://xkcd.com/1678/), Randall Munroe; [Eine Erklärung des Comics](https://www.explainxkcd.com/wiki/index.php/1678:_Recent_Searches) falls Sie mehr lernen möchten)\n",
"\n",
- "### 8.7 Schleifen ausführen und zählen\n",
+ "## Schleifen ausführen und zählen\n",
"\n",
"Das folgende Programm zählt wie häufig der Buchstabe `a` in einer Zeichenkette auftaucht:"
]
@@ -600,14 +605,14 @@
"source": [
"\n",
"\n",
- "([One Two](https://xkcd.com/764/), Randall Munroe)"
+ "([One Two](https://xkcd.com/764/), Randall Munroe, [Erklärung des Comics](https://www.explainxkcd.com/wiki/index.php/764:_One_Two) falls Sie mehr lernen wollen)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
- "### 8.8 Methoden für Zeichenketten\n",
+ "## 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. Vielleicht können Sie erkennen, dass wir für das `turtle` Modul bereits Methoden verwendet haben. Beispielsweise erwartet die Methode `upper` eine Zeichenkette und gibt eine neue Zeichenkette zurück, in der alle Buchstaben GROSS geschrieben sind.\n",
"\n",
@@ -709,7 +714,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "### 8.9 Der `in`-Operator\n",
+ "## 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 Teilzeichenkette der zweiten ist:\n"
]
@@ -848,7 +853,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "### 8.11 Debugging\n",
+ "## Debugging\n",
"\n",
"Wenn wir Indizes 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: "
]
@@ -881,7 +886,7 @@
"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 annehmen, 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",
+ "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 annehmen, dass die beiden Wörter die gleiche Länge haben. Das ist ein Beispiel für das [Wächter-Muster aus Seminar 6](seminar06.ipynb).\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",
@@ -970,7 +975,7 @@
"\n",
"\n",
"\n",
- "([Fixing Problems](https://xkcd.com/1739/), Randall Munroe)\n",
+ "([Fixing Problems](https://xkcd.com/1739/), Randall Munroe, [Erklärung des Comics](https://www.explainxkcd.com/wiki/index.php/1739:_Fixing_Problems) falls Sie mehr lernen wollen)\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 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",
@@ -990,7 +995,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "### 8.12 Glossar\n",
+ "## Glossar\n",
"\n",
"Legen wir uns eine Liste mit den wichtigsten Begriffen an, die wir im Kapitel 8 gelernt haben:\n",
"\n",
@@ -1014,9 +1019,9 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "### 8.13 Ãœbung\n",
+ "## Ãœbung\n",
"\n",
- "#### Aufgabe 1\n",
+ "### Aufgabe 1\n",
"\n",
"Lesen Sie die Dokumentation für die Zeichenketten-Methoden auf [dieser 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 - mindestens 5- aus, um sich mit ihnen vertraut zu machen. Die Methoden `strip` und `replace` sind besonders nützlich. \n"
]
@@ -1041,10 +1046,10 @@
"\n",
"\n",
"\n",
- "([Strip Games](https://xkcd.com/696/), Randall Munroe)\n",
+ "([Strip Games](https://xkcd.com/696/), Randall Munroe, [Erklärung des Comics](https://www.explainxkcd.com/wiki/index.php/696:_Strip_Games) falls Sie mehr wissen möchten)\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."
+ "### Aufgabe 2\n",
+ "Es gibt eine Zeichenketten-Methode mit Namen `count`, die ähnlich der Funktion im [Abschnitt 9](#8.9-Schleifen-ausf%C3%BChren-und-z%C3%A4hlen) in diesem Notebook ist ist. Lesen Sie die Dokumentation dieser Methode und schreiben Sie einen Aufruf, der die Anzahl an `a`'s in `banana` zählt."
]
},
{
@@ -1060,7 +1065,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "#### Aufgabe 3\n",
+ "### Aufgabe 3\n",
"Einem Zeichenketten-Segment können wir einen dritten Wert übergeben, der die \"Schrittweite\" angibt, d.h. die Anzahl an Schritten zwischen zwei aufeinanderfolgenden Zeichen. Eine Schrittweite von 2 bedeutet, dass jedes zweite Zeichen ausgewählt wird; 3 bedeutet, dass jedes dritte Zeichen ausgewählt wird, etc."
]
},
@@ -1080,7 +1085,43 @@
"source": [
"Eine Schrittweite 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."
+ "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",
+ "\n",
+ "<details>\n",
+ " <summary type=\"button\" class=\"btn btn-primary\">1. Hinweis</summary>\n",
+ " <div class=\"alert alert-info\" role=\"alert\">\n",
+ "\n",
+ "Schreiben Sie zunächst den Kopf der Funktion auf. Wir werden die Funktion in mehreren Zeilen entwickeln und dann so zusammenfassen, dass Sie nur eine Zeile brauchen. Schreiben Sie auch schon eine `return`-Anweisung auf und lassen Sie einen Platzhalter zurückgeben. \n",
+ " </div> \n",
+ "</details> \n",
+ " \n",
+ " \n",
+ "<details>\n",
+ " <summary type=\"button\" class=\"btn btn-primary\">2. Hinweis</summary>\n",
+ " <div class=\"alert alert-info\" role=\"alert\">\n",
+ "\n",
+ "Erzeugen Sie eine umgekehrte Zeichenkette des eingegebenen Wortes.\n",
+ " </div> \n",
+ "</details> \n",
+ "\n",
+ "\n",
+ "<details>\n",
+ " <summary type=\"button\" class=\"btn btn-primary\">3. Hinweis</summary>\n",
+ " <div class=\"alert alert-info\" role=\"alert\">\n",
+ "\n",
+ "Vergleichen Sie in der `return`- Anweisung die ursprüngliche Zeichenkette mit der umgekehrten Zeichenkette\n",
+ " </div> \n",
+ "</details>\n",
+ "\n",
+ "<details>\n",
+ " <summary type=\"button\" class=\"btn btn-primary\">4. Hinweis</summary>\n",
+ " <div class=\"alert alert-info\" role=\"alert\">\n",
+ "\n",
+ "Sie können die umgekehrte Zeichenkette auch in der `return`-Anweisung erzeugen und direkt vergleichen, so erhalten Sie eine einzeilige Funktion\n",
+ " </div> \n",
+ "</details>\n",
+ " \n"
]
},
{
@@ -1099,11 +1140,7 @@
"\n",
"<a data-flickr-embed=\"true\" href=\"https://www.flickr.com/photos/jasoneppink/4964471335\" title=\"Spoiler Alert\"><img src=\"https://farm5.staticflickr.com/4110/4964471335_1f86a923f3_n.jpg\" width=\"320\" height=\"213\" alt=\"Spoiler Alert\"></a><script async src=\"//embedr.flickr.com/assets/client-code.js\" charset=\"utf-8\"></script>\n",
"\n",
- "(Quelle: Jason Eppink, Flickr)\n",
- "\n",
- "\n",
- "1. Schreiben Sie wie immer erst den Funktionskopf.\n",
- "2. Überlegen Sie was Sie über boolsche Werte wissen, schreiben sie den Vergleich ruhig ersteinmal mehrzeilig auf und überlegen Sie dann wie sie Zeilen zusammenfassen können."
+ "(Quelle: Jason Eppink, Flickr)\n"
]
},
{
@@ -1123,7 +1160,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "#### Aufgabe 4\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): "
]
@@ -1177,31 +1214,56 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "\n",
- "<a data-flickr-embed=\"true\" href=\"https://www.flickr.com/photos/jasoneppink/4964471335\" title=\"Spoiler Alert\"><img src=\"https://farm5.staticflickr.com/4110/4964471335_1f86a923f3_n.jpg\" width=\"320\" height=\"213\" alt=\"Spoiler Alert\"></a><script async src=\"//embedr.flickr.com/assets/client-code.js\" charset=\"utf-8\"></script>\n",
- "\n",
- "(Quelle: Jason Eppink, Flickr)\n",
- "\n",
- "Hier gibt es keine Lösungsansätze, schauen sie sich die Lösungen von unten an und versuchen Sie nachzuvollziehen wie der tatsächliche Effekt entsteht. Fragen Sie dabei auf jeden Fall nach, wenn Sie etwas nicht verstehen!\n",
- "\n",
- " - any_lowercase1 prüft ob alle Zeichen Kleinbuchstaben sind.\n",
- " - any_lowercase2 prüft ob `c`ein Kleinbuchstabe ist und gibt immer true – als Zeichenkette, nicht als boolscher Wert – zurück.\n",
- " - any_lowercase3 prüft ob der letzte Buchstabe ein Kleinbuchstabe ist.\n",
- " - any_lowercase4 prüft ob es Kleinbuchstaben gibt, diese Funktion macht das was sie soll.\n",
- " - any_lowercase5 püft ob der erste Buchstabe ein Kleinbuchstabe ist. "
+ "Hier werden Sie keine klassischen Lösungsansätze finden, stattdessen wird für jede Funktion erklärt, was Sie tatsächlich tut. Führen Sie aber auf jeden Fall zunächst jede der Funktionen aus und versuchen Sie in eigenen Worten zu erklären, was die Funktionen machen. Testen Sie immer Großbuchstaben an verschiedenen Stellen im Wort und schauen Sie sich die Ergebnisse an.\n",
+ " \n",
+ " <details>\n",
+ " <summary type=\"button\" class=\"btn btn-success\">any_lowercase1</summary>\n",
+ " <div class=\"alert alert-success\" role=\"alert\">\n",
+ "Diese Funktion prüft ob der erste Buchstabe ein Kleinbuchstabe ist, und gibt darauf basierend entweder `True` oder `False`zurück. Wenn der erste Buchstabe ein Großbuchstabe ist, gibt die Funktion `False`zurück.\n",
+ " </div> \n",
+ "</details> \n",
+ " \n",
+ " <details>\n",
+ " <summary type=\"button\" class=\"btn btn-success\">any_lowercase2</summary>\n",
+ " <div class=\"alert alert-success\" role=\"alert\">\n",
+ "Diese Funktion gibt zunächst nicht einmal einen boolschen Wert sondern eine Zeichenkette zurück, aber selbst wenn dies die gewollte Ausgabe wäre, macht die Funktion nicht, was in der Aufgabenstellung gefordert ist. Stattdessen wird geprüft, ob die Zeichenkette `c` ein Kleinbuchstabe ist. </div> \n",
+ "</details> \n",
+ " \n",
+ " \n",
+ " <details>\n",
+ " <summary type=\"button\" class=\"btn btn-success\">any_lowercase3</summary>\n",
+ " <div class=\"alert alert-success\" role=\"alert\">\n",
+ "Diese Funktion prüft, ob das letzte Zeichen ein Kleinbuchstabe ist. Dafür verwendet Sie eine sogenannte \"flag\", die den Wahrheitswert jedes einzelnen Buchstaben solange speichert, bis der nächste Buchstabe geprüft wird. Dadurch zählt nur der letzte Buchstabe für die endgültige Ausgabe. </div> \n",
+ "</details> \n",
+ " \n",
+ " \n",
+ " <details>\n",
+ " <summary type=\"button\" class=\"btn btn-success\">any_lowercase4</summary>\n",
+ " <div class=\"alert alert-success\" role=\"alert\">\n",
+ "Diese Funktion tut genau das, was in der Aufgabenstellung verlangt wird. Auch Sie verwendet eine temporäre Variable als \"flag\", um den Wahrheitszustand der Aussage zu speichern, verwendet aber boolsche Logik, damit `True` zurückgegeben wird, wenn die Funktion mindestens einen Kleinbuchstaben findet. Wir nutzen den boolsche `or`Operator, der dann `True ergibt, wenn mindestens eine der Aussagen wahr ist. Die Flag Variable ist so lange falsch, bis `is_lower()` `True` zurückgibt. Dann ist der Wert der Variablen `True` und bleibt es auch, bis die Funktion beendet wird.\n",
+ " </div> \n",
+ "</details> \n",
+ " \n",
+ " \n",
+ " <details>\n",
+ " <summary type=\"button\" class=\"btn btn-success\">any_lowercase5</summary>\n",
+ " <div class=\"alert alert-success\" role=\"alert\">\n",
+ "Diese Funktion prüft, ob alle Buchstaben Kleinbuchstaben sind und gibt `False`zurück, sobald sie einen Großbuchstaben findet. Erst wenn kein Buchstabe für `is_lower``False` zurückgegeben wird, wird `True` zurückgegeben. Schauen Sie sich die `if`-Bedingung genau an und versuchen Sie diese nachzuvollziehen.\n",
+ " </div> \n",
+ "</details> "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
- "#### Aufgabe 6\n",
+ "### 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 heißt, ihn durch das Alphabet zu schieben, wobei wir, falls notwendig, wieder am Anfang anfangen, sodass 'A' um drei verschoben 'D' ergibt und 'Z' um 1 verschoben 'A'. \n",
"\n",
"\n",
"\n",
- "([Security](https://xkcd.com/538/), Randall Munroe)\n",
+ "([Security](https://xkcd.com/538/), Randall Munroe; [Erklärung des Comics](https://www.explainxkcd.com/wiki/index.php/538:_Security) falls Sie mehr wissen wollen.)\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",
@@ -1220,14 +1282,135 @@
"metadata": {},
"outputs": [],
"source": [
- "ord('c') - ord('a')"
+ "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."
+ "Denn `'c'` ist der 2. Buchstabe des Alphabets. Passen Sie aber auf: die Zahlenwerte für die Großbuchstaben sind anders.\n",
+ "\n",
+ "\n",
+ "Es folgen einige Hinweise zum Lösen der Aufgabe. Versuchen Sie so viel wie möglich alleine mit Ihrem Partner zu lösen, das ist die beste Übung und fragen Sie nach, wenn Sie etwas nicht verstehen.\n",
+ "\n",
+ "<details>\n",
+ " <summary type=\"button\" class=\"btn btn-primary\">1. Hinweis</summary>\n",
+ " <div class=\"alert alert-info\" role=\"alert\">\n",
+ "\n",
+ "Wie immer fangen wir damit a,n den Kopf der Funktion zu schreiben. Überlegen Sie sich, welche Parameter der Funktion übergeben werden und schreiben Sie auch schon die Rückgabe mit einem Platzhalter.\n",
+ " </div> \n",
+ "</details> \n",
+ " \n",
+ " \n",
+ "<details>\n",
+ " <summary type=\"button\" class=\"btn btn-primary\">2. Hinweis</summary>\n",
+ " <div class=\"alert alert-info\" role=\"alert\">\n",
+ "Um ein Wort um eine bestimmte Anzahl an Buchstaben zu verschieben, ist es am einfachsten, jeden Buchstaben um diese Anzahl zu verschieben und dann das neue Wort zusammenzusetzen. Wir werden dies in eine eigene Funktion auslagern. Schreiben Sie das Gerüst dieser Funktion, also den Kopf, die Parameter und die `return`-Anweisung mit einer Platzhaltervariablen.\n",
+ "\n",
+ " </div> \n",
+ "</details> \n",
+ " \n",
+ "Wir beschäftigen uns nun erstmal mit der Verschiebung eines einzelnen Buchstabens. Erst wenn das funktioniert, kehren wir zur Funktion zum Verschieben eines ganzen Wortes zurück. \n",
+ " \n",
+ "<details>\n",
+ " <summary type=\"button\" class=\"btn btn-primary\">3. Hinweis</summary>\n",
+ " <div class=\"alert alert-info\" role=\"alert\">\n",
+ "Wir werden die `ord`- und `chr`-Funktionen nutzen um die Buchstaben zu verschieben. Dabei sollen Zeichen, die keine Buchstaben sind, nicht verschoben werden (Konkret sollen also Sonderzeichen wie `?,.,!,:` etc. und Leerzeichen einfach zurückgegeben werden). Wenn ein Zeichen weder groß noch klein geschrieben ist, ist es ein Sonderzeichen. Auch müssen durch die unterschiedlichen Stellenwerte Groß- und Kleinbuchstaben getrennt voneinander behandelt werden. Wie genau wir mit den Buchstaben umgehen, schauen wir uns noch an. Schreiben Sie einen Test, der prüft, ob Sie einen Groß- oder Kleinbuchstaben oder ein Sonderzeichen haben.\n",
+ " </div> \n",
+ "</details>\n",
+ "\n",
+ "<details> \n",
+ " <summary type=\"button\" class=\"btn btn-primary\">4. Hinweis</summary>\n",
+ " <div class=\"alert alert-info\" role=\"alert\">\n",
+ "\n",
+ " Prüfen Sie mit `if`, `elif` und `else` und den Methoden `isupper()` und `islower()`, welche Bedingung wahr ist. Alle Sonderzeichen sollten im `else` Fall behandelt und unverändert zurückgegeben werden. Für die anderen beiden Zeilen können Sie sich einen eindeutigen Platzhalterwert überlegen. Testen Sie nun zunächst einmal, ob Ihre Funktion die verschiedenen Fälle eindeutig und fehlerfrei identifiziert. Machen Sie erst weiter, wenn es funktioniert.\n",
+ " </div> \n",
+ "</details>\n",
+ "\n",
+ "<details>\n",
+ " <summary type=\"button\" class=\"btn btn-primary\">5. Hinweis</summary>\n",
+ " <div class=\"alert alert-info\" role=\"alert\">\n",
+ " \n",
+ "Wenn Sie nur den numerischen Wert des Buchstaben und die Verschiebung addieren und dann wieder in einen Buchstaben verwandeln, funktioniert das in vielen Fällen gut. Probieren Sie aus, was passiert, wenn Sie über z hinaus zurück zum Start des Alphabets gehen wollen. Was passiert? Wir werden uns im nächsten Schritt damit beschäftigen, wie wir das Problem lösen können.\n",
+ " \n",
+ " </div> \n",
+ "</details>\n",
+ "\n",
+ "<details>\n",
+ " <summary type=\"button\" class=\"btn btn-primary\">6. Hinweis</summary>\n",
+ " <div class=\"alert alert-info\" role=\"alert\">\n",
+ "Wir wollen damit beginnen, einen Vergleichswert festzulegen. Wir verwenden dafür den Zahlenwert des Buchstaben a, dabei müssen wir zwischen Groß- und Kleinschreibung unterscheiden. Weisen Sie beide Werte innerhalb der `if`-Schleife derselben Variablen zu. Damit ist der Wert in Abhängigkeit der Schreibweise des eingegebenen Buchstaben festgelegt und wir können im Weiteren die Schreibweise ignorieren. \n",
+ " </div> \n",
+ "</details>\n",
+ "\n",
+ "Die nächsten Schritte sind zunächst eventuell etwas verwirrend, machen aber hoffentlich am Ende der Hinweise wieder Sinn. Sollten Sie nicht verstehen, warum etwas passiert, fragen Sie bitte nach!\n",
+ "\n",
+ "<details>\n",
+ " <summary type=\"button\" class=\"btn btn-primary\">7. Hinweis</summary>\n",
+ " <div class=\"alert alert-info\" role=\"alert\">\n",
+ "Zunächst wollen wir mit Hilfe des Vergleichswertes (dem Wert für a) den Index des Buchstaben im Alphabet festlegen. Dabei wird bei 0 mit dem Zählen begonnen und bei 25 für z aufgehört. Es besteht dieselbe Verschiebung in unserer Vorstellung, wie bei Computerindexen üblich. Um die Position zu berechnen, ziehen wir den Wert der Vergleichvariable vom ordinalen Wert des Buchstabens ab. Lassen Sie sich diese Zahl ruhig einmal für ein paar Buchstaben ausgeben und schauen Sie, ob die Werte stimmen. \n",
+ " </div> \n",
+ "</details>\n",
+ "\n",
+ "<details>\n",
+ " <summary type=\"button\" class=\"btn btn-primary\">8 Hinweis</summary>\n",
+ " <div class=\"alert alert-info\" role=\"alert\">\n",
+ " \n",
+ "Als nächstes können wir den Index für den verschobenen Buchstaben berechnen, indem wir n zum Index addieren. Nun funktioniert die Funktion bis zu dem Punkt, an dem wir von `z` zu `a` gehen müssen. Wie wir damit umgehen, schauen wir uns im nächsten Schritt an. \n",
+ " </div> \n",
+ "</details>\n",
+ "<details>\n",
+ " <summary type=\"button\" class=\"btn btn-primary\">9. Hinweis</summary>\n",
+ " <div class=\"alert alert-info\" role=\"alert\">\n",
+ " \n",
+ "Um den Index zu bekommen, selbst wenn wir über 25 hinaus zurück zu 0 gehen wollen, verwenden wir den modulo Operator, der uns den Rest einer Division zurückgibt. Wird eine Zahl unter 26 mit Rest durch 26 geteilt, ist das Ergebnis `0 Rest diese Zahl`. Wird hingegen zum Beispiel 28 mit Rest durch 26 geteilt, ist das Ergebnis `1 Rest 2`. \n",
+ " </div> \n",
+ "</details>\n",
+ "<details>\n",
+ " <summary type=\"button\" class=\"btn btn-primary\">10. Hinweis</summary>\n",
+ " <div class=\"alert alert-info\" role=\"alert\">\n",
+ " \n",
+ "Wenn wir nun den Index unseres neuen Buchstabens haben, müssen wir noch den tatsächlichen ordinalen Wert des Buchstabens berechnen. Dafür kehren wir das um, was wir zu Beginn der Berechnung gemacht haben und addieren den Startwert wieder hinzu. \n",
+ " </div> \n",
+ "</details>\n",
+ "\n",
+ "<details>\n",
+ " <summary type=\"button\" class=\"btn btn-primary\">11. Hinweis</summary>\n",
+ " <div class=\"alert alert-info\" role=\"alert\">\n",
+ " \n",
+ "Jetzt müssen wir noch den ordinalen Wert mit der `chr`-Funktion in einen Buchstaben verwandeln und zurückgeben. Testen Sie, dass die Funktion das tut was Sie soll und auch funktioniert, wenn Sie eine Verschiebung über die Grenzen des Alphabets vornehmen. \n",
+ " </div> \n",
+ "</details>\n",
+ "\n",
+ "Wir können jetzt Buchstaben um einen bestimmten Wert verschieben. Nun wenden wir uns wieder der Funktion zu, die ein ganzes Wort nimmt und entsprechend verschiebt.\n",
+ "\n",
+ "<details>\n",
+ " <summary type=\"button\" class=\"btn btn-primary\">12. Hinweis</summary>\n",
+ " <div class=\"alert alert-info\" role=\"alert\">\n",
+ "\n",
+ "Da wir Zeichenketten, nachdem sie erzeugt wurden, nicht mehr verändern können, müssen wir eine neue Zeichenkette erzeugen, die eine verschobene Kopie der alten Zeichenkette ist. Wir wollen mit einer leeren Zeichenkette anfangen und dann nach und nach neue Buchstaben hinten an die Zeichenkette anhängen. Im nächsten Schritt müssen wir auf jeden Buchstaben den verschobenen Buchstaben finden. Überlegen Sie, wie Sie die eingegebene Zeichenkette Buchstabe für Buchstabe durchlaufen können.\n",
+ "\n",
+ " </div> \n",
+ "</details>\n",
+ "\n",
+ "<details>\n",
+ " <summary type=\"button\" class=\"btn btn-primary\">13. Hinweis</summary>\n",
+ " <div class=\"alert alert-info\" role=\"alert\">\n",
+ "\n",
+ "In der `for`-Schleife fügen Sie den Rückgabewert der `rotate_letter` der neuen Zeichenkette hinzu, indem Sie die Funktion mit dem entsprechenden Buchstaben aufrufen. \n",
+ " \n",
+ " </div> \n",
+ "</details>\n",
+ "\n",
+ "<details>\n",
+ " <summary type=\"button\" class=\"btn btn-primary\">14. Hinweis</summary>\n",
+ " <div class=\"alert alert-info\" role=\"alert\">\n",
+ "\n",
+ "Denken Sie daran, die neue Zeichenkette auszugeben und testen Sie ihre Funktion um zu sehen, ob Sie das tut, was Sie soll.\n",
+ " \n",
+ " </div> \n",
+ "</details>"
]
},
{
@@ -1253,28 +1436,6 @@
"([Rot13](https://imgur.com/gallery/T7BD6), vnznfyhg)\n"
]
},
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "\n",
- "<a data-flickr-embed=\"true\" href=\"https://www.flickr.com/photos/jasoneppink/4964471335\" title=\"Spoiler Alert\"><img src=\"https://farm5.staticflickr.com/4110/4964471335_1f86a923f3_n.jpg\" width=\"320\" height=\"213\" alt=\"Spoiler Alert\"></a><script async src=\"//embedr.flickr.com/assets/client-code.js\" charset=\"utf-8\"></script>\n",
- "\n",
- "\n",
- "1. Schreiben Sie das Grundgerüst für `rotate_word()`, dieses braucht einzugebende Argumente und muss am Ende einen String zurückgeben.\n",
- "2. Jeder Buchstabe muss einzeln rotiert werden. Das lagern wir in eine weitere Funktion namens rotate_letters aus, schreiben Sie auch dafür wieder die Grundstruktur, also den Kopf der Funktion und auch hier wieder einen Rückgabewert.\n",
- "3. Vor allem Leerzeichen, aber auch alle Zahlen und Sonderzeichen sollen nicht verschoben, sondern einfach zurückgegeben werden. Auch sind Groß- und Kleinschreibung getrennt voneinander codiert. Daher müssen Sie das eingegebene Zeichen prüfen. Sie können dafür die Methoden `isupper()` und `islower()` verwenden. \n",
- "3. Zum Prüfen können Sie eine `if`- Anweisung verwenden. Stellen Sie sicher, dass alle Eingabefälle abgedeckt sind.\n",
- "4. In dieser Verzweigung legen Sie einen Start- bzw. Vergleichswert fest. Dafür wählen Sie den numerischen Wert von `a` - in Abhängigkeit des eingegebenen Buchstabens als Groß- oder Kleinbuchstabe.\n",
- "5. Berechnen Sie die Position im Alphabet indem Sie diesen Startwert von dem Wert des eingegebenen Buchstaben abziehen.\n",
- "6. Berechnen Sie den neuen Wert indem Sie `n` hinzuaddieren, mit Rest durch 26 teilen und dann wieder start hinzuaddieren um einen neuen gültigen Wert zu bekommen. Dies ist für die Fälle nötig, bei denen über `z` hinausgegangen wird und wieder am Anfang des Alphabets begonnen werden soll. \n",
- "7. Wenn jetzt `rotate_letter` funktioniert, können Sie sich wieder `rotate_word` zuwenden. Hier müssen Sie eine neue Zeichenkette mit den berechneten Buchstaben erzeugen. \n",
- "8. Sie fangen mit einer leeren Zeichenkette an. Dann durchlaufen Sie das eingegebene Wort Buchstabe für Buchstabe.\n",
- "9. Schreiben Sie dafür eine `for`-Schleife. \n",
- "10. In der Schleife rufen Sie `rotate_letter` für den jeweiligen Buchstaben auf und fügen das Ergebnis der in `rotate_word` erzeugten Zeichenkette hinzu.\n",
- "11. Nach Verlassen der Schleife wird das neue Wort ausgegeben. "
- ]
- },
{
"cell_type": "code",
"execution_count": null,
--
GitLab