From c9c5e0eaf8bc466818f388877307f27607d9fe54 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Robert=20J=C3=A4schke?= <jaeschke@l3s.de>
Date: Thu, 25 Jan 2018 13:53:35 +0000
Subject: [PATCH] =?UTF-8?q?+weitere=20Abschnitte=20=C3=BCbersetzt?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
notebooks/seminar08.ipynb | 240 ++++++++++++++++++++++++++++++++++++++
1 file changed, 240 insertions(+)
diff --git a/notebooks/seminar08.ipynb b/notebooks/seminar08.ipynb
index d9028f1..5fd6ce5 100644
--- a/notebooks/seminar08.ipynb
+++ b/notebooks/seminar08.ipynb
@@ -295,6 +295,246 @@
"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": [
+ "### 8.4 Zeichenketten-Segmente\n",
+ "\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 Indexe *zwischen* die Zeichen zeigen, wie in der folgenden Abbildung dargestellt:\n",
+ "\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": [
+ "### 8.6 Zeichenketten sind unveränderbar\n",
+ "\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 \"object\" in diesem Beispiel ist die Zeichenkette und das \"item\" das Zeichen, welches wir zuweisen wollten. Momentan können wir uns unter einem Objekt das gleiche wie einen Wert vorstellen, aber wir werden später (in [Abschnitt 10.10](seminar10.ipynb#Objekte-und-Werte)) genauer kennenlernen, was Objekte sind.\n",
+ "\n",
+ "Der Grund für den Fehler ist, dass Zeichenketten **unveränderbar** (*immutable*) sind. Das heisst, wie können eine existierende Zeichenkette nicht verändern. Das beste, was wir machen können, ist eine neue Zeichenkette zu erzeugen, die eine Variante des Originals ist:"
+ ]
+ },
+ {
+ "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": [
+ "### 8.6 Suche\n",
+ "\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` das Inverse des `[]`-Operators. Anstatt einn Index zu nehmen und das entsprechende Zeichen zu extrahieren nimmt es ein Zeichen und findet den Index, an dem dieses Zeichen auftaucht. Wenn das Zeichen nicht gefunden wird, dann gibt die Funktion `-1` zurück.\n",
+ "\n",
+ "Das ist das erste Mal, dass wir eine `return`-Anweisung innerhalb einer Schleife sehen! Wenn `word[index] == letter`, dann bricht die Funktion die Schleife ab und gibt direkt `index` zurück.\n",
+ "\n",
+ "Wenn das Zeichen `letter` nicht in der Zeichenkette auftaucht, dann 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"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### 8.7 Schleifen ausführen und zählen\n",
+ "\n",
+ "Das folgende Programm zählt wie häufig der Buchstabe `a` in einer Zeichenkette auftaucht:"
+ ]
+ },
+ {
+ "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",
+ "\n",
+ "Verkapseln Sie den Code in einer Funktion mit Namen `count` und verallgemeinern Sie die Funktion, so dass sie die Zeichenkette und das gesuchte Zeichen als Parameter akzeptiert."
+ ]
+ },
+ {
+ "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": []
+ },
{
"cell_type": "markdown",
"metadata": {},
--
GitLab