From c4b4773e01286655839cd2c43db888f5ac057860 Mon Sep 17 00:00:00 2001
From: Michel Schwab <michel.schwab@hu-berlin.de>
Date: Tue, 6 Nov 2018 16:08:32 +0100
Subject: [PATCH] adapted seminar04
---
notebooks/seminar04.ipynb | 176 ++++++++++++++++++++++++++++++--------
1 file changed, 142 insertions(+), 34 deletions(-)
diff --git a/notebooks/seminar04.ipynb b/notebooks/seminar04.ipynb
index ddb2700..08dd9b4 100644
--- a/notebooks/seminar04.ipynb
+++ b/notebooks/seminar04.ipynb
@@ -9,7 +9,7 @@
"## 4: Fallstudie: Schnittstellenentwurf\n",
"[Chapter 4: Case Study: interface design](http://greenteapress.com/thinkpython/html/thinkpython005.html)\n",
"\n",
- "In diesem Kapitel lernen wir, anhand einer Fallstudie, wie wir Funktionen entwerfen können, die gut zusammenarbeiten.\n",
+ "In diesem Kapitel lernen wir anhand einer Fallstudie, wie wir Funktionen entwerfen können, die gut zusammenarbeiten.\n",
"\n",
"Wir lernen außerdem das `turtle`-Modul kennen, mit dessen Hilfe wir Graphiken erzeugen können.\n",
"\n",
@@ -110,7 +110,7 @@
"*(Hinweis: In Jupyter gibt es manchmal Probleme mit dem `turtle`-Modul. **Wichtig ist, dass Sie stets das Turtle-Fenster schließen.** Manchmal hilft es, den Code nochmal auszuführen oder im Kernel-Menü den Punkt \"Restart & Clear Output\" aufzurufen. Wenn es gar nicht klappt, dann nutzen Sie für die Turtle-Programmierung bitte nicht Jupyter-Notebooks, sondern Python-Dateien und führen diese direkt mit Python aus. \n",
"Manchmal vergisst Jupyter Notebooks auch, dass bereits eine Schildkröte existiert, in diesem Fall initialisieren Sie diese bitte einfach am Anfang des gewünschten Code-Blocks)*\n",
"\n",
- "Probieren Sie nun folgendes (am besten in einem eigenen Jupyter-Notebook, einer eigenen Python-Datei, oder im folgenden Block, den Sie dann schrittweise ergänzen):"
+ "Probieren Sie nun Folgendes (am besten in einem eigenen Jupyter-Notebook, einer eigenen Python-Datei oder im folgenden Block, den Sie dann schrittweise ergänzen):"
]
},
{
@@ -144,7 +144,7 @@
"<turtle.Turtle object at 0xb7bfbf4c>\n",
"```\n",
"\n",
- "Das bedeutet, dass `bob` auf ein Objekt vom Typ `Turtle` verweist, wie es im `turtle`-Modul definiert wurde.\n",
+ "Das bedeutet, dass `bob` auf ein Objekt vom Typ `Turtle` verweist, wie es im `turtle`-Modul definiert wird.\n",
"\n",
"Der Aufruf von `mainloop` weist das Fenster an, auf Nutzeraktivität zu warten. In diesem Fall kann man als NutzerIn allerdings kaum mehr tun, als das Fenster zu schließen.\n",
"\n",
@@ -158,9 +158,9 @@
"\n",
"Das Argument von `fd` ist eine Strecke in Pixeln (den Bildpunkten auf dem Monitor), daher hängt die Entfernung, die `bob` geht, von unserer Monitorauflösung ab.\n",
"\n",
- "Andere Methoden, die wir auf einer Schildkröte aufrufen können sind `bk` für eine Rückwärtsbewegung (**b**ac**k**ward), `lt` für eine Linksdrehung (**l**eft **t**urn) und `rt` für eine Rechtsdrehung (**r**ight **t**urn). Das Argument für `lt` und `rt` ist ein Winkel in Grad.\n",
+ "Andere Methoden, die wir auf einer Schildkröte aufrufen können, sind `bk` für eine Rückwärtsbewegung (**b**ac**k**ward), `lt` für eine Linksdrehung (**l**eft **t**urn) und `rt` für eine Rechtsdrehung (**r**ight **t**urn). Das Argument für `lt` und `rt` ist ein Winkel in Grad.\n",
"\n",
- "Jede Schildkröte hat außerdem einen \"Stift\", der entweder \"oben\" oder \"unten\" ist. Wenn der Stift unten ist, berührt der Stift sozusagen das Papier und die Schildkröte hinterlässt eine Spur wenn sie sich bewegt. Die Methoden `pu` und `pd` stehen für \"Stift hoch\" (**p**en **u**p) und \"Stift herunter\" (**p**en **d**own).\n",
+ "Jede Schildkröte hat außerdem einen \"Stift\", der entweder \"oben\" oder \"unten\" ist. Wenn der Stift unten ist, berührt der Stift sozusagen das Papier und die Schildkröte hinterlässt eine Spur wenn sie sich bewegt. Die Methoden `pu` und `pd` stehen für \"Stift hoch\" (**p**en **u**p) und \"Stift herunter\" (**p**en **d**own). Diese beiden Methoden brauchen kein Argument als Input.\n",
"\n",
"Fügen Sie die folgenden Zeilen zu Ihrem Programm hinzu, um einen rechten Winkel zu zeichnen (nachdem Sie `bob` erzeugt haben und bevor Sie `mainloop` aufrufen):\n",
"\n",
@@ -186,7 +186,7 @@
"source": [
"### 4.2 Einfache Wiederholung\n",
"\n",
- "Vielleicht haben Sie folgendes geschrieben:\n",
+ "Vielleicht haben Sie Folgendes geschrieben:\n",
"\n",
"```python\n",
"bob.fd(100)\n",
@@ -228,7 +228,7 @@
"Hello!\n",
"```\n",
"\n",
- "Das ist die einfachste Art und Weise, eine `for`-Schleife zu verwenden. Wir werden uns das später ausführlicher anschauen, aber das sollte reichen, damit Sie ihr Programm zum Zeichnen eines Quadrats vereinfachen können. Bitte fahren Sie erst fort, wenn Sie ihr Programm mit Hilfe der `for`-Schleife vereinfacht haben.\n",
+ "Das ist die einfachste Art und Weise, eine `for`-Schleife zu verwenden. Wir werden uns das später ausführlicher anschauen. Für jetzt sollte das reichen, damit Sie ihr Programm zum Zeichnen eines Quadrats vereinfachen können. Bitte fahren Sie erst fort, wenn Sie ihr Programm mit Hilfe der `for`-Schleife vereinfacht haben.\n",
"\n",
"<a data-flickr-embed=\"true\" href=\"https://www.flickr.com/photos/jasoneppink/4964471335\" title=\"Spoiler Alert\"><img src=\"https://farm5.staticflickr.com/4110/4964471335_1f86a923f3_n.jpg\" width=\"320\" height=\"213\" alt=\"Spoiler Alert\"></a><script async src=\"//embedr.flickr.com/assets/client-code.js\" charset=\"utf-8\"></script>\n",
"\n",
@@ -243,6 +243,8 @@
"metadata": {},
"outputs": [],
"source": [
+ "import turtle\n",
+ "\n",
"bob=turtle.Turtle()\n",
"\n",
"for i in range(4):\n",
@@ -266,7 +268,7 @@
"source": [
"### 4.3 Ãœbungen\n",
"\n",
- "In den folgenden Abschnitten folgen einige Übungen zur \"Schildkrötenwelt\". Sie sollten Ihnen Spaß bereiten, habe aber auch einen Sinn. Versuchen Sie diesen herauszufinden und gehen Sie Abschnittweise vor. \n"
+ "In den folgenden Abschnitten folgen einige Übungen zur \"Schildkrötenwelt\". Sie sollten Ihnen Spaß bereiten, haben aber auch einen Sinn. Versuchen Sie diesen herauszufinden und gehen Sie abschnittweise vor. \n"
]
},
{
@@ -275,7 +277,7 @@
"source": [
"### 4.4 Verkapselung\n",
"\n",
- " - **Aufgabe 1:** Schreiben Sie eine Funktion `square`, die einen Parameter namens `t` erwartet, welcher eine Schildkröte ist. Die Funktion soll die Schildkröte nutzen, um ein Quadrat zu zeichnen.\n",
+ " - **Aufgabe 1:** Schreiben Sie eine Funktion `square`, die einen Parameter `t` erwartet, welcher eine Schildkröte ist. Die Funktion soll die Schildkröte nutzen, um ein Quadrat zu zeichnen.\n",
" - **Aufgabe 2:** Schreiben Sie einen Funktionsaufruf, der `bob` als Argument an `square` übergibt und rufen Sie ihr Programm auf."
]
},
@@ -303,19 +305,26 @@
"metadata": {},
"outputs": [],
"source": [
+ "import turtle\n",
+ "\n",
+ "bob=turtle.Turtle()\n",
+ "\n",
"def square(t):\n",
" for i in range(4):\n",
" t.fd(100)\n",
" t.lt(90)\n",
"\n",
- "square(bob)"
+ "square(bob)\n",
+ "\n",
+ "turtle.mainloop() \n",
+ "turtle.bye()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
- "Die beiden innersten Anweisungen (`t.fd` und `t.lt`) sind doppelt eingerückt, weil sie innerhalb der `for`-Schleife sind, die wiederrum innerhalb der Funktionsdefinition steht. Die übernächste Zeile (`square(bob)`) ist wieder bündig mit dem linken Rand ausgerichtet, also sowohl außerhalb der `for`-Schleife, als auch außerhalb der Funktionsdefinition.\n",
+ "Die beiden innersten Anweisungen (`t.fd` und `t.lt`) sind doppelt eingerückt, weil sie innerhalb der `for`-Schleife sind, die wiederum innerhalb der Funktionsdefinition steht. Die übernächste Zeile (`square(bob)`) ist wieder bündig mit dem linken Rand ausgerichtet, also sowohl außerhalb der `for`-Schleife, als auch außerhalb der Funktionsdefinition.\n",
"\n",
"Innerhalb der Funktion verweist `t` auf die gleiche Schildkröte `bob`, so dass `t.lt(90)` die gleiche Auswirkung hat wie `bob.lt(90)`. Hätten wir dann in der Funktion nicht direkt `bob` aufrufen können oder den Parameter stattdessen `bob` nennen können? Prinzipiell schon, aber die Idee ist, dass `t` irgendeine Schildkröte sein kann, nicht nur `bob`, so dass wir beispielsweise eine zweite Schildkröte erzeugen und sie als Argument an `square` übergeben können:"
]
@@ -326,8 +335,18 @@
"metadata": {},
"outputs": [],
"source": [
+ "import turtle\n",
+ "\n",
+ "def square(t):\n",
+ " for i in range(4):\n",
+ " t.fd(100)\n",
+ " t.lt(90)\n",
+ "\n",
"alice = turtle.Turtle()\n",
- "square(alice)"
+ "square(alice)\n",
+ "\n",
+ "turtle.mainloop() \n",
+ "turtle.bye()"
]
},
{
@@ -343,7 +362,7 @@
"source": [
"### 4.5 Verallgemeinerung\n",
"\n",
- "- **Aufgabe 3:** Ergänzen Sie die Funktion `square` um einen weiteren Parameter namens `length`. Ändern Sie den Rumpf der Funktion so, dass dass die Seitenlänge des gezeichneten Quadrats `length` entspricht. Passen Sie dann den Funktionsaufruf an, sodass ein weiteres Argument als Länge übergeben wird. Starten Sie ihr Programm noch einmal und testen Sie es mit verschiedenen Werten für die Länge. *(Hinweis: Kopieren Sie die Funktion aus dem vorherigen Abschnitt oder arbeiten Sie in dem bereits geschriebenen Code)*"
+ "- **Aufgabe 3:** Ergänzen Sie die Funktion `square` um einen weiteren Parameter namens `length`. Ändern Sie den Rumpf der Funktion so, dass die Seitenlänge des gezeichneten Quadrats `length` entspricht. Passen Sie dann den Funktionsaufruf an, sodass ein weiteres Argument als Länge übergeben wird. Starten Sie ihr Programm noch einmal und testen Sie es mit verschiedenen Werten für die Länge. *(Hinweis: Kopieren Sie die Funktion aus dem vorherigen Abschnitt oder arbeiten Sie in dem bereits geschriebenen Code)*"
]
},
{
@@ -370,12 +389,19 @@
"metadata": {},
"outputs": [],
"source": [
+ "import turtle\n",
+ "\n",
+ "bob=turtle.Turtle()\n",
+ "\n",
"def square(t, length):\n",
" for i in range(4):\n",
" t.fd(length)\n",
" t.lt(90)\n",
"\n",
- "square(bob, 400)"
+ "square(bob, 400)\n",
+ "\n",
+ "turtle.mainloop() \n",
+ "turtle.bye()"
]
},
{
@@ -411,13 +437,20 @@
"metadata": {},
"outputs": [],
"source": [
+ "import turtle\n",
+ "\n",
+ "bob=turtle.Turtle()\n",
+ "\n",
"def polygon(t, n, length):\n",
" angle = 360 / n\n",
" for i in range(n):\n",
" t.fd(length)\n",
" t.lt(angle)\n",
"\n",
- "polygon(bob, 7, 70)"
+ "polygon(bob, 7, 70)\n",
+ "\n",
+ "turtle.mainloop() \n",
+ "turtle.bye()"
]
},
{
@@ -435,7 +468,20 @@
"metadata": {},
"outputs": [],
"source": [
- "polygon(bob, n=7, length=70)"
+ "import turtle\n",
+ "\n",
+ "bob=turtle.Turtle()\n",
+ "\n",
+ "def polygon(t, n, length):\n",
+ " angle = 360 / n\n",
+ " for i in range(n):\n",
+ " t.fd(length)\n",
+ " t.lt(angle)\n",
+ "\n",
+ "polygon(bob, n=7, length=70)\n",
+ "\n",
+ "turtle.mainloop() \n",
+ "turtle.bye()\n"
]
},
{
@@ -444,7 +490,7 @@
"source": [
"Diese werden **Schlüsselwortargumente** genannt, denn Sie enthalten die Parameter als \"Schlüsselwörter\" (diese sollten nicht mit Python-Schlüsselwörtern wie z.B. `while` oder `def` verwechselt werden).\n",
"\n",
- "Durch diese Syntax wird das Programm lesbarer. Sie erinnert uns auch daran, wie Argumente und Parameter funktionieren: wenn wir eine Funktion aufrufen, werden unsere Argumente den Parametern zugewiesen."
+ "Durch diese Syntax wird das Programm lesbarer. Sie erinnert uns auch daran, wie Argumente und Parameter funktionieren: Wenn wir eine Funktion aufrufen, werden unsere Argumente den Parametern zugewiesen."
]
},
{
@@ -453,7 +499,7 @@
"source": [
"### 4.6 Schnittstellenentwurf\n",
"\n",
- "- **Aufgabe 5:** Schreiben Sie eine Funktion `circle` die eine Schildkröte `t` und einen Radius `r` als Parameter erwartet und annähernd einen Kreis zeichnet, indem sie die Funktion `polygon` mit einer geeigneten Seitenlänge und Anzahl von Seiten aufruft. Testen Sie ihre Funktion mit verschiedenen Werten für `r`.\n",
+ "- **Aufgabe 5:** Schreiben Sie eine Funktion `circle`, die eine Schildkröte `t` und einen Radius `r` als Parameter erwartet und annähernd einen Kreis zeichnet, indem sie die Funktion `polygon` mit einer geeigneten Seitenlänge und Anzahl von Seiten aufruft. Testen Sie ihre Funktion mit verschiedenen Werten für `r`.\n",
"\n",
" *(Hinweis: Finden Sie den Umfang des Kreises heraus und stellen Sie sicher, dass `length * n` gleich dem Umfang ist.)*"
]
@@ -482,7 +528,15 @@
"metadata": {},
"outputs": [],
"source": [
- "import math\n",
+ "import turtle, math\n",
+ "\n",
+ "\n",
+ "def polygon(t, n, length):\n",
+ " angle = 360 / n\n",
+ " for i in range(n):\n",
+ " t.fd(length)\n",
+ " t.lt(angle)\n",
+ " \n",
"\n",
"def circle(t, r):\n",
" circumference = 2 * math.pi * r\n",
@@ -497,7 +551,7 @@
"source": [
"Die erste Zeile berechnet den Umfang eines Kreises mit dem Radius `r` mit Hilfe der Formel 2 π r. Da wir `math.pi` nutzen wollen, müssen wir zunächst `math` importieren. Die Konvention ist, dass `import`-Anweisungen stets am Anfang eines Python-Programms stehen.\n",
"\n",
- "Weil `n` die Anzahl der Liniensegmente in unserer Näherung eines Kreises ist, ist `length` die Länge jedes einzelnen Segmentes. Daher zeichnet `polygon` ein reguläre 50-seitiges Vieleck als Näherun eines Kreises mit Radius `r`.\n",
+ "Weil `n` die Anzahl der Liniensegmente in unserer Näherung eines Kreises ist, ist `length` die Länge jedes einzelnen Segmentes. Daher zeichnet `polygon` ein reguläres 50-seitiges Vieleck als Näherung eines Kreises mit Radius `r`.\n",
"\n",
"Eine Beschränkung dieser Lösung ist, dass `n` eine Konstante ist. Daher sind für sehr große Kreise die Liniensegmente zu lang und für kleine Kreise verschwenden wir Zeit mit dem Zeichnen sehr kleiner Segmente. Eine Lösung wäre, die Funktion zu verallgemeinern und `n` als Parameter hinzuzufügen. Dies gäbe dem Nutzer (wer auch immer `circle` aufruft) mehr Kontrolle, aber die Schnittstelle wäre weniger aufgeräumt.\n",
"\n",
@@ -514,6 +568,15 @@
"metadata": {},
"outputs": [],
"source": [
+ "import turtle, math\n",
+ "\n",
+ "\n",
+ "def polygon(t, n, length):\n",
+ " angle = 360 / n\n",
+ " for i in range(n):\n",
+ " t.fd(length)\n",
+ " t.lt(angle)\n",
+ " \n",
"def circle(t, r):\n",
" circumference = 2 * math.pi * r\n",
" n = int(circumference / 3) + 3\n",
@@ -525,13 +588,13 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "Jetzt ist die Anzahl der Liniensegmente eine ganze Zahl, die nah bei Umfang/3 liegt, sodass die Länge jedes Segments ungefähr 3 beträgt. Das ist klein genug, damit der Kreis gut aussieht, aber auch groß genug, um eine effiziente Zeichnung zu ermöglichen und passt daher für jede Größe von Kreis. \n",
+ "Jetzt ist die Anzahl der Liniensegmente eine ganze Zahl, die nah bei `Umfang/3` liegt, sodass die Länge jedes Segments ungefähr 3 beträgt. Das ist klein genug, damit der Kreis gut aussieht, aber auch groß genug, um eine effiziente Zeichnung zu ermöglichen und passt daher für jede Kreisgröße. \n",
"\n",
"Wir addieren 3, damit das Vieleck mindestens drei Seiten hat.\n",
"\n",
"### 4.7 Refactoring\n",
"\n",
- "- **Aufgabe 6:** Schreiben Sie eine verallgemeinerte Funktion `circle`, die Sie `arc` nennen. Diese soll ein weiteres Argument `angle` erwartet, welches angibt, welcher Anteil des Kreises gezeichnet werden soll. Die Funktion `arc` soll also einen Kreisbogen zeichnen. Der Wert von `angle` ist dabei in Grad, so dass für `angle=360` ein vollständiger Kreis gezeichnet werden sollte.\n"
+ "- **Aufgabe 6:** Schreiben Sie eine verallgemeinerte Funktion `circle`, die Sie `arc` nennen. Diese soll ein weiteres Argument `angle` erwarten, welches angibt, welcher Anteil des Kreises gezeichnet werden soll. Die Funktion `arc` soll also einen Kreisbogen zeichnen. Der Wert von `angle` ist dabei in Grad, so dass für `angle=360` ein vollständiger Kreis gezeichnet werden sollte.\n"
]
},
{
@@ -561,6 +624,8 @@
"metadata": {},
"outputs": [],
"source": [
+ "import turtle \n",
+ "\n",
"def arc(t, r, angle):\n",
" arc_length = 2 * math.pi * r * angle / 360\n",
" n = int(arc_length / 3) + 1\n",
@@ -569,7 +634,11 @@
" \n",
" for i in range(n):\n",
" t.fd(step_length)\n",
- " t.lt(step_angle)"
+ " t.lt(step_angle)\n",
+ " \n",
+ " \n",
+ "#turtle.mainloop()\n",
+ "#turtle.bye()"
]
},
{
@@ -585,10 +654,16 @@
"metadata": {},
"outputs": [],
"source": [
+ "import turtle\n",
+ "\n",
"def polyline(t, n, length, angle):\n",
" for i in range(n):\n",
" t.fd(length)\n",
- " t.lt(angle)"
+ " t.lt(angle)\n",
+ "\n",
+ " \n",
+ "#turtle.mainloop()\n",
+ "#turtle.bye()"
]
},
{
@@ -604,16 +679,23 @@
"metadata": {},
"outputs": [],
"source": [
- "def polygon(t, n, length):\n",
- " angle = 360.0 / n\n",
- " polyline(t, n, length, angle)\n",
+ "import turtle\n",
"\n",
+ "def polyline(t, n, length, angle):\n",
+ " for i in range(n):\n",
+ " t.fd(length)\n",
+ " t.lt(angle)\n",
+ " \n",
"def arc(t, r, angle):\n",
" arc_length = 2 * math.pi * r * angle / 360\n",
" n = int(arc_length / 3) + 1\n",
" step_length = arc_length / n\n",
" step_angle = float(angle) / n\n",
- " polyline(t, n, step_length, step_angle)"
+ " polyline(t, n, step_length, step_angle)\n",
+ " \n",
+ "\n",
+ "#turtle.mainloop()\n",
+ "#turtle.bye()"
]
},
{
@@ -629,15 +711,34 @@
"metadata": {},
"outputs": [],
"source": [
+ "import turtle\n",
+ "\n",
+ "def polyline(t, n, length, angle):\n",
+ " for i in range(n):\n",
+ " t.fd(length)\n",
+ " t.lt(angle)\n",
+ " \n",
+ "def arc(t, r, angle):\n",
+ " arc_length = 2 * math.pi * r * angle / 360\n",
+ " n = int(arc_length / 3) + 1\n",
+ " step_length = arc_length / n\n",
+ " step_angle = float(angle) / n\n",
+ " polyline(t, n, step_length, step_angle)\n",
+ " \n",
"def circle(t, r):\n",
- " arc(t, r, 360)"
+ " arc(t, r, 360)\n",
+ " \n",
+ " \n",
+ " \n",
+ "#turtle.mainloop()\n",
+ "#turtle.bye()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
- "Dieser Prozess der Umstrukturierung eines Programms und der Verbesserung von Schnittstellen nennt sich **Refactoring** und hilft Code wiederverwenden zu können. In unserem Fall haben wir festgestellt, dass `arc` und `polygon` ähnlichen Code enthalten haben, daher haben wir diesen Code umgestaltet und in die Funktion `polyline` \"ausfaktorisiert\" also quasi ausgeklammert.\n",
+ "Dieser Prozess der Umstrukturierung eines Programms und der Verbesserung von Schnittstellen nennt sich **Refactoring** und hilft Code wiederverwenden zu können. In unserem Fall haben wir festgestellt, dass `arc` und `polygon` ähnlichen Code enthalten haben, daher haben wir diesen Code umgestaltet und in die Funktion `polyline` \"ausfaktorisiert\", also quasi ausgeklammert.\n",
"\n",
"Hätten wir vorausschauend geplant, hätten wir vielleicht `polyline` zuerst geschrieben und diese Umstrukturierung vermieden. Oft wissen wir aber am Anfang eines Projektes noch nicht genug, um schon alle Schnittstellen entwerfen zu können. Sobald wir anfangen zu programmieren, verstehen wir das Problem besser. Manchmal ist Refactoring ein Anzeichen dafür, dass wir etwas gelernt haben.\n"
]
@@ -648,7 +749,7 @@
"source": [
"### 4.8 Ein Entwicklungsplan\n",
"\n",
- "Ein **Entwicklungsplan** ist ein Prozess zum Schreiben von Programmen. Der Prozess, den wir in dieser Fallstudie verwendet haben ist \"Verkapselung und Verallgemeinerung\". Die Schritte dieses Prozesses sind:\n",
+ "Ein **Entwicklungsplan** ist ein Prozess zum Schreiben von Programmen. Der Prozess, den wir in dieser Fallstudie verwendet haben, heißt \"Verkapselung und Verallgemeinerung\". Die Schritte dieses Prozesses sind:\n",
"\n",
"1. Wir schreiben ein kleines Programm ohne Funktionsdefinitionen.\n",
"2. Sobald das Programm funktioniert, identifizieren wir ein schlüssiges und zusammengehöriges Stück Code, verkapseln es in einer Funktion und geben ihm einen Namen.\n",
@@ -675,13 +776,20 @@
"metadata": {},
"outputs": [],
"source": [
+ "import turtle\n",
+ "\n",
"def polyline(t, n, length, angle):\n",
" \"\"\"Draws n line segments with the given length and\n",
" angle (in degrees) between them. t is a turtle.\n",
" \"\"\" \n",
" for i in range(n):\n",
" t.fd(length)\n",
- " t.lt(angle)"
+ " t.lt(angle)\n",
+ " \n",
+ " \n",
+ "\n",
+ "#turtle.mainloop()\n",
+ "#turtle.bye()"
]
},
{
@@ -690,7 +798,7 @@
"source": [
"Es gilt die Konvention, dass Docstrings in dreifachen Anführungszeichen gesetzt werden. Mit Hilfe der dreifachen Anführungszeichen kann der Text über mehr als eine Zeile hinwegreichen.\n",
"\n",
- "Der Docstring im Beispiel ist knapp, enthält aber die wesentlichen Informationen, die jemand benötigt, der die Funktion nutzen möchte. Es wird prägnant erklärt, was die Funktion tut (ohne groß zu beschreiben, wie sie das tut). Es wird auch erklärt, welche Auswirkung jeder Parameter auf das Verhalten der Funktion hat und von welchem Typ jeder Parameter sein sollte (falls es nicht offensichtlich ist). \n",
+ "Der Docstring im Beispiel ist knapp, enthält aber die wesentlichen Informationen, die jemand benötigt, der die Funktion nutzen möchte. Es wird prägnant erklärt, was die Funktion tut (ohne groß zu beschreiben, wie sie es tut). Es wird auch erklärt, welche Auswirkung jeder Parameter auf das Verhalten der Funktion hat und von welchem Typ jeder Parameter sein sollte (falls es nicht offensichtlich ist). \n",
"\n",
"Das Schreiben dieser Art von Dokumentation ist ein wichtiger Teil des Schnittstellenentwurfs. Eine gut konzipierte Schnittstelle sollte einfach zu erklären sein. Falls es Ihnen schwerfällt, Ihre Funktionen zu erklären, dann könnte es vielleicht helfen, die Schnittstelle zu verbessern. \n"
]
@@ -766,7 +874,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "1. Zeichnen Sie (mit Stift und Papier) ein Stapeldiagramm (siehe [Kapitel 3](#3.9-Stapel-Diagramme)), welches den Zustand des Programms zeigt, während die Anweisung `circle(bob, radius)` ausgeführt wid. Sie können das manuell herausfinden, oder `print`-Anweisungen zum Code hinzufügen. (*Hinweis: Unter Umständen kann Ihnen [Python-Tutor](http://pythontutor.com/) dabei helfen*)\n",
+ "1. Zeichnen Sie (mit Stift und Papier) ein Stapeldiagramm (siehe [Kapitel 3](#3.9-Stapel-Diagramme)), welches den Zustand des Programms zeigt, während die Anweisung `circle(bob, radius)` ausgeführt wid. Sie können das manuell herausfinden oder `print`-Anweisungen zum Code hinzufügen. (*Hinweis: Unter Umständen kann Ihnen [Python-Tutor](http://pythontutor.com/) dabei helfen*)\n",
"2. Die Version der Funktion `arc` in [Abschnitt 4.7](#4.7-Refactoring) ist nicht besonders präzise, denn die lineare Näherung eines Kreises ist immer ausserhalb des wahren Kreises. Daher steht die Schildkröte am Ende immer ein paar Pixel vom richtigen Ziel entfernt. Die Lösung im Python-Code zeigt eine Möglichkeit, die Auswirkung dieses Fehlers zu reduzieren. Lesen Sie sich den Code durch und schauen Sie, ob das für Sie einen Sinn ergibt. Vielleicht hilft es Ihnen weiter, ein Diagramm zu zeichnen."
]
},
--
GitLab