"In dieser Rubrik, die immer am Anfang eines Kapitels steht, möchte ich Ihnen zeigen, wofür ich Python nutze und warum ich es mag. Sie werden vielleicht noch nicht verstehen, was ich genau mache, aber Sie sehen damit schon einmal die Möglichkeiten von Python und können später darauf zurückgreifen. Da dies auch ein Exkurs ist, können Sie diese Rubrik gerne auch erst einmal überspringen.\n",
"\n",
"Mit den Operatoren aus diesem Kapitel können wir ganz leicht das Verfahren zur Umwandlung einer Dezimalzahl in ihre Binärdarstellung implementieren:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"pass"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 8 Zeichenketten\n",
"\n",
"Zeichenketten sind anders als ganze Zahlen, Gleitkommazahlen und Boolesche Werte. Eine Zeichenkette ist eine **Folge** (*sequence*), d.h. eine geordnete Menge einzelner Werte. In diesem Kapitel lernen wir, wie wir die Zeichen zugreifen können, aus denen eine Zeichenkette besteht und wir lernen einige der Funktionen kennn, die für Zeichenketten bereitgestellt werden.\n",
"\n",
"### 8.1 Eine Zeichenkette ist eine Folge\n",
"\n",
"Eine Zeichenkette ist eine Folge von Zeichen. Wir können auf die einzelnen Zeichen mit Hilfe des Klammer-Operators zugreifen:"
]
},
{
"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 Variable `letter` zu.\n",
"\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` ist der 2. Buchstabe.\n",
"\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": [
"Aber 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": [
"### 8.2 `len`\n",
"\n",
"`len` ist eine eingebaute Funktion, die die Anzahl der Zeichen einer Zeichenkette zurückgibt:\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"fruit = \"banana\"\n",
"len(fruit)"
]
},
{
"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 extrahierren, müssen wir 1 von `length` abziehen: "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"last = fruit[length - 1]\n",
"last"
]
},
{
"cell_type": "raw",
"metadata": {},
"source": [
"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",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"fruit[-1]"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"fruit[-2]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 8.3 Durchlauf mit einer `for`-Schleife\n",
"\n",
"In vielen Berechnungen müsen wir eine Zeichenkette Zeichen für Zeichen verarbeiten. Oftmals beginnen wir mit dem ersten Zeichen und wählen dann in jedem Schritt das nächste Zeichen aus, machen etwas damit und fahren fort bis zum Ende der Zeichenkette. Diese Art von Prozess wird **Durchlauf** (*traversal*) genannt. Eine Möglichkeit einen Durchlauf zu programmieren, ist mit Hilfe einer `while`-Schleife:\n",
"\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",
"\n",
"# Testaufruf\n",
"print(streawkceur(\"streawkceur\"))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Eine andere 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",
"Im folgenden Beispiel sehen wir, wie die Zeichenkettenverknüpfung und eine `for`-Schleife verwendet werden, um eine ABC-Schützen-Folge (sortierte Folge) zu erzeugen. In Robert McCloskeys Buch \"Make Way for Ducklings\", sind die Namen der Entenkücken *Jack, Kack, Lack, Mack, Nack, Ouack, Pack* und *Quack*. Die Schleife gibt die Namen in dieser Reihenfolge aus: "
]
},
{
"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."
]
},
{
"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/). "
"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
}
%% Cell type:markdown id: tags:
# Seminar Problemorientierte Programmierung
## Exkurs: Was mir an Python gefällt
In dieser Rubrik, die immer am Anfang eines Kapitels steht, möchte ich Ihnen zeigen, wofür ich Python nutze und warum ich es mag. Sie werden vielleicht noch nicht verstehen, was ich genau mache, aber Sie sehen damit schon einmal die Möglichkeiten von Python und können später darauf zurückgreifen. Da dies auch ein Exkurs ist, können Sie diese Rubrik gerne auch erst einmal überspringen.
Mit den Operatoren aus diesem Kapitel können wir ganz leicht das Verfahren zur Umwandlung einer Dezimalzahl in ihre Binärdarstellung implementieren:
%% Cell type:code id: tags:
```
pass
```
%% Cell type:markdown id: tags:
## 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 die Zeichen zugreifen können, aus denen eine Zeichenkette besteht und wir lernen einige der Funktionen kennn, die für Zeichenketten bereitgestellt werden.
### 8.1 Eine Zeichenkette ist eine Folge
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:
```
fruit = 'banana'
letter = fruit[1]
```
%% 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.
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:
%% Cell type:code id: tags:
```
letter
```
%% 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:
%% Cell type:code id: tags:
```
letter = fruit[0]
letter
```
%% Cell type:markdown id: tags:
Somit ist `b` der 0. Buchstabe von `banana`, `a` ist der 1. Buchstabe und `n` ist der 2. Buchstabe.
Als Index können wir einen Ausdruck verwenden, der Variablen und Operatoren enthält:
%% Cell type:code id: tags:
```
i = 1
fruit[i]
```
%% Cell type:code id: tags:
```
fruit[i + 1]
```
%% Cell type:markdown id: tags:
Aber der Wert des Index muss eine ganze Zahl sein. Ansonsten erhalten wir eine Fehlermeldung:
%% Cell type:code id: tags:
```
letter = fruit[1.5]
```
%% Cell type:markdown id: tags:
### 8.2 `len`
`len` ist eine eingebaute Funktion, die die Anzahl der Zeichen einer Zeichenkette zurückgibt:
%% Cell type:code id: tags:
```
fruit = "banana"
len(fruit)
```
%% Cell type:markdown id: tags:
Um auf das letzte Zeichen einer Zeichenkette zuzugreifen, würden Sie vielleicht folgendes versuchen:
%% Cell type:code id: tags:
```
length = len(fruit)
last = fruit[length]
```
%% 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 extrahierren, müssen wir 1 von `length` abziehen:
%% Cell type:code id: tags:
```
last = fruit[length - 1]
last
```
%% Cell type:raw 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.:
%% Cell type:code id: tags:
```
fruit[-1]
```
%% Cell type:code id: tags:
```
fruit[-2]
```
%% Cell type:markdown id: tags:
### 8.3 Durchlauf mit einer `for`-Schleife
In vielen Berechnungen müsen wir eine Zeichenkette Zeichen für Zeichen verarbeiten. Oftmals beginnen wir mit dem ersten Zeichen und wählen dann in jedem Schritt das nächste Zeichen aus, machen etwas damit und fahren fort bis zum Ende der Zeichenkette. Diese Art von Prozess wird **Durchlauf** (*traversal*) genannt. Eine Möglichkeit einen Durchlauf zu programmieren, ist mit Hilfe einer `while`-Schleife:
%% Cell type:code id: tags:
```
index = 0
while index < len(fruit):
letter = fruit[index]
print(letter)
index = index + 1
```
%% 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.
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:
```
# Implementieren Sie hier die Funktion streawkceur
# Testaufruf
print(streawkceur("streawkceur"))
```
%% Cell type:markdown id: tags:
Eine andere Möglichkeit einen Durchlauf zu schreiben ist mit Hilfe der `for`-Schleife:
%% Cell type:code id: tags:
```
for letter in fruit:
print(letter)
```
%% 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.
Im folgenden Beispiel sehen wir, wie die Zeichenkettenverknüpfung und eine `for`-Schleife verwendet werden, um eine ABC-Schützen-Folge (sortierte Folge) zu erzeugen. In Robert McCloskeys Buch "Make Way for Ducklings", sind die Namen der Entenkücken *Jack, Kack, Lack, Mack, Nack, Ouack, Pack* und *Quack*. Die Schleife gibt die Namen in dieser Reihenfolge aus:
%% Cell type:code id: tags:
```
prefixes = 'JKLMNOPQ'
suffix = 'ack'
for letter in prefixes:
print(letter + suffix)
```
%% 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.
%% 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/).
