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.
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.
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:
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:
-
-
-
-
-
-
%% Cell type:markdown id: tags:
%% Cell type:markdown id: tags:
## Exkurs: Was mir an Python gefällt
## Exkurs: Was mir an Python gefällt
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.
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 id: tags:
%% Cell type:code id: tags:
```
```
# klappt nur, wenn das Python-Modul BeautifulSoup installiert ist
# klappt nur, wenn das Python-Modul BeautifulSoup installiert ist
from collections import Counter
from collections import Counter
import requests
import requests
from bs4 import BeautifulSoup
from bs4 import BeautifulSoup
# wir wollen häufige n-Gramme finden - hier n anpassen
# wir wollen häufige n-Gramme finden - hier n anpassen
n = 6
n = 6
# sollte für jede beliebige Webseite funktionieren - hier anpassen
# sollte für jede beliebige Webseite funktionieren - hier anpassen
link = "https://de.wikipedia.org/w/index.php?title=Berlin&printable=yes"
link = "https://de.wikipedia.org/w/index.php?title=Berlin&printable=yes"
# Webseite herunterladen und Text extrahieren
# Webseite herunterladen und Text extrahieren
text = BeautifulSoup(requests.get(link).text, "lxml").get_text()
text = BeautifulSoup(requests.get(link).text, "lxml").get_text()
# n-Gramme zählen
# n-Gramme zählen
ctr = Counter()
ctr = Counter()
for i in range(0, len(text) - n + 1):
for i in range(0, len(text) - n + 1):
ngram = text[i:i+n]
ngram = text[i:i+n]
# Zeichenketten mit Leerzeichen ignorieren
# Zeichenketten mit Leerzeichen ignorieren
if ' ' not in ngram:
if ' ' not in ngram:
ctr[ngram] += 1
ctr[ngram] += 1
# die Top-10 ausgeben
# die Top-10 ausgeben
for ngram, frequ in ctr.most_common(10):
for ngram, frequ in ctr.most_common(10):
print(frequ, ngram, sep='\t')
print(frequ, ngram, sep='\t')
```
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id: tags:
## 8 Zeichenketten
## 8 Zeichenketten
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.
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.
Eine Zeichenkette ist eine Folge von Zeichen. Wir können auf die einzelnen Zeichen mit Hilfe des Klammer-Operators zugreifen:
Eine Zeichenkette ist eine Folge von Zeichen. Wir können auf die einzelnen Zeichen mit Hilfe des Klammer-Operators zugreifen:
%% Cell type:code id: tags:
%% Cell type:code id: tags:
```
```
fruit = 'banana'
fruit = 'banana'
letter = fruit[1]
letter = fruit[1]
```
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id: tags:
Die zweite Anweisung wählt das Zeichen mit Nummer 1 aus der Zeichenkette `fruit` und weist dieses der Variable `letter` zu.
Die zweite Anweisung wählt das Zeichen mit Nummer 1 aus der Zeichenkette `fruit` und weist dieses der Variable `letter` zu.
Der Ausdruck in eckigen Klammern wird **Index** genannt. Der Index gibt an, welches Zeichen der Folge wir haben möchten.
Der Ausdruck in eckigen Klammern wird **Index** genannt. Der Index gibt an, welches Zeichen der Folge wir haben möchten.
Allerdings entspricht das Ergebnis vielleicht nicht ganz dem, was wir erwartet hätten:
Allerdings entspricht das Ergebnis vielleicht nicht ganz dem, was wir erwartet hätten:
%% Cell type:code id: tags:
%% Cell type:code id: tags:
```
```
letter
letter
```
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id: tags:
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:
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 id: tags:
%% Cell type:code id: tags:
```
```
letter = fruit[0]
letter = fruit[0]
letter
letter
```
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id: tags:
Somit ist `b` der 0. Buchstabe von `banana`, `a` ist der 1. Buchstabe und `n` der 2.
Somit ist `b` der 0. Buchstabe von `banana`, `a` ist der 1. Buchstabe und `n` der 2.
Als Index können wir einen Ausdruck verwenden, der Variablen und Operatoren enthält:
Als Index können wir einen Ausdruck verwenden, der Variablen und Operatoren enthält:
%% Cell type:code id: tags:
%% Cell type:code id: tags:
```
```
i = 1
i = 1
fruit[i]
fruit[i]
```
```
%% Cell type:code id: tags:
%% Cell type:code id: tags:
```
```
fruit[i + 1]
fruit[i + 1]
```
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id: tags:
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:
`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:
`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:
%% Cell type:code id: tags:
%% Cell type:code id: tags:
```
```
fruit = "banana"
fruit = "banana"
len(fruit)
len(fruit)
```
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id: tags:
Um auf das letzte Zeichen einer Zeichenkette zuzugreifen, würden Sie vielleicht folgendes versuchen:
Um auf das letzte Zeichen einer Zeichenkette zuzugreifen, würden Sie vielleicht folgendes versuchen:
%% Cell type:code id: tags:
%% Cell type:code id: tags:
```
```
length = len(fruit)
length = len(fruit)
last = fruit[length]
last = fruit[length]
```
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id: tags:
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:
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 id: tags:
%% Cell type:code id: tags:
```
```
last = fruit[length - 1]
last = fruit[length - 1]
last
last
```
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id: tags:
Alternativ können wir einen negativen Index nutzen, der rückwärts vom Ende der Zeichenkette her zählt. Der Ausdruck `fruit[-1]` ergibt das letzte Zeichen, `fruit[-2]` das vorletzte Zeichen, usw.:
Alternativ können wir einen negativen Index nutzen, der rückwärts vom Ende der Zeichenkette her zählt. Der Ausdruck `fruit[-1]` ergibt das letzte Zeichen, `fruit[-2]` das vorletzte Zeichen, usw.:
%% Cell type:code id: tags:
%% Cell type:code id: tags:
```
```
fruit[-1]
fruit[-1]
```
```
%% Cell type:code id: tags:
%% Cell type:code id: tags:
```
```
fruit[-2]
fruit[-2]
```
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id: tags:
### 8.3 Durchlauf mit einer `for`-Schleife
### 8.3 Durchlauf mit einer `for`-Schleife
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:
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:
%% Cell type:code id: tags:
%% Cell type:code id: tags:
```
```
index = 0
index = 0
while index < len(fruit):
while index < len(fruit):
letter = fruit[index]
letter = fruit[index]
print(letter)
print(letter)
index = index + 1
index = index + 1
```
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id: tags:
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.
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.
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:
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 id: tags:
%% Cell type:code id: tags:
```
```
# Implementieren Sie hier die Funktion streawkceur
# Implementieren Sie hier die Funktion streawkceur
# Testaufruf
# Testaufruf
streawkceur("streawkceur")
streawkceur("streawkceur")
```
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id: tags:
Eine einfachere 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:
%% Cell type:code id: tags:
%% Cell type:code id: tags:
```
```
for letter in fruit:
for letter in fruit:
print(letter)
print(letter)
```
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id: tags:
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.
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.
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:
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 id: tags:
%% Cell type:code id: tags:
```
```
prefixes = 'JKLMNOPQ'
prefixes = 'JKLMNOPQ'
suffix = 'ack'
suffix = 'ack'
for letter in prefixes:
for letter in prefixes:
print(letter + suffix)
print(letter + suffix)
```
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id: tags:
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.*
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 id: tags:
%% Cell type:markdown id: tags:
### 8.4 Zeichenketten-Segmente
### 8.4 Zeichenketten-Segmente
Ein Teil einer Zeichenkette wird **Segment** (*slice*) gennannt. Ein Segment können wir ähnlich wie ein einzelnes Zeichen auswählen:
Ein Teil einer Zeichenkette wird **Segment** (*slice*) gennannt. Ein Segment können wir ähnlich wie ein einzelnes Zeichen auswählen:
%% Cell type:code id: tags:
%% Cell type:code id: tags:
```
```
s = 'Monty Python'
s = 'Monty Python'
s[0:5]
s[0:5]
```
```
%% Cell type:code id: tags:
%% Cell type:code id: tags:
```
```
s[6:12]
s[6:12]
```
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id: tags:
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:
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:
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:
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 id: tags:
%% Cell type:code id: tags:
```
```
fruit = 'banana'
fruit = 'banana'
fruit[:3]
fruit[:3]
```
```
%% Cell type:code id: tags:
%% Cell type:code id: tags:
```
```
fruit[3:]
fruit[3:]
```
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id: tags:
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:
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 id: tags:
%% Cell type:code id: tags:
```
```
fruit = 'banana'
fruit = 'banana'
fruit[3:3]
fruit[3:3]
```
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id: tags:
Eine leere Zeichenkette enthält keine Zeichen und hat die Länge 0. Ansonsten ist es aber eine ganz normale Zeichenkette.
Eine leere Zeichenkette enthält keine Zeichen und hat die Länge 0. Ansonsten ist es aber eine ganz normale Zeichenkette.
Um unser Beispiel fortzuführen: was meinen Sie, bedeutet `fruit[:]`? Probieren Sie es aus!
Um unser Beispiel fortzuführen: was meinen Sie, bedeutet `fruit[:]`? Probieren Sie es aus!
%% Cell type:code id: tags:
%% Cell type:code id: tags:
```
```
```
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id: tags:
### 8.5 Zeichenketten sind unveränderbar
### 8.5 Zeichenketten sind unveränderbar
Es ist verlockend, den `[]`-Operator auf der linken Seite einer Zuweisung zu verwenden, um ein Zeichen innerhalb einer Zeichenkette zu verändern. Beispielsweise:
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 id: tags:
%% Cell type:code id: tags:
```
```
greeting = 'hello World!'
greeting = 'hello World!'
greeting[0] = 'H'
greeting[0] = 'H'
```
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id: tags:
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.
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.
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:
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 id: tags:
%% Cell type:code id: tags:
```
```
greeting = "hello World!"
greeting = "hello World!"
new_greeting = "H" + greeting[1:]
new_greeting = "H" + greeting[1:]
new_greeting
new_greeting
```
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id: tags:
In diesem Beispiel wird ein neuer Anfangsbuchstabe mit einem Segment von `greeting` zusammengefügt. Die ursprüngliche Zeichenkette verändert sich dadurch nicht.
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 id: tags:
%% Cell type:markdown id: tags:
### 8.6 Suche
### 8.6 Suche
Was macht die folgende Funktion? Probieren Sie es aus!
Was macht die folgende Funktion? Probieren Sie es aus!
%% Cell type:code id: tags:
%% Cell type:code id: tags:
```
```
def find(word, letter):
def find(word, letter):
index = 0
index = 0
while index < len(word):
while index < len(word):
if word[index] == letter:
if word[index] == letter:
return index
return index
index = index + 1
index = index + 1
return -1
return -1
```
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id: tags:
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.
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.
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.
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.
Wenn das Zeichen `letter` nicht in der Zeichenkette auftaucht, wird die Schleife ganz normal verlassen und es wird `-1` zurückgegeben.
Wenn das Zeichen `letter` nicht in der Zeichenkette auftaucht, wird die Schleife ganz normal verlassen und es wird `-1` zurückgegeben.
Dieses Berechnungsmuster - eine Folge durchlaufen und zurückkehren, sobald wir gefunden haben, wonach wir suchen - wird **Suche** genannt.
Dieses Berechnungsmuster - eine Folge durchlaufen und zurückkehren, sobald wir gefunden haben, wonach wir suchen - wird **Suche** genannt.
Verändern Sie `find` so, dass es einen dritten Parameter hat, der den Index in `word` angibt, ab dem gesucht werden soll.
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 id: tags:
%% Cell type:code id: tags:
```
```
# Implementieren Sie hier die veränderte Funktion find
# Implementieren Sie hier die veränderte Funktion find
```
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id: tags:
Das folgende Programm zählt wie häufig der Buchstabe `a` in einer Zeichenkette auftaucht:
Das folgende Programm zählt wie häufig der Buchstabe `a` in einer Zeichenkette auftaucht:
%% Cell type:code id: tags:
%% Cell type:code id: tags:
```
```
word = 'banana'
word = 'banana'
count = 0
count = 0
for letter in word:
for letter in word:
if letter == 'a':
if letter == 'a':
count = count + 1
count = count + 1
print(count)
print(count)
```
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id: tags:
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.
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.
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.
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 id: tags:
%% Cell type:code id: tags:
```
```
# Implementieren Sie hier die Funktion count
# Implementieren Sie hier die Funktion count
```
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id: tags:
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 id: tags:
%% Cell type:code id: tags:
```
```
# Implementieren Sie hier die umgeschriebene Variante der Funktion
# Implementieren Sie hier die umgeschriebene Variante der Funktion
```
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id: tags:
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.
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.
Anstatt der Funktions-Syntax `upper(word)` nutzt die Methode jedoch die Syntax `word.upper()`:
Anstatt der Funktions-Syntax `upper(word)` nutzt die Methode jedoch die Syntax `word.upper()`:
%% Cell type:code id: tags:
%% Cell type:code id: tags:
```
```
word = 'banana'
word = 'banana'
new_word = word.upper()
new_word = word.upper()
new_word
new_word
```
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id: tags:
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.
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.
Dies wird **Aufruf** (*invocation*) der Methode genannt. In diesem Beispiel würden wir sagen, dass wir `upper` auf `word` aufrufen.
Dies wird **Aufruf** (*invocation*) der Methode genannt. In diesem Beispiel würden wir sagen, dass wir `upper` auf `word` aufrufen.
Wie sich herausstellt, gibt es eine Zeichenketten-Methode namens `find`, die sehr ähnlich zu der Funktion ist, die wir geschrieben haben:
Wie sich herausstellt, gibt es eine Zeichenketten-Methode namens `find`, die sehr ähnlich zu der Funktion ist, die wir geschrieben haben:
%% Cell type:code id: tags:
%% Cell type:code id: tags:
```
```
word = 'banana'
word = 'banana'
index = word.find('a')
index = word.find('a')
index
index
```
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id: tags:
In diesem Beispiel rufen wir `find` auf `word` auf und reichen den Buchstaben, den wir suchen, als Argument an `find` weiter.
In diesem Beispiel rufen wir `find` auf `word` auf und reichen den Buchstaben, den wir suchen, als Argument an `find` weiter.
Tatsächlich ist die `find`-Methode allgemeiner als unsere Funktion, denn sie kann auch Teilzeichenketten finden, nicht nur einzelne Zeichen:
Tatsächlich ist die `find`-Methode allgemeiner als unsere Funktion, denn sie kann auch Teilzeichenketten finden, nicht nur einzelne Zeichen:
%% Cell type:code id: tags:
%% Cell type:code id: tags:
```
```
word.find('na')
word.find('na')
```
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id: tags:
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:
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 id: tags:
%% Cell type:code id: tags:
```
```
word.find('na', 3)
word.find('na', 3)
```
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id: tags:
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:
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 id: tags:
%% Cell type:code id: tags:
```
```
name = 'bob'
name = 'bob'
name.find('b', 1, 2)
name.find('b', 1, 2)
```
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id: tags:
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.
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 id: tags:
%% Cell type:markdown id: tags:
### 8.9 Der `in`-Operator
### 8.9 Der `in`-Operator
Das Wort `in` ist ein Boolescher Operator, der zwei Zeichenketten erwartet und `True` zurückgibt, wenn die erste Zeichenkette eine Teilzeichenkette der zweiten ist:
Das Wort `in` ist ein Boolescher Operator, der zwei Zeichenketten erwartet und `True` zurückgibt, wenn die erste Zeichenkette eine Teilzeichenkette der zweiten ist:
%% Cell type:code id: tags:
%% Cell type:code id: tags:
```
```
'a' in 'banana'
'a' in 'banana'
```
```
%% Cell type:code id: tags:
%% Cell type:code id: tags:
```
```
'seed' in 'banana'
'seed' in 'banana'
```
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id: tags:
Beispielsweise gibt die folgende Funktion alle Buchstaben von `word1` aus, die auch in `word2` enthalten sind:
Beispielsweise gibt die folgende Funktion alle Buchstaben von `word1` aus, die auch in `word2` enthalten sind:
%% Cell type:code id: tags:
%% Cell type:code id: tags:
```
```
def in_both(word1, word2):
def in_both(word1, word2):
for letter in word1:
for letter in word1:
if letter in word2:
if letter in word2:
print(letter)
print(letter)
```
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id: tags:
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."*
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."*
Hier ist das was passiert, wenn wir Äpfel mit Birnen vergleichen:
Hier ist das was passiert, wenn wir Äpfel mit Birnen vergleichen:
%% Cell type:code id: tags:
%% Cell type:code id: tags:
```
```
in_both("Äpfel", "Birnen")
in_both("Äpfel", "Birnen")
```
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id: tags:
Die Vergleichs-Operatoren funktionieren auch mit Zeichenketten. Um zu prüfen, ob zwei Zeichenketten gleich sind, können wir einfach folgendes machen:
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 id: tags:
%% Cell type:code id: tags:
```
```
if word == 'banana':
if word == 'banana':
print("All right, bananas.")
print("All right, bananas.")
```
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id: tags:
Andere Vergleichsoperatoren sind nützlich, um Wörter alphabetisch zu ordnen:
Andere Vergleichsoperatoren sind nützlich, um Wörter alphabetisch zu ordnen:
%% Cell type:code id: tags:
%% Cell type:code id: tags:
```
```
if word < 'banana':
if word < 'banana':
print('Your word, ' + word + ', comes before banana.')
print('Your word, ' + word + ', comes before banana.')
elif word > 'banana':
elif word > 'banana':
print('Your word, ' + word + ', comes after banana.')
print('Your word, ' + word + ', comes after banana.')
else:
else:
print('All right, bananas.')
print('All right, bananas.')
```
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id: tags:
Passen Sie den Wert von `word` an, so dass der obige Code jeweils einen anderen der drei verschiedenen Texte ausgibt.
Passen Sie den Wert von `word` an, so dass der obige Code jeweils einen anderen der drei verschiedenen Texte ausgibt.
Python behandelt Groß- und Kleinbuchstaben anders, als wir Menschen es tun würden. Alle Großbuchstaben kommen vor allen Kleinbuchstaben, so dass
Python behandelt Groß- und Kleinbuchstaben anders, als wir Menschen es tun würden. Alle Großbuchstaben kommen vor allen Kleinbuchstaben, so dass
`Your word, Pineapple, comes before banana.`
`Your word, Pineapple, comes before banana.`
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.
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.
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:
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 id: tags:
%% Cell type:code id: tags:
```
```
'älter' < 'bald'
'älter' < 'bald'
```
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id: tags:
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.)
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 id: tags:
%% Cell type:markdown id: tags:
### 8.11 Debugging
### 8.11 Debugging
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:
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:
%% Cell type:code id: tags:
%% Cell type:code id: tags:
```
```
def is_reverse(word1, word2):
def is_reverse(word1, word2):
if len(word1) != len(word2):
if len(word1) != len(word2):
return False
return False
i = 0
i = 0
j = len(word2)
j = len(word2)
while j > 0:
while j > 0:
if word1[i] != word2[j]:
if word1[i] != word2[j]:
return False
return False
i = i+1
i = i+1
j = j-1
j = j-1
return True
return True
```
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id: tags:
Leider enthält die Funktion einen Fehler.
Leider enthält die Funktion einen Fehler.
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).
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).
`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.
`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.
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`:
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 id: tags:
%% Cell type:code id: tags:
```
```
is_reverse("pots", "stop")
is_reverse("pots", "stop")
```
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id: tags:
Eine sinnvolle Möglichkeit, solche Fehler zu debuggen, ist, sich die Werte der Indizes direkt vor der Stelle auszugeben, an der der Fehler auftritt:
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 id: tags:
%% Cell type:code id: tags:
```
```
def is_reverse(word1, word2):
def is_reverse(word1, word2):
if len(word1) != len(word2):
if len(word1) != len(word2):
return False
return False
i = 0
i = 0
j = len(word2)
j = len(word2)
while j > 0:
while j > 0:
print(i,j) # for debugging
print(i,j) # for debugging
if word1[i] != word2[j]:
if word1[i] != word2[j]:
return False
return False
i = i+1
i = i+1
j = j-1
j = j-1
return True
return True
```
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id: tags:
Wenn wir jetzt das Programm starten, erhalten wir mehr Information:
Wenn wir jetzt das Programm starten, erhalten wir mehr Information:
%% Cell type:code id: tags:
%% Cell type:code id: tags:
```
```
is_reverse("pots", "stop")
is_reverse("pots", "stop")
```
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id: tags:
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.
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.
Wenn wir den Fehler beheben und das Programm nochmal starten, erhalten wir:
Wenn wir den Fehler beheben und das Programm nochmal starten, erhalten wir:
%% Cell type:code id: tags:
%% Cell type:code id: tags:
```
```
is_reverse("pots", "stop")
is_reverse("pots", "stop")
```
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id: tags:
(Beheben Sie den Fehler und probieren Sie es aus!)
(Beheben Sie den Fehler und probieren Sie es aus!)
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:
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:
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.
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.
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.
([Max De Marzi](https://maxdemarzi.com/2014/03/23/caching-partial-traversals/))
([Max De Marzi](https://maxdemarzi.com/2014/03/23/caching-partial-traversals/))
%% Cell type:markdown id: tags:
%% Cell type:markdown id: tags:
### 8.12 Glossar
### 8.12 Glossar
Legen wir uns eine Liste mit den wichtigsten Begriffen an, die wir im Kapitel 8 gelernt haben:
Legen wir uns eine Liste mit den wichtigsten Begriffen an, die wir im Kapitel 8 gelernt haben:
- Objekt:
- Objekt:
- Folge:
- Folge:
- Element:
- Element:
- Index: Der Index beschreibt die Position in einer Folge, an der eine Aktion ausgeführt wird. Das erste Indexelement ist fast immer `0`
- Index: Der Index beschreibt die Position in einer Folge, an der eine Aktion ausgeführt wird. Das erste Indexelement ist fast immer `0`
- Segment:
- Segment:
- leere Zeichenkette:
- leere Zeichenkette:
- unveränderbar:
- unveränderbar:
- Durchlauf:
- Durchlauf:
- Suche:
- Suche:
- Zähler:
- Zähler:
- Aufruf:
- Aufruf:
- optionales Argument:
- optionales Argument:
Ergänzen Sie die Liste in eigenen Worten. Das ist eine gute Erinnerungs- und Übungsmöglichkeit.
Ergänzen Sie die Liste in eigenen Worten. Das ist eine gute Erinnerungs- und Übungsmöglichkeit.
%% Cell type:markdown id: tags:
%% Cell type:markdown id: tags:
### 8.13 Übung
### 8.13 Übung
#### Aufgabe 1
#### Aufgabe 1
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.
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.
%% Cell type:code id: tags:
%% Cell type:code id: tags:
```
```
# probieren Sie hier einige der Methoden auf
# probieren Sie hier einige der Methoden auf
# ein Beispiel
# ein Beispiel
" Manchmal liest man einen Text ein und möchte überflüssige Leerzeichen entfernen. ".strip()
" Manchmal liest man einen Text ein und möchte überflüssige Leerzeichen entfernen. ".strip()
```
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id: tags:
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.
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.
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.
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 id: tags:
%% Cell type:code id: tags:
```
```
# Rufen Sie hier die Methode count auf
# Rufen Sie hier die Methode count auf
```
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id: tags:
#### Aufgabe 3
#### Aufgabe 3
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.
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 id: tags:
%% Cell type:code id: tags:
```
```
fruit = 'banana'
fruit = 'banana'
fruit[0:5:2]
fruit[0:5:2]
```
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id: tags:
Eine Schrittweite von -1 durchläuft das Wort rückwärts, so dass das Segment `[::-1]` eine umgekehrte Zeichenkette erzeugt.
Eine Schrittweite von -1 durchläuft das Wort rückwärts, so dass das Segment `[::-1]` eine umgekehrte Zeichenkette erzeugt.
Nutzen Sie diese Möglichkeit, um eine einzeilige Variante von `is_palindrome` aus der [3. Aufgabe von Kapitel 6](seminar06.ipynb#Aufgabe-3) zu schreiben.
Nutzen Sie diese Möglichkeit, um eine einzeilige Variante von `is_palindrome` aus der [3. Aufgabe von Kapitel 6](seminar06.ipynb#Aufgabe-3) zu schreiben.
%% Cell type:code id: tags:
%% Cell type:code id: tags:
```
```
# Implementieren Sie hier die Variante von is_palindrome
# Implementieren Sie hier die Variante von is_palindrome
1. Schreiben Sie wie immer erst den Funktionskopf.
1. Schreiben Sie wie immer erst den Funktionskopf.
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.
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 id: tags:
%% Cell type:code id: tags:
```
```
def is_palindrome(s):
def is_palindrome(s):
return s==s[::-1]
return s==s[::-1]
is_palindrome("AnnA")
is_palindrome("AnnA")
```
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id: tags:
#### Aufgabe 4
#### Aufgabe 4
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):
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 id: tags:
%% Cell type:code id: tags:
```
```
def any_lowercase1(s):
def any_lowercase1(s):
""" Fügen Sie hier den Kommentar für diese Funktion ein.
""" Fügen Sie hier den Kommentar für diese Funktion ein.
"""
"""
for c in s:
for c in s:
if c.islower():
if c.islower():
return True
return True
else:
else:
return False
return False
def any_lowercase2(s):
def any_lowercase2(s):
for c in s:
for c in s:
if 'c'.islower():
if 'c'.islower():
return 'True'
return 'True'
else:
else:
return 'False'
return 'False'
def any_lowercase3(s):
def any_lowercase3(s):
for c in s:
for c in s:
flag = c.islower()
flag = c.islower()
return flag
return flag
def any_lowercase4(s):
def any_lowercase4(s):
flag = False
flag = False
for c in s:
for c in s:
flag = flag or c.islower()
flag = flag or c.islower()
return flag
return flag
def any_lowercase5(s):
def any_lowercase5(s):
for c in s:
for c in s:
if not c.islower():
if not c.islower():
return False
return False
return True
return True
any_lowercase5("aaaH")
any_lowercase5("aaaH")
# Testen Sie hier am besten die Funktionen durch und fügen Sie dann
# Testen Sie hier am besten die Funktionen durch und fügen Sie dann
# oben zu jeder Funktion einen Kommentar hinzu, der erklärt, was die
# oben zu jeder Funktion einen Kommentar hinzu, der erklärt, was die
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!
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!
- lowercase1 prüft, ob das erste Zeichen der Zeichenkette ein Kleinbuchstaben ist.
- lowercase1 prüft, ob das erste Zeichen der Zeichenkette ein Kleinbuchstaben ist.
- lowercase2 prüft, ob die Zeichenkette `c`ein Kleinbuchstabe ist und gibt immer True - als string, nicht als boolscher Wert - zurück.
- lowercase2 prüft, ob die Zeichenkette `c`ein Kleinbuchstabe ist und gibt immer True - als string, nicht als boolscher Wert - zurück.
- lowercase3 prüft, ob der letzte Buchstabe ein Kleinbuchstabe ist.
- lowercase3 prüft, ob der letzte Buchstabe ein Kleinbuchstabe ist.
- lowercase4 prüft, ob es Kleinbuchstaben gibt, diese Funktion macht das was sie soll.
- lowercase4 prüft, ob es Kleinbuchstaben gibt, diese Funktion macht das was sie soll.
- lowercase5 prüft, ob die Zeichenkette nur aus Kleinbuchstaben besteht
- lowercase5 prüft, ob die Zeichenkette nur aus Kleinbuchstaben besteht
%% Cell type:markdown id: tags:
%% Cell type:markdown id: tags:
#### Aufgabe 6
#### Aufgabe 6
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'.
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'.
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.
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.
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.
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.
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:
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:
%% Cell type:code id: tags:
%% Cell type:code id: tags:
```
```
ord('c') - ord('a')
ord('c') - ord('a')
```
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id: tags:
Denn `'c'` ist der 2. Buchstabe des Alphabets. Passen Sie aber auf: die Zahlenwerte für die Großbuchstaben sind anders.
Denn `'c'` ist der 2. Buchstabe des Alphabets. Passen Sie aber auf: die Zahlenwerte für die Großbuchstaben sind anders.
%% Cell type:code id: tags:
%% Cell type:code id: tags:
```
```
# Implementieren Sie hier die Funktion rotate_word
# Implementieren Sie hier die Funktion rotate_word
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.
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.
1. Schreiben Sie das Grundgerüst für `rotate_word()`, dieses braucht einzugebende Argumente und muss am Ende einen String zurückgeben.
1. Schreiben Sie das Grundgerüst für `rotate_word()`, dieses braucht einzugebende Argumente und muss am Ende einen String zurückgeben.
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.
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.
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.
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.
3. Zum Prüfen können Sie eine `if`- Anweisung verwenden. Stellen Sie sicher, dass alle Eingabefälle abgedeckt sind.
3. Zum Prüfen können Sie eine `if`- Anweisung verwenden. Stellen Sie sicher, dass alle Eingabefälle abgedeckt sind.
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.
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.
5. Berechnen Sie die Position im Alphabet indem Sie diesen Startwert von dem Wert des eingegebenen Buchstaben abziehen.
5. Berechnen Sie die Position im Alphabet indem Sie diesen Startwert von dem Wert des eingegebenen Buchstaben abziehen.
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.
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.
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.
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.
8. Sie fangen mit einer leeren Zeichenkette an. Dann durchlaufen Sie das eingegebene Wort Buchstabe für Buchstabe.
8. Sie fangen mit einer leeren Zeichenkette an. Dann durchlaufen Sie das eingegebene Wort Buchstabe für Buchstabe.
9. Schreiben Sie dafür eine `for`-Schleife.
9. Schreiben Sie dafür eine `for`-Schleife.
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.
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.
11. Nach Verlassen der Schleife wird das neue Wort ausgegeben.
11. Nach Verlassen der Schleife wird das neue Wort ausgegeben.
%% Cell type:code id: tags:
%% Cell type:code id: tags:
```
```
def rotate_letter (s,n):
def rotate_letter (s,n):
if s.isupper():
if s.isupper():
start= ord('A')
start= ord('A')
print(start)
elif s.islower():
elif s.islower():
start=ord('a')
start=ord('a')
print(start)
else:
else:
return s
return s
letter=ord(s)-start
letter=ord(s)-start
print(letter)
new=(letter+n)%26+start
new=(letter+n)%26+start
print(new)
return chr(new)
return chr(new)
def rotate_word(word,n):
def rotate_word(word,n):
neu=''
neu=''
for letter in word:
for letter in word:
neu=neu+rotate_letter(letter,n)
neu=neu+rotate_letter(letter,n)
return neu
return neu
rotate_word("ab",7)
rotate_word("cheer",7)
```
```
%% Cell type:markdown id: tags:
%% Cell type:markdown id: tags:
 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/).
 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/).
