From 6ea0412a58a4739696f47d5cbbe49b9cea979723 Mon Sep 17 00:00:00 2001
From: Michel Schwab <michel.schwab@hu-berlin.de>
Date: Wed, 12 Dec 2018 13:33:38 +0100
Subject: [PATCH] Seminar08 MB
---
notebooks/seminar08.ipynb | 161 +++++++++++++++++++++++++++++++++-----
1 file changed, 140 insertions(+), 21 deletions(-)
diff --git a/notebooks/seminar08.ipynb b/notebooks/seminar08.ipynb
index d618f11..c42aeec 100644
--- a/notebooks/seminar08.ipynb
+++ b/notebooks/seminar08.ipynb
@@ -4,13 +4,39 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "# Seminar Problemorientierte Programmierung\n",
+ "# Seminar Problemorientierte Programmierung"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## 8 Zeichenketten\n",
+ "[Chapter 8: Strings](http://greenteapress.com/thinkpython2/html/thinkpython2009.html)\n",
"\n",
- "## Exkurs: Was mir an Python gefällt\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",
"\n",
- "In dieser Rubrik, die immer am Anfang eines Kapitels steht, möchte ich Ihnen zeigen, wofür ich Python nutze und warum ich es mag. Sie werden vielleicht noch nicht verstehen, was ich genau mache, aber Sie sehen damit schon einmal die Möglichkeiten von Python und können später darauf zurückgreifen. Da dies auch ein Exkurs ist, können Sie diese Rubrik gerne auch erst einmal überspringen.\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",
- "Text-Statistik ist ganz einfach machbar - mit dem Wissen aus diesem Kapitel können wir z.B. n-Gramme berechnen. Hier ein Beispiel, welches automatisch eine Webseite herunterlädt und die häufigsten 6-Gramme berechnet. "
+ "- \n",
+ "- \n",
+ "- "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Exkurs: Was mir an Python gefällt\n",
+ "\n",
+ "Text-Statistik ist ganz einfach machbar - mit dem Wissen aus diesem Kapitel können wir z.B. n-Gramme berechnen. Vielleicht kommen Sie ja am Ende dieses Notebooks zu diesem Exkurs zurück. Hier ein Beispiel, welches automatisch eine Webseite herunterlädt und die häufigsten 6-Gramme berechnet. "
]
},
{
@@ -115,7 +141,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "Somit ist `b` der 0. Buchstabe von `banana`, `a` ist der 1. Buchstabe und `n` ist der 2. Buchstabe.\n",
+ "Somit ist `b` der 0. Buchstabe von `banana`, `a` ist der 1. Buchstabe und `n` der 2.\n",
"\n",
"Als Index können wir einen Ausdruck verwenden, der Variablen und Operatoren enthält:"
]
@@ -143,7 +169,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "Aber der Wert des Index muss eine ganze Zahl sein. Ansonsten erhalten wir eine Fehlermeldung:"
+ "Der Wert des Index muss eine ganze Zahl sein. Ansonsten erhalten wir eine Fehlermeldung:"
]
},
{
@@ -165,7 +191,7 @@
"\n",
"### 8.2 `len`\n",
"\n",
- "`len` ist eine eingebaute Funktion, die die Anzahl der Zeichen einer Zeichenkette zurückgibt:\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"
]
},
{
@@ -286,7 +312,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "Eine andere Möglichkeit einen Durchlauf zu schreiben ist mit Hilfe der `for`-Schleife:"
+ "Eine einfachere Möglichkeit einen Durchlauf zu schreiben ist mit Hilfe der `for`-Schleife:"
]
},
{
@@ -329,7 +355,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "Natürlich ist das nicht ganz korrekt, denn \"Ouack\" und \"Quack\" sind flasch geschrieben. Verändern Sie das Programm, um diesen Fehler zu beheben."
+ "Natürlich ist das nicht ganz korrekt, denn \"Ouack\" und \"Quack\" sind flasch geschrieben. Verändern Sie das Programm, um diesen Fehler zu beheben. *Hinweis: Hier muss eine Entscheidung getroffen und eine von zwei Möglichkeiten verwendet werden.*"
]
},
{
@@ -448,7 +474,7 @@
"source": [
"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:"
+ "Der Grund für den Fehler ist, dass Zeichenketten **unveränderbar** (*immutable*) sind. Das heisst, wir 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:"
]
},
{
@@ -499,9 +525,9 @@
"source": [
"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",
+ "Das ist das erste Mal, dass wir eine `return`-Anweisung innerhalb einer Schleife sehen und sie nicht \"nur\" in einer Verzweigung auftritt! Wenn `word[index] == letter` den boolschen Wert `True` zurückliefert, dann bricht die Funktion die Schleife ab und gibt direkt `index` zurück.\n",
"\n",
- "Wenn das Zeichen `letter` nicht in der Zeichenkette auftaucht, dann wird die Schleife ganz normal verlassen und es wird `-1` zurückgegeben.\n",
+ "Wenn das Zeichen `letter` nicht in der Zeichenkette auftaucht, wird die Schleife ganz normal verlassen und es wird `-1` zurückgegeben.\n",
"\n",
"Dieses Berechnungsmuster - eine Folge durchlaufen und zurückkehren, sobald wir gefunden haben, wonach wir suchen - wird **Suche** genannt.\n",
"\n",
@@ -514,7 +540,7 @@
"metadata": {},
"outputs": [],
"source": [
- "# Implementieren Sie hier die veränderte Funktion find"
+ "# Implementieren Sie hier die veränderte Funktion find\n"
]
},
{
@@ -548,9 +574,9 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "Das Program demonstriert ein anderes Berechnungsmuster, das **Zähler** (*counter*) genannt wird. Die Variabe `count` wird mit 0 initialisiert und dann jedesmall erhöht, wenn ein `a` gefunden wird. Wenn die Schleife beendet ist, dann enthält `count` das Ergebnis - die Gesamtzahl an `a`s.\n",
+ "Das Program demonstriert ein anderes Berechnungsmuster, das **Zähler** (*counter*) genannt wird. Die Variabe `count` wird mit 0 initialisiert und dann jedesmall erhöht, wenn ein `a` gefunden wird. Wenn die Schleife beendet ist, dann enthält `count` das Ergebnis - die Gesamtzahl an '`a`'s.\n",
"\n",
- "Verkapseln Sie den Code in einer Funktion mit Namen `count` und verallgemeinern Sie die Funktion, so dass sie die Zeichenkette und das gesuchte Zeichen als Parameter akzeptiert."
+ "Verkapseln Sie den Code in einer Funktion mit Namen `count` und verallgemeinern Sie die Funktion so, dass sie die Zeichenkette und das gesuchte Zeichen als Parameter erwartet."
]
},
{
@@ -593,7 +619,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 Methode `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. 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",
"Anstatt der Funktions-Syntax `upper(word)` nutzt die Methode jedoch die Syntax `word.upper()`:\n"
]
@@ -981,7 +1007,7 @@
"- Objekt:\n",
"- Folge:\n",
"- Element:\n",
- "- Index:\n",
+ "- Index: Der Index beschreibt die Position in einer Folge, an der eine Aktion ausgeführt wird. Das erste Indexelement ist fast immer `0`\n",
"- Segment:\n",
"- leere Zeichenkette:\n",
"- unveränderbar:\n",
@@ -1002,7 +1028,7 @@
"\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. "
+ "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"
]
},
{
@@ -1076,6 +1102,33 @@
"# Implementieren Sie hier die Variante von is_palindrome"
]
},
+ {
+ "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",
+ "\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."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def is_palindrome(s):\n",
+ " return s==s[::-1]\n",
+ "\n",
+ "\n",
+ "is_palindrome(\"AnnA\")"
+ ]
+ },
{
"cell_type": "markdown",
"metadata": {},
@@ -1124,18 +1177,37 @@
" return False\n",
" return True\n",
"\n",
+ "any_lowercase5 (\"Hallo\")\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."
]
},
+ {
+ "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",
+ " - lowercase1 prüft ob alle Zeichen Kleinbuchstaben sind.\n",
+ " - lowercase2 prüft ob `c`ein Kleinbuchstabe ist und gibt immer true -als string, nicht als boolscher Wert- zurück.\n",
+ " - lowercase3 prüft ob der letzte Buchstabe ein Kleinbuchstabe ist.\n",
+ " - lowercase4 prüft ob es Kleinbuchstaben gibt, diese Funktion macht das was sie soll.\n",
+ " - lowercase5 püft ob der erste Buchstabe ein Kleinbuchstabe ist. "
+ ]
+ },
{
"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",
+ "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",
@@ -1188,9 +1260,56 @@
"\n",
"\n",
"\n",
- "([Rot13](https://imgur.com/gallery/T7BD6), vnznfyhg)\n",
+ "([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",
- "(Musterlösung: http://thinkpython2.com/code/rotate.py)"
+ "\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,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def rotate_letter (s,n):\n",
+ " if s.isupper():\n",
+ " start= ord('A')\n",
+ " elif s.islower():\n",
+ " start=ord('a')\n",
+ " else:\n",
+ " return s\n",
+ " letter=ord(s)-start\n",
+ " new=(letter+n)%26+start\n",
+ " return chr(new)\n",
+ "\n",
+ "\n",
+ "def rotate_word(word,n):\n",
+ " neu=''\n",
+ " for letter in word:\n",
+ " neu=neu+rotate_letter(letter,n)\n",
+ " return neu\n",
+ " \n",
+ "rotate_word(\"cheer\",7)"
]
},
{
--
GitLab