From 310390b2315b001073d0580b05bbcb9dd83ad8bd Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Robert=20J=C3=A4schke?= <jaeschke@l3s.de>
Date: Fri, 26 Jan 2018 17:55:48 +0100
Subject: [PATCH] +Kapitel 8
---
README.org | 1 +
notebooks/README.org | 1 +
notebooks/seminar08.ipynb | 177 ++++++++++++++++++++++++++++++++------
3 files changed, 152 insertions(+), 27 deletions(-)
diff --git a/README.org b/README.org
index fd58242..2adf5d0 100644
--- a/README.org
+++ b/README.org
@@ -31,6 +31,7 @@ speichern unter.../ wählen:
- [[https://scm.cms.hu-berlin.de/ibi/python/raw/master/notebooks/seminar05.ipynb][5: Verzweigungen und Rekursion]]
- [[https://scm.cms.hu-berlin.de/ibi/python/raw/master/notebooks/seminar06.ipynb][6: Ertragreiche Funktionen]]
- [[https://scm.cms.hu-berlin.de/ibi/python/raw/master/notebooks/seminar07.ipynb][7: Iteration]]
+- [[https://scm.cms.hu-berlin.de/ibi/python/raw/master/notebooks/seminar08.ipynb][8: Zeichenketten]]
Merken Sie sich, wo Sie die Dateien gespeichert haben und navigieren
Sie dann mit Jupyter zu diesem Ordner, um sie zu öffnen.
diff --git a/notebooks/README.org b/notebooks/README.org
index 899a447..c8554b2 100644
--- a/notebooks/README.org
+++ b/notebooks/README.org
@@ -23,3 +23,4 @@ speichern unter.../ wählen:
- [[https://scm.cms.hu-berlin.de/ibi/python/raw/master/notebooks/seminar05.ipynb][5: Verzweigungen und Rekursion]]
- [[https://scm.cms.hu-berlin.de/ibi/python/raw/master/notebooks/seminar06.ipynb][6: Ertragreiche Funktionen]]
- [[https://scm.cms.hu-berlin.de/ibi/python/raw/master/notebooks/seminar07.ipynb][7: Iteration]]
+- [[https://scm.cms.hu-berlin.de/ibi/python/raw/master/notebooks/seminar08.ipynb][8: Zeichenketten]]
diff --git a/notebooks/seminar08.ipynb b/notebooks/seminar08.ipynb
index 0c0d300..ca6215d 100644
--- a/notebooks/seminar08.ipynb
+++ b/notebooks/seminar08.ipynb
@@ -52,7 +52,12 @@
"source": [
"## 8 Zeichenketten\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 die Zeichen zugreifen können, aus denen eine Zeichenkette besteht und wir lernen einige der Funktionen kennn, die für Zeichenketten bereitgestellt werden.\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 wir 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",
"### 8.1 Eine Zeichenkette ist eine Folge\n",
"\n",
@@ -154,6 +159,10 @@
"cell_type": "markdown",
"metadata": {},
"source": [
+ "\n",
+ "\n",
+ "([Evan-Amos](https://commons.wikimedia.org/wiki/File:Banana-Single.jpg))\n",
+ "\n",
"### 8.2 `len`\n",
"\n",
"`len` ist eine eingebaute Funktion, die die Anzahl der Zeichen einer Zeichenkette zurückgibt:\n"
@@ -190,7 +199,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "Der Grund für diesen `IndexError` ist, dass es in `banana` kein Zeichen mit dem Index 6 gibt. Da wir ja mit Null begonnen haben zu zählen, sind die sechs Zeichen mit den Zahlen 0 bis 5 numeriert. Um also das letzte Zeichen zu extrahierren, müssen wir 1 von `length` abziehen: "
+ "Der Grund für diesen `IndexError` ist, dass es in `banana` kein Zeichen mit dem Index 6 gibt. Da wir ja mit Null begonnen haben zu zählen, sind die sechs Zeichen mit den Zahlen 0 bis 5 numeriert. Um also das letzte Zeichen zu extrahieren, müssen wir 1 von `length` abziehen: "
]
},
{
@@ -234,7 +243,7 @@
"source": [
"### 8.3 Durchlauf mit einer `for`-Schleife\n",
"\n",
- "In vielen Berechnungen müsen wir eine Zeichenkette Zeichen für Zeichen verarbeiten. Oftmals 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",
+ "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"
]
},
@@ -296,7 +305,11 @@
"source": [
"Jedes Mal, wenn die Schleife durchlaufen wird, wird das nächste Zeichen der Variablen `letter` zugewiesen. Die Schleife fährt fort, bis keine Zeichen mehr übrig sind.\n",
"\n",
- "Im folgenden Beispiel sehen wir, wie die Zeichenkettenverknüpfung und eine `for`-Schleife verwendet werden, um eine ABC-Schützen-Folge (sortierte Folge) zu erzeugen. In Robert McCloskeys Buch \"Make Way for Ducklings\", sind die Namen der Entenkücken *Jack, Kack, Lack, Mack, Nack, Ouack, Pack* und *Quack*. Die Schleife gibt die Namen in dieser Reihenfolge aus: "
+ "\n",
+ "\n",
+ "([Rizka](https://commons.wikimedia.org/wiki/File:Ducklings_in_the_Fall,_Boston_Public_Garden,_Boston,_Massachusetts.JPG))\n",
+ "\n",
+ "Im folgenden Beispiel sehen wir, wie die Zeichenkettenverknüpfung und eine `for`-Schleife verwendet werden, um eine ABC-Schützen-Folge (sortierte Folge) zu erzeugen. In Robert McCloskeys Buch \"Make Way for Ducklings\", sind die Namen der Entenküken *Jack, Kack, Lack, Mack, Nack, Ouack, Pack* und *Quack*. Die Schleife gibt die Namen in dieser Reihenfolge aus: "
]
},
{
@@ -351,7 +364,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "Der Operator `[n:m]` gibt uns den Teil der Zeichenkette vom n-ten bis zum m-ten Zeichen zurück, einschließlich des n-ten aber ohne das m-te Zeichen. Dieses Verhalten ist nicht eingängig, daher hilft es vielleicht, sich vorzustellen, dass die Indexe *zwischen* die Zeichen zeigen, wie in der folgenden Abbildung dargestellt:\n",
+ "Der Operator `[n:m]` gibt uns den Teil der Zeichenkette vom n-ten bis zum m-ten Zeichen zurück, einschließlich des n-ten aber ohne das m-te Zeichen. Dieses Verhalten ist nicht eingängig, daher hilft es vielleicht, sich vorzustellen, dass die Indizes (Mehrzahl von Index) *zwischen* die Zeichen zeigen, wie in der folgenden Abbildung dargestellt:\n",
"\n",
"\n",
"\n",
@@ -484,7 +497,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "Auf gewisse Weise ist `find` das Inverse des `[]`-Operators. Anstatt einn Index zu nehmen und das entsprechende Zeichen zu extrahieren nimmt es ein Zeichen und findet den Index, an dem dieses Zeichen auftaucht. Wenn das Zeichen nicht gefunden wird, dann gibt die Funktion `-1` zurück.\n",
+ "Auf gewisse Weise ist `find` das Inverse des `[]`-Operators. Anstatt einen Index zu nehmen und das entsprechende Zeichen zu extrahieren nimmt es ein Zeichen und findet den Index, an dem dieses Zeichen auftaucht. Wenn das Zeichen nicht gefunden wird, dann gibt die Funktion `-1` zurück.\n",
"\n",
"Das ist das erste Mal, dass wir eine `return`-Anweisung innerhalb einer Schleife sehen! Wenn `word[index] == letter`, dann bricht die Funktion die Schleife ab und gibt direkt `index` zurück.\n",
"\n",
@@ -508,6 +521,10 @@
"cell_type": "markdown",
"metadata": {},
"source": [
+ "\n",
+ "\n",
+ "([Recent Searches](https://xkcd.com/1678/), Randall Munroe)\n",
+ "\n",
"### 8.7 Schleifen ausführen und zählen\n",
"\n",
"Das folgende Programm zählt wie häufig der Buchstabe `a` in einer Zeichenkette auftaucht:"
@@ -549,7 +566,25 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "Schreiben Sie die Funktion jetzt so um, dass sie die Version von `find` mit den drei Parametern aus dem vorherigen Abschnitt verwendet. "
+ "Schreiben Sie die Funktion jetzt so um, dass sie die Version von `find` mit den drei Parametern aus dem vorherigen Abschnitt verwendet."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Implementieren Sie hier die umgeschriebene Variante der Funktion"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "\n",
+ "([One Two](https://xkcd.com/764/), Randall Munroe)"
]
},
{
@@ -558,7 +593,7 @@
"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",
+ "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 Methode `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"
]
@@ -651,7 +686,7 @@
"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."
+ "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 Index sucht, das Zeichen an dessen Stelle aber nicht mit einschliesst, arbeitet es konsistent zum Segment-Operator."
]
},
{
@@ -660,7 +695,7 @@
"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"
+ "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"
]
},
{
@@ -706,7 +741,7 @@
"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"
+ "Hier ist das was passiert, wenn wir Äpfel mit Birnen vergleichen:"
]
},
{
@@ -715,13 +750,17 @@
"metadata": {},
"outputs": [],
"source": [
- "in_both(\"Apfel\", \"Birne\")"
+ "in_both(\"Äpfel\", \"Birnen\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
+ "\n",
+ "\n",
+ "([Fuck Grapefruit](https://xkcd.com/388/), Randall Munroe)\n",
+ "\n",
"### 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:"
@@ -762,9 +801,9 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "Passen Sie den Wert von `word` an, so dass der obige Code die drei verschiedenen Texte ausgibt.\n",
+ "Passen Sie den Wert von `word` an, so dass der obige Code jeweils einen anderen der 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",
+ "Python behandelt Groß- und Kleinbuchstaben anders, als wir Menschen es tun würden. Alle Großbuchstaben kommen vor allen Kleinbuchstaben, so dass \n",
"\n",
"`Your word, Pineapple, comes before banana.` \n",
"\n",
@@ -795,7 +834,7 @@
"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: "
+ "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: "
]
},
{
@@ -826,7 +865,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 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",
+ "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",
"\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",
@@ -913,14 +952,22 @@
"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",
+ "([Fixing Problems](https://xkcd.com/1739/), Randall Munroe)\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",
"\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."
+ "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.\n",
+ "\n",
+ "\n",
+ "\n",
+ "([Max De Marzi](https://maxdemarzi.com/2014/03/23/caching-partial-traversals/))"
]
},
{
@@ -955,15 +1002,50 @@
"\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",
+ "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. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# probieren Sie hier einige der Methoden auf\n",
"\n",
+ "# ein Beispiel\n",
+ "\" Manchmal liest man einen Text ein und möchte überflüssige Leerzeichen entfernen. \".strip()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
"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",
"\n",
+ "([Strip Games](https://xkcd.com/696/), Randall Munroe)\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."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Rufen Sie hier die Methode count auf"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
"#### 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"
+ "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."
]
},
{
@@ -980,10 +1062,24 @@
"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",
+ "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."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Implementieren Sie hier die Variante von is_palindrome"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
"#### 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): "
@@ -996,6 +1092,8 @@
"outputs": [],
"source": [
"def any_lowercase1(s):\n",
+ " \"\"\" Fügen Sie hier den Kommentar für diese Funktion ein. \n",
+ " \"\"\"\n",
" for c in s:\n",
" if c.islower():\n",
" return True\n",
@@ -1024,7 +1122,11 @@
" for c in s:\n",
" if not c.islower():\n",
" return False\n",
- " return True"
+ " return True\n",
+ "\n",
+ "# Testen Sie hier am besten die Funktionen durch und fügen Sie dann \n",
+ "# oben zu jeder Funktion einen Kommentar hinzu, der erklärt, was die\n",
+ "# jeweilige Funktion wirklich tut."
]
},
{
@@ -1063,10 +1165,31 @@
"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",
+ "Denn `'c'` ist der 2. Buchstabe des Alphabets. Passen Sie aber auf: die Zahlenwerte für die Großbuchstaben sind anders."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Implementieren Sie hier die Funktion rotate_word"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "\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",
+ "\n",
+ "\n",
+ "([Rot13](https://imgur.com/gallery/T7BD6), vnznfyhg)\n",
+ "\n",
"(Musterlösung: http://thinkpython2.com/code/rotate.py)"
]
},
--
GitLab