diff --git a/notebooks/seminar07.ipynb b/notebooks/seminar07.ipynb
index 32a83a99c85432f7e3254f19413fe70e9baae9d2..926000130ae263f22d768761ad48ca464eaf35b5 100644
--- a/notebooks/seminar07.ipynb
+++ b/notebooks/seminar07.ipynb
@@ -40,7 +40,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "### 7.1 Neuzuordnung\n",
+ "### 7.1 Neuzuweisung\n",
"\n",
"Wie Sie vielleicht schon herausgefunden haben, ist es erlaubt, mehr als nur eine Zuweisung an die selbe Variable durchzuführen. Durch eine neue Zuweisung verweist eine existierende Variable auf einen neuen Wert (und nicht mehr auf den alten Wert)."
]
@@ -63,7 +63,7 @@
"source": [
"Wenn wir `x` beim ersten Mal ausgeben, ist sein Wert 5; beim zweiten Mal ist sein Wert 7.\n",
"\n",
- "Die folgende Abbildung zeigt, wie diese **Neuzuordnung** (*reassignment*) in einem Zustandsdiagramm aussieht. \n",
+ "Die folgende Abbildung zeigt, wie diese **Neuzuweisung** (*reassignment*) in einem Zustandsdiagramm aussieht. \n",
"\n",
"\n",
"\n",
@@ -185,7 +185,7 @@
"\n",
"Diese Art von Kontrollfluss wird Schleife genannt, weil der dritte Schritt wieder zum ersten Schritt springt und damit den Kreis (Schleife) schließt. (Im Englischen Original passt es besser: *This type of flow is called a loop because the third step loops back around to the top*.)\n",
"\n",
- "Der Schleifenrumpf sollte den Wert einer oder mehrerer Variablen ändern, so dass die Bedingung irgendwann einmal unwahr wird und die Schleife beendet wird. Ansonsten wiederholt sich die Schleife für immer, was **unendliche Schleife** (*infinite loop*) genannt wird.\n",
+ "Der Schleifenrumpf sollte den Wert einer oder mehrerer Variablen ändern, so dass die Bedingung irgendwann einmal unwahr wird und die Schleife beendet wird. Ansonsten wiederholt sich die Schleife für immer, was **Endlosschleife** (*infinite loop*) genannt wird.\n",
"\n",
"\n",
"\n",
@@ -434,24 +434,200 @@
"Wobei wir für `epsilon` einen sehr kleinen Wert wie z.B. `0.0000001` wählen sollten, der bestimmt, welche Näherung gut genug für uns ist. "
]
},
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### 7.6 Algorithmen\n",
+ "\n",
+ "Das Newton-Verfahren ist ein klassisches Beispiel für einen **Algorithmus**: ein Prozess zur Lösung einer bestimmten Problemklasse (in diesem Fall die Berechnung von Quadratwurzeln). \n",
+ "\n",
+ "Um zu verstehen, was ein Algorithmus ist, hilft es vielleicht, sich etwas anzuschauen, was kein Algorithmus ist. Als Sie (wohl in der Grundschule) gelernt haben, Zahlen mit nur einer Ziffer zu multiplizieren, haben Sie wahrscheinlich die Multiplikationstabelle (das [Kleine Einmaleins](https://de.wikipedia.org/wiki/Einmaleins)) auswendig gelernt. Effektiv haben Sie sich damit also 100 verschiedene Lösungen gemerkt. Diese Art von Wissen ist nicht algorithmisch.\n",
+ "\n",
+ "Aber wenn Sie \"faul\" waren, haben Sie vielleicht ein paar Tricks gelernt. Beispielsweise kann man das Produkt einer Zahl $n$ mit 9 berechnen, indem man $n-1$ als erste Ziffer des Ergebnisses aufschreibt und dann $10-n$ als zweite Ziffer anhängt. Dieser Trick ist eine allgemeine Lösung, um jede Zahl mit nur einer Zahl mit 9 zu multiplizieren. Das ist ein Algorithmus!\n",
+ "\n",
+ "Genauso sind die Verfahren zur schriftlichen Addition (mit Übertrag), Subtraktion und Division Algorithmen. Eine Eigenschaft von Algorithmen ist, dass Sie keine Intelligenz benötigen, um ausgeführt zu werden. Sie sind mechanische Prozesse bei denen jeder Schritt vom vorherigen mittels einfacher und eindeutiger Regeln folgt.\n",
+ "\n",
+ "Algorithmen auszuführen ist langweilig aber sie zu entwerfen ist interessant, intellektuell herausforderng und ein wesentlicher Teil der Informatik.\n",
+ "\n",
+ "Einige Dinge die Menschen natürlicherweise tun - ohne Schwierigkeiten oder bewusst einen Gedanken daran zu verschwenden - gehören zu den am schwersten repräsentierbaren Algorithmen. Sprachverstehen ist ein gutes Beispiel. Wir alle machen das ständig aber noch niemand konnte richtig erklären *wie* wir das machen - zumindest nicht in Form eines Algorithmus.\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### 7.7 Debugging\n",
+ "\n",
+ "Sobald Sie größere Programme schreiben werden Sie bemerken, dass Sie mehr Zeit mit Debuggen verbringen. Mehr Programmcode bedeutet halt auch dass es mehr Möglichkeiten gibt, einen Fehler zu machen und mehr Stellen, an denen sich \"Bugs\" verstecken können.\n",
+ "\n",
+ "Eine Möglichkeit die Zeit für das Debuggen zu reduzieren ist \"Debugging durch Halbieren\" (binäre Suche). Wenn Ihr Programm beispielsweise 100 Zeilen hat und Sie jede Zeile einzeln prüfen würden, dann bräuchten Sie 100 Schritte zum Debuggen.\n",
+ "\n",
+ "Stattdessen können Sie versuchen, das Problem zu halbieren. Gehen Sie (ungefähr) zur Hälfte des Programms und suchen Sie dort nach einem Zwischenwert (eine Variable), den Sie überprüfen können. Fügen Sie eine `print`-Anweisung (oder etwas anderes, was einen prüfbare Auswirkung hat) hinzu und starten Sie das Programm.\n",
+ "\n",
+ "Wenn diese Überprüfung in der Mitte das falsche Ergebnis ausgibt, muss das Problem in der ersten Hälfte des Programms liegen, ansonsten in der zweiten Hälfte.\n",
+ "\n",
+ "Jedes Mal wenn Sie einen solchen Test durchführen, haben Sie die Anzahl an Codezeilen halbiert, die Sie prüfen müssen. Nach sechs Schritten (was deutlich weniger als 100 ist), sind Sie bei ein oder zwei Programmzeilen angekommen, in denen der Fehler stecken sollte - zumindest theoretisch.\n",
+ "\n",
+ "In der Praxis ist oft nicht klar, was die \"Mitte des Programms\" ist und es ist nicht immer möglich, dort einen Test hinzuzufügen. Es ist nicht sinnvoll, die Zeilen zu zählen und die exakte Mitte zu finden. Denken Sie stattdessen an Stellen im Programm, die Fehler enthalten könnten und bei denen es einfach ist, eine Überprüfung (Debug-Ausgabe) hinzuzufügen. Suchen Sie dann nach einer Stelle, bei der Sie denken, dass die Chance, dass der Fehler davor oder danach ist ungefähr gleich ist. "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### 7.8 Glossar\n",
+ "\n",
+ "Legen wir uns eine Liste mit den wichtigsten Begriffen an, die wir im Kapitel 7 gelernt haben:\n",
+ "\n",
+ "- Neuzuweisung: \n",
+ "- Aktualisierung:\n",
+ "- Initialisierung:\n",
+ "- inkrementieren:\n",
+ "- dekrementieren:\n",
+ "- Iteration:\n",
+ "- Endlosschleife:\n",
+ "- Algorithmus: \n",
+ "\n",
+ "Ergänzen Sie die Liste in eigenen Worten. Das ist eine gute Erinnerungs- und Übungsmöglichkeit."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### 7.9 Ãœbung\n",
+ "\n",
+ "#### Aufgabe 1\n",
+ "\n",
+ "Kopieren Sie die Schleife aus [Abschnitt 7.5](#7.5-Quadratwurzeln) und verkapseln Sie sie in eine Funktion `mysqrt` die einen Parameter `a` erwartet, einen sinnvollen Wert für `x` wählt und eine Näherung für die Quadratwurzel von `a` zurückliefert."
+ ]
+ },
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
- "source": []
+ "source": [
+ "# Implementieren Sie hier die Funktion mysqrt\n",
+ "\n",
+ "\n",
+ "# Testen Sie hier die Funktion\n",
+ "print(\"Die Wurzel von 2 ist ungefähr \", mysqrt(2))\n",
+ "print(\"Die Wurzel von 23 ist ungefähr \", mysqrt(23))"
+ ]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
- "### 7.8 Glossar\n",
+ "Testen Sie die Funktion, indem Sie eine Funktion `test_square_root` schreiben, die eine Tabelle der folgenden Art ausgibt:\n",
"\n",
- "Legen wir uns eine Liste mit den wichtigsten Begriffen an, die wir im Kapitel 7 gelernt haben:\n",
+ "```\n",
+ "a mysqrt(a) math.sqrt(a) diff\n",
+ "- --------- ------------ ----\n",
+ "1.0 1.0 1.0 0.0\n",
+ "2.0 1.41421356237 1.41421356237 2.22044604925e-16\n",
+ "3.0 1.73205080757 1.73205080757 0.0\n",
+ "4.0 2.0 2.0 0.0\n",
+ "5.0 2.2360679775 2.2360679775 0.0\n",
+ "6.0 2.44948974278 2.44948974278 0.0\n",
+ "7.0 2.64575131106 2.64575131106 0.0\n",
+ "8.0 2.82842712475 2.82842712475 4.4408920985e-16\n",
+ "9.0 3.0 3.0 0.0\n",
+ "```\n",
+ "\n",
+ "Dabei ist die erste Spalte eine Zahl; `a`, die zweite Spalte ist die Quadratwurzel von `a` die mit `mysqrt` berechnet wurde; die dritte Spalte ist die Quadratwurzel, die mittels `math.sqrt` berechnet wurde; und die vierte Spalte ist der Absolutbetrag des Unterschieds zwischen den beiden Werten."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def test_square_root():\n",
+ " # Implementieren Sie hier die Funktion test_square_root\n",
"\n",
"\n",
+ "# Rufen Sie hier die Funktion test_square_root auf\n",
+ "test_square_root()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Aufgabe 2\n",
"\n",
- "Ergänzen Sie die Liste in eigenen Worten. Das ist eine gute Erinnerungs- und Übungsmöglichkeit."
+ "Die eingebaute Funktion `eval` erwartet eine Zeichenkette und führt sie dann mit dem Python-Interpreter aus. Beispielsweise:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "eval('1 + 2 * 3')"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import math\n",
+ "eval('math.sqrt(5)')"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "eval('type(math.pi)')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Schreiben Sie eine Funktion `eval_loop`, die den Nutzer iterativ bittet etwas einzugeben, die eingegebene Zeichenkette mittels `eval` ausführt und schließlich das Ergebnis ausgibt. \n",
+ "\n",
+ "Die Funktion sollte so lange laufen, bis der Nutzer `done` eingibt und dann sollte der Rückgabewert des letzten ausgeführten Ausdrucks ausgegeben werden."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Implementieren Sie hier die Funktion eval_loop"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Aufgabe 3\n",
+ "\n",
+ "\n",
+ "\n",
+ "Der Mathematiker [Srinivasa Ramanujan](https://de.wikipedia.org/wiki/S._Ramanujan) hat eine unendliche Folge gefunden die genutzt werden kann, um eine numerische Näherung für 1/$\\pi$ zu berechnen:\n",
+ "\n",
+ "\\begin{equation}\n",
+ "\\frac{1}{n} = \\frac{2\\sqrt{2}}{9801} \\cdot \\sum_{k=0}^{\\infty} \\frac{(4\\cdot k)! \\cdot (1103+26390 \\cdot k)}{(k!)^4 \\cdot 396^{4\\cdot k}}\n",
+ "\\end{equation}\n",
+ "\n",
+ "(Eventuell ist die Formel [in der Original-Aufgabenstellung](http://greenteapress.com/thinkpython2/html/thinkpython2008.html#hevea_default541) besser zu lesen.)\n",
+ "\n",
+ "Schreiben Sie eine Funktion `estimate_pi` die diese Formel nutzt, um einen Näherungswert für $\\pi$ zu berechnen und zurückzugeben. Sie sollten eine `while`-Schleife nutzen, um die Terme der Summe zu solange berechnen, bis der letzte Term kleiner ist als `1e-15` (was die Python-Notation für $10^{-15}$ ist). Sie können Ihr Ergebnis prüfen, indem Sie es mit `math.pi` vergleichen.\n",
+ "\n",
+ "Lösung: http://thinkpython2.com/code/pi.py"
]
},
{
@@ -465,9 +641,9 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "\n",
+ "\n",
"\n",
- "Herzlichen Glückwunsch! Sie haben das 6. Kapitel geschafft. Weiter geht es in [7: Iteration](seminar07.ipynb)."
+ "Herzlichen Glückwunsch! Sie haben das 7. Kapitel geschafft. Weiter geht es in [8: Zeichenketten](seminar08.ipynb)."
]
}
],