Newer
Older
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"[Chapter 8: Strings](http://greenteapress.com/thinkpython2/html/thinkpython2009.html)\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",
"[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",
"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",
"- \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. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# 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')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"Eine Zeichenkette ist eine Folge von Zeichen. Wir können auf die einzelnen Zeichen mit Hilfe des Klammer-Operators zugreifen:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"fruit = 'banana'\n",
"letter = fruit[1]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Die zweite Anweisung wählt das Zeichen mit Nummer 1 aus der Zeichenkette `fruit` und weist dieses der Variablen `letter` zu.\n",
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
"\n",
"Der Ausdruck in eckigen Klammern wird **Index** genannt. Der Index gibt an, welches Zeichen der Folge wir haben möchten.\n",
"\n",
"Allerdings entspricht das Ergebnis vielleicht nicht ganz dem, was wir erwartet hätten: "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"letter"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Für die meisten Menschen ist der erste Buchstabe von `banana` das `b` und nicht das `a`. Aber in der Informatik wird oft beginnend mit der Null gezählt und somit hat das erste Zeichen einer Zeichenkette den Index 0:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"letter = fruit[0]\n",
"letter"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Somit ist `b` der 0. Buchstabe von `banana`, `a` ist der 1. Buchstabe und `n` der 2.\n",
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
"\n",
"Als Index können wir einen Ausdruck verwenden, der Variablen und Operatoren enthält:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"i = 1\n",
"fruit[i]"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"fruit[i + 1]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Der Wert des Index muss eine ganze Zahl sein. Ansonsten erhalten wir eine Fehlermeldung:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"letter = fruit[1.5]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"\n",
"([Evan-Amos](https://commons.wikimedia.org/wiki/File:Banana-Single.jpg))\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"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Um auf das letzte Zeichen einer Zeichenkette zuzugreifen, würden Sie vielleicht folgendes versuchen: "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"length = len(fruit)\n",
"last = fruit[length]"
]
},
{
"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 extrahieren, müssen wir 1 von `length` abziehen: "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"last = fruit[length - 1]\n",
"last"
]
},
{
"Alternativ können wir einen negativen Index nutzen, der rückwärts vom Ende der Zeichenkette an zählt. Der Ausdruck `fruit[-1]` ergibt das letzte Zeichen, `fruit[-2]` das vorletzte Zeichen, usw.:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"fruit[-1]"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"fruit[-2]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"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",
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"index = 0\n",
"while index < len(fruit):\n",
" letter = fruit[index]\n",
" print(letter)\n",
" index = index + 1\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Diese Schleife durchläuft die Zeichenkette und gibt jedes Zeichen in einer eigenen Zeile aus. Die Schleifenbedingung ist `index < len(fruit)`, so dass, sobald `index` gleich der Länge der Zeichenkette ist, die Bedingung nicht mehr erfüllt ist und die Schleife abgebrochen wird. Das letzte Zeichen, auf das zugegriffen wird, ist das mit dem Index `len(fruit)-1`, welches auch das letzte Zeichen der Zeichenkette ist.\n",
"\n",
"Schreiben Sie als Übung eine Funktion `streawkceur`, die eine Zeichenkette als Argument erwartet und die Buchstaben rückwärts anzeigt, mit einem Buchstaben pro Zeile:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Implementieren Sie hier die Funktion streawkceur\n",
"\n",
"# Testaufruf\n",
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Eine einfachere Möglichkeit einen Durchlauf zu schreiben ist mit Hilfe der `for`-Schleife:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"for letter in fruit:\n",
" print(letter)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"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",
"\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: "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"prefixes = 'JKLMNOPQ'\n",
"suffix = 'ack'\n",
"\n",
"for letter in prefixes:\n",
" print(letter + suffix)"
]
},
{
"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. *Hinweis: Hier muss eine Entscheidung getroffen und eine von zwei Möglichkeiten verwendet werden.*"
{
"cell_type": "markdown",
"metadata": {},
"source": [
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
"\n",
"Ein Teil einer Zeichenkette wird **Segment** (*slice*) gennannt. Ein Segment können wir ähnlich wie ein einzelnes Zeichen auswählen:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"s = 'Monty Python'\n",
"s[0:5]"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"s[6:12]"
]
},
{
"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 Indizes (Mehrzahl von Index) *zwischen* die Zeichen zeigen, wie in der folgenden Abbildung dargestellt:\n",
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
"\n",
"\n",
"\n",
"Wenn wir den ersten Index (vor dem Doppelpunkt) weglassen, beginnt das Segment mit dem ersten Zeichen der Zeichenkette. Wenn wir den zweiten Index weglassen, endet das Segment mit dem letzten Zeichen der Zeichenkette:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"fruit = 'banana'\n",
"fruit[:3]"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"fruit[3:]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Wenn der erste Index größer oder gleich dem zweiten ist, dann ist das Ergebnis die **leere Zeichenkette** (*empty string*), die durch zwei Anführungszeichen (mit nichts dazwischen) repräsentiert wird:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"fruit = 'banana'\n",
"fruit[3:3]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Eine leere Zeichenkette enthält keine Zeichen und hat die Länge 0. Ansonsten ist es aber eine ganz normale Zeichenkette.\n",
"\n",
"Um unser Beispiel fortzuführen: was meinen Sie, bedeutet `fruit[:]`? Probieren Sie es aus!"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"Es ist verlockend, den `[]`-Operator auf der linken Seite einer Zuweisung zu verwenden, um ein Zeichen innerhalb einer Zeichenkette zu verändern. Beispielsweise:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"greeting = 'hello World!'\n",
"greeting[0] = 'H'"
]
},
{
"cell_type": "markdown",
"metadata": {},
"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",
"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:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"greeting = \"hello World!\"\n",
"new_greeting = \"H\" + greeting[1:]\n",
"new_greeting"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"In diesem Beispiel wird ein neuer Anfangsbuchstabe mit einem Segment von `greeting` zusammengefügt. Die ursprüngliche Zeichenkette verändert sich dadurch nicht."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"Was macht die folgende Funktion? Probieren Sie es aus!\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def find(word, letter):\n",
" index = 0\n",
" while index < len(word):\n",
" if word[index] == letter:\n",
" return index\n",
" index = index + 1\n",
" return -1\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Auf gewisse Weise ist `find` die Inversion 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, gibt die Funktion `-1` 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",
"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",
"Verändern Sie `find` so, dass es einen dritten Parameter hat, der den Index in `word` angibt, ab dem gesucht werden soll. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Implementieren Sie hier die veränderte Funktion find\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"\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",
"Das folgende Programm zählt wie häufig der Buchstabe `a` in einer Zeichenkette auftaucht:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"word = 'banana'\n",
"count = 0\n",
"for letter in word:\n",
" if letter == 'a':\n",
" count = count + 1\n",
"print(count)"
]
},
{
"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",
"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."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Implementieren Sie hier die Funktion count"
]
},
{
"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."
]
},
{
"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, [Erklärung des Comics](https://www.explainxkcd.com/wiki/index.php/764:_One_Two) falls Sie mehr lernen wollen)"
{
"cell_type": "markdown",
"metadata": {},
"source": [
"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"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
"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 Index sucht, das Zeichen an dessen Stelle aber nicht mit einschliesst, arbeitet es konsistent zum Segment-Operator."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"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"
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
]
},
{
"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": [
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"\n",
"([Fuck Grapefruit](https://xkcd.com/388/), Randall Munroe)\n",
"\n",
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
"### 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 jeweils einen anderen der drei verschiedenen Texte ausgibt.\n",
"Python behandelt Groß- und Kleinbuchstaben anders, als wir Menschen es tun würden. Alle Großbuchstaben kommen vor allen Kleinbuchstaben, sodass \n",
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
"\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": [
"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: "
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
]
},
{
"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 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",
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
"\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",
"\n",
"\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",
"\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.\n",
"\n",
"\n",
"\n",
"([Max De Marzi](https://maxdemarzi.com/2014/03/23/caching-partial-traversals/))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\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: 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",
"- 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": [
"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"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# probieren Sie hier einige der Methoden auf\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",
"\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",
"### 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."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Rufen Sie hier die Methode count auf"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"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."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"fruit = 'banana'\n",
"fruit[0:5:2]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Eine Schrittweite von -1 durchläuft das Wort rückwärts, so dass das Segment `[::-1]` eine umgekehrte Zeichenkette erzeugt.\n",
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
"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"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# 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",
]
},
{
"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": {},
"source": [
"\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",
" \"\"\" Fügen Sie hier den Kommentar für diese Funktion ein. \n",
" \"\"\"\n",
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
" 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",
"# 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": [
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
"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": [
"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; [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",
"\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": [
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
"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>"
]
},
{
"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",
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
"([Rot13](https://imgur.com/gallery/T7BD6), vnznfyhg)\n"
]
},
{
"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)"
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
{
"cell_type": "markdown",
"metadata": {},
"source": [
" Speichern Sie dieses Notebook, so dass Ihre Änderungen nicht verlorengehen (nicht auf einem Pool-Rechner). Klicken Sie dazu oben links auf das Disketten-Icon und nutzen Sie beispielsweise einen USB-Stick, E-Mail, Google Drive, Dropbox oder Ihre [HU-Box](https://box.hu-berlin.de/). "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"\n",
"Herzlichen Glückwunsch! Sie haben das 8. Kapitel geschafft. Weiter geht es in [9: Wortspiele](seminar09.ipynb)."
]
}
],
"metadata": {
"language_info": {
"name": "python",
"pygments_lexer": "ipython3"
}
},
"nbformat": 4,
"nbformat_minor": 2
}