{
"cells": [
{
"cell_type": "markdown",
"id": "941d0725-c678-43db-89b7-2897e1ccf0ae",
"metadata": {},
"source": [
"# Kapitel 5: Verzweigungen und Rekursion\n",
"[Chapter 5: Conditionals and recursion](https://colab.research.google.com/github/AllenDowney/ThinkPython/blob/v3/chapters/chap05.ipynb)\n",
"\n",
"\n",
"Das erste Thema dieses Kapitels ist die `if`-Anweisung, die je nach Zustand des Programms unterschiedlichen Code ausführt. Im zweiten Teil lernen Sie die `Rekursion` kennen. "
]
},
{
"cell_type": "markdown",
"id": "ceb73dff-b1ae-45e5-8329-dda65d93f0e5",
"metadata": {},
"source": [
"## Ihre Lernziele\n",
"Sie können eine Übersicht der Inhalte dieses Notebooks einblenden mit *Strg + Shift + k*. \n",
"\n",
"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:\n",
"\n",
"- \n",
"- \n",
"- \n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "90816f33-29e3-48d1-b8dc-35a7edad02a3",
"metadata": {},
"source": [
"## Exkurs: Was mir an Python gefällt\n",
"\n",
"Das Modul os stellt Funktionen bereit, um Funktionalitäten des Betriebssystems zu nutzen. Beispielsweise können wir damit Verzeichnis-Inhalte auflisten, durch Verzeichnisse navigieren, Informationen zu Dateien bekommen und Dateieigenschaften verändern. Das folgende Programm gibt eine Liste aller Jupyter-Notebooks im aktuellen Verzeichnis zusammen mit der Dateigröße aus und berechnet die Gesamtgröße der Dateien:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "78f5837f-1de8-45ae-9bbc-d99e66e84697",
"metadata": {},
"outputs": [],
"source": [
"import os\n",
"\n",
"# Tabellenkopf ausgeben\n",
"print(\"Bytes\\tName\")\n",
"print(\"--------------------------------------------------------------\")\n",
"\n",
"# Gesamtgröße in Bytes\n",
"bytes_sum = 0\n",
"\n",
"# Inhalt des aktuellen Verzeichnisses durchlaufen\n",
"for entry in os.scandir():\n",
" if entry.is_file() and entry.name.endswith(\".ipynb\"):\n",
" size = entry.stat().st_size\n",
" bytes_sum +=size\n",
" print(\"{:5d}\".format(size), entry.name, sep='\\t')\n",
" \n",
"print(\"--------------------------------------------------------------\")\n",
"print(bytes_sum, \"bytes =\", bytes_sum/1000, \"kilobytes =\", bytes_sum/1000000, \"Megabytes\")"
]
},
{
"cell_type": "markdown",
"id": "3b72643b-1146-4846-b66f-e87570747a17",
"metadata": {},
"source": [
"## Herunterladen des unterstützenden Codes\n",
"Die folgende Zelle lädt eine Datei herunter und führt einen Code aus, der speziell für dieses Notebook verwendet wird. Sie müssen diesen Code nicht verstehen, aber Sie sollten die Zelle vor allen weiteren Zellen in diesem Notebook ausführen."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "8119ba50",
"metadata": {
"tags": [
"remove-cell"
]
},
"outputs": [],
"source": [
"from os.path import basename, exists\n",
"\n",
"def download(url):\n",
" filename = basename(url)\n",
" if not exists(filename):\n",
" from urllib.request import urlretrieve\n",
"\n",
" local, _ = urlretrieve(url, filename)\n",
" print(\"Downloaded \" + str(local))\n",
" return filename\n",
"\n",
"download('https://github.com/AllenDowney/ThinkPython/raw/v3/thinkpython.py');\n",
"download('https://github.com/AllenDowney/ThinkPython/raw/v3/diagram.py');\n",
"download('https://github.com/ramalho/jupyturtle/releases/download/2024-03/jupyturtle.py');\n",
"\n",
"import thinkpython"
]
},
{
"cell_type": "markdown",
"id": "75b60d6c",
"metadata": {},
"source": [
"# Verzweigungen und Rekursion\n",
"\n",
"Das Hauptthema dieses Kapitels ist die `if`-Anweisung, die je nach dem Zustand des Programms verschieenen Code ausführt.\n",
"Mithilfe der `if`-Anweisung werden wir im Anschluss in der Lage sein, eine der mächtigsten Ideen in der Informatik zu erforschen, die **Rekursion** (Englisch: *recursion*).\n",
"\n",
"Zunächst beginnen wir aber mit drei neuen Features: dem **Modulo-Operator** (Englisch: *modulus operator*), **booleschen Ausdrücken** (Englisch: *boolean expressions*) und **logischen Operatoren** (Englisch: *logical operators*)."
]
},
{
"cell_type": "markdown",
"id": "4ab7caf4",
"metadata": {},
"source": [
"## Ganzzahlige Division und Modulo\n",
"\n",
"In einem früheren Notebook haben wir bereits den Operator zur ganzzahligen Division, `//`, kennengelernt, der zwei Zahlen dividiert und auf eine ganze Zahl abrundet.\n",
"Nehmen wir beispielsweise an, ein Film hat eine Laufzeit von 105 Minuten.\n",
"Nun wollen wir vielleicht wissen, wie viel das in Stunden ist.\n",
"Eine gewöhnliche Division gibt uns hier eine Gleitkommazahl zurück:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "30bd0ba7",
"metadata": {},
"outputs": [],
"source": [
"minutes = 105\n",
"minutes / 60"
]
},
{
"cell_type": "markdown",
"id": "3f224403",
"metadata": {},
"source": [
"Wir schreiben Stunden aber normalerweise nicht mit einem Dezimalkomma.\n",
"Eine ganzzahlige Division gibt die Anzahl der Stunden als ganze Zahl zurück und rundet dabei ab:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "451e3198",
"metadata": {},
"outputs": [],
"source": [
"minutes = 105\n",
"hours = minutes // 60\n",
"hours"
]
},
{
"cell_type": "markdown",
"id": "bfa9b0cf",
"metadata": {},
"source": [
"Um den Rest zu erhalten, könnten wir eine Stunde in Minuten abziehen:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "64b92876",
"metadata": {},
"outputs": [],
"source": [
"remainder = minutes - hours * 60\n",
"remainder"
]
},
{
"cell_type": "markdown",
"id": "05caf27f",
"metadata": {},
"source": [
"Oder wir könnten den **Modulo-Operator**, `%`, verwenden, der zwei Zahlen dividiert und den Rest dieser Division ausgibt:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "0a593844",
"metadata": {},
"outputs": [],
"source": [
"remainder = minutes % 60\n",
"remainder"
]
},
{
"cell_type": "markdown",
"id": "18c1e0d0",
"metadata": {},
"source": [
"Der Modulo-Operator ist praktischer als es auf den ersten Blick wirken mag.\n",
"Er kann beispielsweise kontrollieren, ob eine Zahl durch eine andere teilbar ist -- wenn `x % y` Null ergibt, dann ist `x`durch `y` teilbar.\n",
"\n",
"Außerdem kann er die äußerste rechte Ziffer (oder Ziffern) einer Zahl extrahieren.\n",
"Zum Beispiel ergibt `x % 10` die äußerste rechte Ziffer von `x` (zur Basis 10).\n",
"Auf ähnliche Weise liefert `x % 100` die letzten beiden Ziffern von `x`:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "5bd341f7",
"metadata": {},
"outputs": [],
"source": [
"x = 123\n",
"x % 10"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "367fce0c",
"metadata": {},
"outputs": [],
"source": [
"x % 100"
]
},
{
"cell_type": "markdown",
"id": "f2344fc0",
"metadata": {},
"source": [
"Abschließend kann der Modulo-Operator auch noch für **modulare Arithmetik**, auch **Uhrenarithmetik** genannt (Englisch: _clock arithmetic_), verwendet werden.\n",
"Wenn eine Veranstaltung zum Beispiel um 11 Uhr beginnt und drei Stunden dauert, können wir den Modulo-Operator verwenden, um herauszufinden wann sie endet:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "db33a44d",
"metadata": {},
"outputs": [],
"source": [
"start = 11\n",
"duration = 3\n",
"end = (start + duration) % 12\n",
"end"
]
},
{
"cell_type": "markdown",
"id": "351c30df",
"metadata": {},
"source": [
"Die Veranstaltung würde um 14 Uhr enden."
]
},
{
"cell_type": "markdown",
"id": "ab6a88cd-c603-46a5-8fa3-cb8c77a68952",
"metadata": {},
"source": [
"## Boolesche Ausdrücke"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b61376eb-ab95-4247-ad8e-aad87a1e01b6",
"metadata": {},
"outputs": [],
"source": [
"from IPython.lib.display import YouTubeVideo\n",
"YouTubeVideo('https://www.youtube.com/watch?v=ucsv_Nhhxmk&list=PL_pqkvxZ6ho3u8PJAsUU-rOAQ74D0TqZB&index=9')"
]
},
{
"cell_type": "markdown",
"id": "4b66e966-5e8b-413c-b038-6d1879248a8e",
"metadata": {},
"source": [
"Ein **boolescher Ausdruck** (Englisch: *boolean expression*) ist ein Ausdruck, der entweder wahr oder falsch ist. Die folgenden Beispiele nutzen den `==`-Operator, der zwei Operanden vergleicht und `True` zurückliefert, falls Sie gleich sind, und ansonsten `False`: "
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "85589d38",
"metadata": {},
"outputs": [],
"source": [
"5 == 5"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "3c9c8f61",
"metadata": {},
"outputs": [],
"source": [
"5 == 6"
]
},
{
"cell_type": "markdown",
"id": "d3ec6b48",
"metadata": {},
"source": [
"`True` und `False` sind zwei besondere Werte, die zum Datentyp `bool` gehören; sie sind keine Zeichenketten!"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "90fb1c9c",
"metadata": {},
"outputs": [],
"source": [
"type(True)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "c1cae572",
"metadata": {},
"outputs": [],
"source": [
"type(False)"
]
},
{
"cell_type": "markdown",
"id": "8990d025-0b98-41c2-a483-980cad2f2013",
"metadata": {},
"source": [
"Der `==`-Operator ist einer der sogenannten **relationalen Operatoren** (Englisch: *relational operator*); die anderen sind:\n",
"\n",
"```python\n",
"x != y # x ist ungleich y\n",
"x > y # x ist größer als y\n",
"x < y # x ist kleiner als y\n",
"x >= y # x ist größer oder gleich y\n",
"x <= y # x ist kleiner oder gleich y\n",
"```\n",
"\n",
"Auch wenn Ihnen diese Symbole wahrscheinlich bekannt vorkommen, so sind sie doch anders als ihre mathematischen Äquivalente. **Ein üblicher Fehler ist, das einfache Gleichheitszeichen (`=`) statt des doppelten Gleichheitszeichens (`==`) zu verwenden.** \n",
"\n",
"Wir merken uns: `=` ist der *Zuweisungsoperator* und `==` ist ein *relationaler Operator*:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "c0e51bcc",
"metadata": {},
"outputs": [],
"source": [
"x = 5\n",
"y = 7"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "a6be44db",
"metadata": {},
"outputs": [],
"source": [
"x == y"
]
},
{
"cell_type": "markdown",
"id": "c3fab685-d90d-403c-b854-8aac15eac525",
"metadata": {},
"source": [
"Die Operatoren `=<` und `=>` gibt es nicht.\n",
"\n",
"\n",
"\n",
"([Formal Logic](https://xkcd.com/1033/), Randall Munroe) [Erklärung des Comics](https://www.explainxkcd.com/wiki/index.php/1033:_Formal_Logic) falls Sie mehr erfahren möchten."
]
},
{
"cell_type": "markdown",
"id": "676f6f6d-e8df-4a76-a34c-785b1a46a8a8",
"metadata": {},
"source": [
"## Logische Operatoren"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "70476000-66e5-4602-982f-f2dc81033713",
"metadata": {},
"outputs": [],
"source": [
"from IPython.lib.display import YouTubeVideo\n",
"YouTubeVideo('https://www.youtube.com/watch?v=075l6R42tkQ&list=PL_pqkvxZ6ho3u8PJAsUU-rOAQ74D0TqZB&index=12')"
]
},
{
"cell_type": "markdown",
"id": "e13600da-c5a5-4825-8042-d6a4ecca3886",
"metadata": {},
"source": [
"Um boolesche Werte zu Ausdrücken zu kombinieren, können wir **logische Operatoren** verwenden.\n",
"Die geläufigsten dieser Operatoren sind `and`, `or` und `not`.\n",
"Die Bedeutung dieser Operatoren ähnelt deren Bedeutung in der englischen Sprache.\n",
"Der Wert des folgenden Ausdrucks ist zum Beispiel nur dann `True`, wenn `x` größer als `0` *und* kleiner als `10` ist:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "848c5f2c",
"metadata": {},
"outputs": [],
"source": [
"x > 0 and x < 10"
]
},
{
"cell_type": "markdown",
"id": "e8c14026",
"metadata": {},
"source": [
"Der folgende Ausdruck ist `True` wenn *entweder eine oder beide* der Bedingungen zutreffen, also wenn die Zahl durch `2` *oder* `3` teilbar ist:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "eb66ee6a",
"metadata": {},
"outputs": [],
"source": [
"x % 2 == 0 or x % 3 == 0"
]
},
{
"cell_type": "markdown",
"id": "3bd0ef52",
"metadata": {},
"source": [
"Zuletzt gibt es noch den`not`-Operator, der einen booleschen Ausdruck negiert. Der folgende Ausdruck ist also `True` wenn `x > y` `False` ist:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "6de8b97c",
"metadata": {},
"outputs": [],
"source": [
"not x > y"
]
},
{
"cell_type": "markdown",
"id": "fc6098c2",
"metadata": {},
"source": [
"Streng genommen sollten die Operanden eines logischen Operators boolesche Ausdrücke sein, Python ist hier aber nicht besonders strikt.\n",
"Jede Zahl, die nicht Null ist, wird als `True` interpretiert:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "add63275",
"metadata": {},
"outputs": [],
"source": [
"42 and True"
]
},
{
"cell_type": "markdown",
"id": "102ceab9",
"metadata": {},
"source": [
"Diese Flexibilität kann praktisch sein, ist in ihren Feinheiten aber möglicherweise auch verwirrend.\n",
"Daher kann es besser sein, sie komplett zu vermeiden."
]
},
{
"cell_type": "markdown",
"id": "351fb9ed-df49-42d9-8dd3-9ece45f9961a",
"metadata": {},
"source": [
"## `if`-Anweisungen"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b1135cac-a111-42f5-83bf-55e66105c025",
"metadata": {},
"outputs": [],
"source": [
"from IPython.lib.display import YouTubeVideo\n",
"YouTubeVideo('https://www.youtube.com/watch?v=b6KzYbM-Hvg&list=PL_pqkvxZ6ho3u8PJAsUU-rOAQ74D0TqZB&index=10')"
]
},
{
"cell_type": "markdown",
"id": "e4f08ecb-8d74-4e2e-b3fa-ead6a1298b19",
"metadata": {},
"source": [
"Um nützliche Programme zu schreiben, benötigen wir fast immer die Möglichkeit, **Bedingungen** (Englisch: *condition*) zu prüfen und das Verhalten des Programms entsprechend anzupassen. **Verzweigungen** (Englisch: *conditional statements*) ermöglichen uns dies. Die einfachste Form ist die `if`-Anweisung:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "80937bef",
"metadata": {},
"outputs": [],
"source": [
"x = 4\n",
"\n",
"if x > 0:\n",
" print(x, 'ist eine positive Zahl')"
]
},
{
"cell_type": "markdown",
"id": "973f705e",
"metadata": {},
"source": [
"`if` ist ein Schlüsselwort in Python.\n",
"\n",
"`if`-Anweisungen haben die gleiche Struktur wie Funktionsdefinitionen: ein (Verzweigungs-)Kopf, gefolgt von einem eingerückten (Verzweigungs-)Rumpf. Anweisungen dieser Art werden **Verbundanweisungen** (Englisch: *block*) genannt. \n",
"\n",
"Der boolesche Ausdruck hinter `if` heißt **Bedingung**. Wenn die Bedingung wahr ist, wird die eingerückte Anweisung ausgeführt. Falls nicht, passiert nichts.\n",
"\n",
"Die Anzahl an Anweisungen, die im Rumpf stehen können, ist nicht begrenzt, es muss aber mindestens eine sein. Manchmal ist es nützlich, einen Rumpf ohne Anweisungen zu haben (üblicherweise als Platzhalter für Code, den wir noch schreiben wollen). In diesem Fall können wir die `pass`-Anweisung verwenden, die nichts tut:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "bc74a318",
"metadata": {},
"outputs": [],
"source": [
"if x < 0:\n",
" pass # TODO: Behandlung negativer Werte implementieren!"
]
},
{
"cell_type": "markdown",
"id": "adf3f6c5",
"metadata": {},
"source": [
"Das Wort `TODO` als Kommentar wird üblicherweise als Erinnerung verwendet, dass an dieser Stelle später noch etwas bearbeitet werden muss."
]
},
{
"cell_type": "markdown",
"id": "435156b2-8c96-41ad-a1b5-bc897a7c6730",
"metadata": {},
"source": [
"## Der `else`-Teil"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "e463d031-72fa-4de6-aaa2-c3a06d6e1ec6",
"metadata": {},
"outputs": [],
"source": [
"from IPython.lib.display import YouTubeVideo\n",
"YouTubeVideo('https://www.youtube.com/watch?v=b6KzYbM-Hvg&list=PL_pqkvxZ6ho3u8PJAsUU-rOAQ74D0TqZB&index=11')"
]
},
{
"cell_type": "markdown",
"id": "81286579-dc84-463d-b3b2-4fb1caf28ab3",
"metadata": {},
"source": [
"Eine `if`-Anweisung kann einen zweiten Teil haben, der `else`-Teil genannt wird. Die Syntax sieht so aus:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "d16f49f2",
"metadata": {},
"outputs": [],
"source": [
"if x % 2 == 0:\n",
" print(\"x ist gerade\")\n",
"else:\n",
" print(\"x ist ungerade\") "
]
},
{
"cell_type": "markdown",
"id": "e7dc8943",
"metadata": {},
"source": [
"Wenn die Bedingung erfüllt (wahr) ist, wird die erste Anweisung ausgeführt; ansonsten läuft die zweite eingerückte Anweisung ab.\n",
"\n",
"Wenn der Rest bei der Division von `x` durch `2` gleich Null ist, dann wissen wir, dass `x` eine gerade Zahl ist und das Programm gibt eine entsprechende Meldung aus. Wenn die Bedingung falsch ist, wird die zweite Anweisung ausgeführt. \n",
"\n",
"Da die Bedingung entweder wahr oder falsch sein muss, wird genau eine der Alternativen ausgeführt. Diese Alternativen werden **Zweige** genannt, denn sie erzeugen eine Verzweigung im Kontrollfluss. "
]
},
{
"cell_type": "markdown",
"id": "20c8adb6",
"metadata": {},
"source": [
"## Verkettete Verzweigungen\n",
"\n",
"Manchmal gibt es mehr als zwei Möglichkeiten und wir benötigen mehr als zwei Zweige. Eine Möglichkeit eine Berechnung dieser Art auszudrücken, sind sogenannte **verkettete Verzweigungen** (Englisch: *chained conditional*):"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "309fccb8",
"metadata": {},
"outputs": [],
"source": [
"x = 2\n",
"y = 3\n",
"\n",
"if x < y:\n",
" print(x, 'ist kleiner als', y)\n",
"elif x > y:\n",
" print(x, 'ist größer als', y)\n",
"else:\n",
" print(x, 'und', y, 'sind gleich')"
]
},
{
"cell_type": "markdown",
"id": "46916379",
"metadata": {},
"source": [
"`elif` ist eine Abkürzung für `else if`. Wieder wird nur genau ein Zweig ausgeführt. Es gibt keine Begrenzung für die Anzahl der `elif`-Anweisungen. Falls es einen `else`-Teil gibt, so muss dieser am Ende stehen, es muss aber keinen geben:\n",
"\n",
"```python\n",
"if choice == 'a':\n",
" draw_a()\n",
"elif choice == 'b':\n",
" draw_b()\n",
"elif choice == 'c':\n",
" draw_c()\n",
"```\n",
"\n",
"Jede Bedingung wird in der vorgegebenen Reihenfolge geprüft. Wenn die erste nicht erfüllt (falsch) ist, wird die nächste geprüft, und so weiter. Sobald eine der Bedingungen erfüllt (wahr) ist, wird der entsprechende Zweig ausgeführt und die `if`-Anweisung wird beendet. **Auch wenn mehr als eine Bedingung erfüllt ist, wird nur der erste zutreffende Zweig ausgeführt.**"
]
},
{
"cell_type": "markdown",
"id": "e0c0b9dd",
"metadata": {},
"source": [
"## Verschachtelte Verzweigungen\n",
"\n",
"Eine Verzweigung kann auch mit einer anderen verschachtelt sein. Wir könnten das Beispiel vom vorherigen Abschnitt auch so schreiben:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "d77539cf",
"metadata": {},
"outputs": [],
"source": [
"if x == y:\n",
" print(x, 'und', y, 'sind gleich')\n",
"else:\n",
" if x < y:\n",
" print(x, 'ist kleiner als', y)\n",
" else:\n",
" print(x, 'ist größer als', y)"
]
},
{
"cell_type": "markdown",
"id": "29f67a0a",
"metadata": {},
"source": [
"Die äußere Verzweigung hat zwei Zweige: \n",
"- Der erste Zweig enthält eine einfache `print`-Anweisung.\n",
"- Der zweite Zweig enthält eine weitere `if`-Anweisung, die selbst zwei Zweige hat. Diese beiden Zweige sind beide einfache Anweisungen; sie könnten aber ebenfalls Verzweigungen enthalten.\n",
"\n",
"Auch wenn die Einrückung der Anweisungen die Struktur offensichtlich macht, werden **verschachtelte Verzweigungen** schnell schwer lesbar. Daher ist es eine gute Idee, sie wenn möglich zu vermeiden.\n",
"\n",
"Boolesche Operatoren bieten uns oft die Möglichkeit, verschachtelte Verzweigungen zu vereinfachen. Beispielsweise können wir den folgenden Code in eine einfache Verzweigung umschreiben:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "91cac1a0",
"metadata": {},
"outputs": [],
"source": [
"if 0 < x:\n",
" if x < 10:\n",
" print(x, 'ist eine positive einstellige Zahl.')"
]
},
{
"cell_type": "markdown",
"id": "5292eb11",
"metadata": {},
"source": [
"Die `print`-Anweisung wird nur ausgeführt, wenn beide Bedingungen erfüllt sind. Daher können wir den gleichen Effekt mit Hilfe des `and`-Operators erzeugen:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "f8ba1724",
"metadata": {},
"outputs": [],
"source": [
"if 0 < x and x < 10:\n",
" print(x, 'ist eine positive einstellige Zahl.')"
]
},
{
"cell_type": "markdown",
"id": "dd8e808a",
"metadata": {},
"source": [
"Für diese Art der Bedingung bietet Python sogar eine noch kürzere Schreibweise:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "014cd6f4",
"metadata": {},
"outputs": [],
"source": [
"if 0 < x < 10:\n",
" print(x, 'ist eine positive einstellige Zahl.')"
]
},
{
"cell_type": "markdown",
"id": "495227bc-589d-4d90-bbf0-3fe31ff481b7",
"metadata": {},
"source": [
"Schreiben Sie die folgende verschachtelte Verzweigung so um, dass nur noch eine Verzweigung verwendet wird:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "c608d757-e04a-459d-8506-46ee66640dfe",
"metadata": {},
"outputs": [],
"source": [
"if x % 2 == 0:\n",
" if x % 4 == 0:\n",
" print(x, \"ist durch 2 und 4 teilbar\")\n",
" else:\n",
" print(x, \"ist nicht durch 2 und nicht durch 4 teilbar\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "f95a2ca1-3da2-4977-a7ae-b3b1850f72cd",
"metadata": {},
"outputs": [],
"source": [
"# Fügen Sie hier Ihren Code ein"
]
},
{
"cell_type": "markdown",
"id": "db583cd9",
"metadata": {},
"source": [
"## Rekursion\n",
"\n",
"Es ist erlaubt, dass eine Funktion eine andere aufruft; es ist auch erlaubt, dass die Funktion sich selbst aufruft. Es ist vielleicht nicht offensichtlich, warum das eine gute Idee ist, aber es ist eines der \"magischsten\" Dinge, die ein Program tun kann. Schauen wir uns beispielsweise die folgende Funktion an:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "17904e98",
"metadata": {},
"outputs": [],
"source": [
"def countdown(n):\n",
" if n <= 0:\n",
" print(\"Abheben!\")\n",
" else:\n",
" print(n)\n",
" countdown(n-1)"
]
},
{
"cell_type": "markdown",
"id": "c88e0dc7",
"metadata": {},
"source": [
"Wenn `n` Null oder negativ ist, gibt die Funktion \"Abheben!\" aus. Ansonsten wird `n` ausgegeben und eine Funktion `countdown` - die Funktion selbst - aufgerufen mit `n-1` als Argument. \n",
"\n",
"Was passiert, wenn wir diese Funktion folgendermaßen aufrufen?"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "6c1e32e2",
"metadata": {},
"outputs": [],
"source": [
"countdown(3)"
]
},
{
"cell_type": "markdown",
"id": "3f3c87ec",
"metadata": {},
"source": [
"Die Ausführung von `countdown` beginnt mit `n=3`. Da `n` größer als 0 ist, wird der Wert 3 ausgegeben und die Funktion ruft sich selbst auf ...\n",
"\n",
"> Die Ausführung von `countdown` beginnt mit `n=2`. Da `n` größer als 0 ist, wird der Wert 2 ausgegeben und die Funktion ruft sich selbst auf ...\n",
">\n",
"> > Die Ausführung von `countdown` beginnt mit `n=1`. Da `n` größer als 0 ist, wird der Wert 1 ausgegeben und die Funktion ruft sich selbst auf ...\n",
"> >\n",
"> > > Die Ausführung von `countdown` beginnt mit `n=0`. Da `n` nicht größer als 0 ist, wird \"Abheben!\" ausgegeben und zurückgesprungen.\n",
"> >\n",
"> > Die Funktion `countdown` mit `n=1` springt zurück.\n",
">\n",
"> Die Funktion `countdown` mit `n=2` springt zurück.\n",
"\n",
"Die Funktion `countdown` mit `n=3` springt zurück.\n",
"\n",
"Und damit sind wir zurück im `__main__`. Die Ausgabe des Aufrufs sieht damit so aus:\n",
"\n",
"```\n",
"3\n",
"2\n",
"1\n",
"Abheben!\n",
"```\n",
"\n",
"Eine Funktion die sich selbst aufruft wird **rekursiv** genannt; der Vorgang wird **Rekursion** genannt.\n",
"\n",
"**Es ist wichtig, dass Sie dieses Beispiel verstanden haben. Falls das nicht der Fall sein sollte, lassen Sie es sich von Ihrem/Ihrer Partner$*$in, Kommiliton$*$in oder Übungsleiter$*$in erklären.**\n",
"\n",
"Eine gute Hilfe ist außerdem diese Webseite: http://www.pythontutor.com.\n",
"Dort können Sie ihren Python Code hochladen und Schritt für Schritt durchführen. \n",
"Probieren Sie es mit der Funktion countdown() aus *(Achtung: Sie müssen die Funktion dort erst definieren und dann auch aufrufen)*.\n",
"\n",
"Als weiteres Beispiel schreiben wir eine Funktion, die eine Zeichenkette `n`-mal ausgibt:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "1bb13f8e",
"metadata": {},
"outputs": [],
"source": [
"def print_n_times(string, n):\n",
" if n > 0:\n",
" print(string)\n",
" print_n_times(string, n-1)"
]
},
{
"cell_type": "markdown",
"id": "73d07c17",
"metadata": {},
"source": [
"Wenn `n` positiv ist, stellt `print_n_times` den Wert von `string` dar und ruft sich im Anschluss selbst auf, wobei `string` und `n-1` als Argumente weitergegeben werden.\n",
"\n",
"Wenn `n` `0` oder negativ ist, wird die Bedingung nicht erfüllt (ist false) und `print_n_times` tut nichts.\n",
"\n",
"Das funktioniert folgendermaßen:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "e7b68c57",
"metadata": {},
"outputs": [],
"source": [
"print_n_times('Spam ', 4)"
]
},
{
"cell_type": "markdown",
"id": "1fb55a78",
"metadata": {},
"source": [
"Für solche einfachen Beispiele wäre es wohl einfacher, eine `for`-Schleife zu verwenden. Aber wir werden später Beispiele sehen, die zwar eher schwierig mit einer `for`-Schleife zu implementieren sind, jedoch sehr einfach mittels Rekursion. "
]
},
{
"cell_type": "markdown",
"id": "18e917a0-7692-47af-802c-ef5c3def21a5",
"metadata": {},
"source": [
" \n",
"\n",
"([Tabletop Roleplaying](https://xkcd.com/244/), Randall Munroe) [Erklärung des Comics](https://www.explainxkcd.com/wiki/index.php/244:_Tabletop_Roleplaying) falls Sie mehr wissen möchten. "
]
},
{
"cell_type": "markdown",
"id": "c652c739",
"metadata": {},
"source": [
"## Stapeldiagramme für rekursive Funktionen\n",
"\n",
"In [Abschnitt 3](seminar03.ipynb#Stapel-Diagramme) haben wir Stapeldiagramme genutzt, um den Zustand eines Programms während eines Funktionsaufrufs zu repräsentieren. Die gleiche Art Diagramm kann uns helfen, eine rekursive Funktion zu interpretieren.\n",
"\n",
"Jedes Mal, wenn eine Funktion aufgerufen wird, erstellt Python einen Block, der die lokalen Variablen und Parameter der Funktion enthält. Für eine rekursive Funktion kann es zur gleichen Zeit mehrere Blöcke auf dem Stapel geben.\n",
"\n",
"Das folgende Stapeldiagramm zeigt die Blöcke die beim Aufruf von `countdown` mit `n = 3 ` erzeugt werden:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "643148da",
"metadata": {
"tags": [
"remove-input"
]
},
"outputs": [],
"source": [
"from diagram import make_frame, Stack\n",
"\n",
"frames = []\n",
"for n in [3,2,1,0]:\n",
" d = dict(n=n)\n",
" frame = make_frame(d, name='countdown', dy=-0.3, loc='left')\n",
" frames.append(frame)\n",
"\n",
"stack = Stack(frames, dy=-0.5)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "a8510119",
"metadata": {
"tags": [
"remove-input"
]
},
"outputs": [],
"source": [
"from diagram import diagram, adjust\n",
"\n",
"\n",
"width, height, x, y = [1.74, 2.04, 1.05, 1.77]\n",
"ax = diagram(width, height)\n",
"bbox = stack.draw(ax, x, y)\n",
"# adjust(x, y, bbox)"
]
},
{
"cell_type": "markdown",
"id": "9282331b",
"metadata": {},
"source": [
"Die vier Blöcke für `countdown` haben unterschiedliche Werte für den Parameter `n`. Der Block am Boden des Stapels, wo `n=0` ist, wird **Basisfall** (Englisch: *base case*) genannt. In diesem gibt es keinen rekursiven Aufruf, daher gibt es keine weiteren Blöcke. Dies ist gleichzeitig die **Abbruchbedingung** (Englisch: *termination condition*) für die Rekursion."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "a2a376b3",
"metadata": {
"tags": [
"remove-cell"
]
},
"outputs": [],
"source": [
"from diagram import make_frame, Stack\n",
"from diagram import diagram, adjust\n",
"\n",
"frames = []\n",
"for n in [2,1,0]:\n",
" d = dict(string='Hello', n=n)\n",
" frame = make_frame(d, name='print_n_times', dx=1.3, loc='left')\n",
" frames.append(frame)\n",
"\n",
"stack = Stack(frames, dy=-0.5)\n",
"\n",
"width, height, x, y = [3.53, 1.54, 1.54, 1.27]\n",
"ax = diagram(width, height)\n",
"bbox = stack.draw(ax, x, y)\n",
"# adjust(x, y, bbox)"
]
},
{
"cell_type": "markdown",
"id": "3872caa8-c17a-4792-869e-35b006cbb867",
"metadata": {},
"source": [
"Schreiben Sie dann eine Funktion `do_n`, die ein Funktionsobjekt und eine ganze Zahl `n` als Parameter erwartet und dann die übergebene Funktion `n`-mal aufruft. *(Funktionsobjekte wurden im [3. Kapitel](seminar03.ipynb) erklärt und dort beispielsweise in [Aufgabe 2](seminar03.ipynb#Aufgabe-2) verwendet.)* "
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "591d684e-e907-41af-9688-63a7b4194683",
"metadata": {},
"outputs": [],
"source": [
"# implementieren Sie hier die Funktion do_n\n",
"def do_n(f, n):\n",
" pass # Löschen Sie diese Zeile, wenn Sie anfangen, die Funktion zu implementieren\n",
"\n",
"\n",
"# eine Testfunktion\n",
"def testfunktion():\n",
" print(\"Ich wurde aufgerufen!\")\n",
"\n",
"# Funktionsaufruf von do_n\n",
"do_n(testfunktion, 7)"
]
},
{
"cell_type": "markdown",
"id": "37bbc2b8",
"metadata": {},
"source": [
"## Unendliche Rekursion\n",
"\n",
"Wenn die Rekursion niemals den Basisfall erreicht, werden immer wieder rekursive Aufrufe getätigt und das Programm wird nicht beendet. Dies wird **unendliche Rekursion** (Englisch: *infinite recursion*) genannt und ist im Allgemeinen keine gute Idee. Das hier ist ein minimales Programm mit unendlicher Rekursion:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "af487feb",
"metadata": {},
"outputs": [],
"source": [
"def recurse():\n",
" recurse()"
]
},
{
"cell_type": "markdown",
"id": "450a20ac",
"metadata": {},
"source": [
"Jedes Mal, wenn `recurse` aufgerufen wird, ruft es sich selbst auf, was einen weiteren Block erstellt.\n",
"In Python gibt es ein Limit für die Menge an Blöcken, die gleichzeitig auf dem Stapel sein können.\n",
"Wenn ein Programm dieses Limit überschreitet, verursacht das einen Laufzeit-Fehler:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "db382901-b669-4978-a9bb-195f491d7b23",
"metadata": {
"tags": [
"remove-cell"
]
},
"outputs": [],
"source": [
"%%expect RecursionError\n",
"%xmode Context\n",
"\n",
"recurse()"
]
},
{
"cell_type": "markdown",
"id": "39fc5c31",
"metadata": {},
"source": [
"Dieser Traceback ist etwas größer als der, den wir im vorherigen Kapitel gesehen haben. Wenn der Fehler auftritt, befinden sich 3000 `recurse`-Blöcke auf dem Stapel!\n",
"\n",
"Wenn bei ihnen eine ungewollte unendliche Rekursion auftritt, überprüfen Sie Ihre Funktion und stellen Sie sicher, dass es einen Basisfall gibt, der keinen rekursiven Aufruf tätigt. Und wenn es einen Basisfall gibt, überprüfen Sie, ob er garantiert erreicht wird.\n",
"\n",
"\n",
"\n",
"([Wolfgang Beyer](https://commons.wikimedia.org/wiki/File:Mandel_zoom_07_satellite.jpg))"
]
},
{
"cell_type": "markdown",
"id": "755a204d-cc0c-42e8-b2d4-5c3d9a6afd78",
"metadata": {},
"source": [
"## Tastatur-Eingaben"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "ead62f89-31ec-45ec-bda1-0a8c27448366",
"metadata": {},
"outputs": [],
"source": [
"from IPython.lib.display import YouTubeVideo\n",
"YouTubeVideo('https://www.youtube.com/watch?v=I9h1c-121Uk&list=PL_pqkvxZ6ho3u8PJAsUU-rOAQ74D0TqZB&index=6')"
]
},
{
"cell_type": "markdown",
"id": "e396ec29-e0cd-4cdb-bfea-be0743478dc1",
"metadata": {},
"source": [
"Die meisten Programme, die wir bisher geschrieben haben, akzeptieren keine Eingaben durch die Nutzerin. Sie erledigen jedesmal die gleiche Aufgabe. \n",
"\n",
"Python bietet eine eingebaute Funktion namens `input` die das Programm pausiert und darauf wartet, dass der Nutzer etwas eintippt. Wenn der Nutzer *Return* oder *Enter* drückt, fährt das Programm fort und `input` gibt was immer der Nutzer eingetippt hat als Zeichenkette zurück:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "f6a2e4d6",
"metadata": {},
"outputs": [],
"source": [
"text = input()"
]
},
{
"cell_type": "markdown",
"id": "acf9ec53",
"metadata": {},
"source": [
"Bevor man von der Nutzerin eine Eingabe bekommt, ist es eine gute Idee, einen Hinweis auszugeben, der der Nutzerin sagt, was Sie eintippen soll. Der Funktion `input` können wir einen solchen Hinweis als Argument übergeben: "
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "964346f0",
"metadata": {},
"outputs": [],
"source": [
"name = input(\"Wie lautet Ihr Name?\\n\")\n",
"name"
]
},
{
"cell_type": "markdown",
"id": "1b754b39",
"metadata": {},
"source": [
"Die Folge `\\n` am Ende des Hinweises repräsentiert einen **Zeilenumbruch** (Englisch: *newline*) - ein spezielles Zeichen, welches einen Zeilenumbruch bewirkt. Aus diesem Grund erscheint die Eingabe des Nutzers unter dem Hinweis.\n",
"\n",
"Falls wir erwarten, dass der Nutzer eine ganze Zahl eintippt, können wir versuchen, die Eingabe in eine ganze Zahl umzuwandeln:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "60a484d7",
"metadata": {},
"outputs": [],
"source": [
"prompt = \"Wie hoch ist die Fluggeschwindigkeit einer unbeladenen Schwalbe?\\n\"\n",
"speed = input(prompt)\n",
"speed = int(speed)\n",
"speed"
]
},
{
"cell_type": "markdown",
"id": "0a65f2af",
"metadata": {},
"source": [
"Wenn der Nutzer etwas anderes als eine Zeichenkette mit Ziffern eintippt (z.B. `eine afrikanische oder eine europäische Schwalbe?`), erhalten wir einen Fehler:\n",
"\n",
"```\n",
"ValueError: invalid literal for int() with base 10: 'Eine afrikanische oder eine europäische Schwalbe?'\n",
"```\n"
]
},
{
"cell_type": "markdown",
"id": "a4ce3ed5",
"metadata": {},
"source": [
"Wir werden später sehen, wie wir diese Art von Fehler behandeln können."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "0aceee1a-6f09-4356-aaa9-70e6d59085e1",
"metadata": {},
"outputs": [],
"source": [
"from IPython.lib.display import YouTubeVideo\n",
"YouTubeVideo('https://www.youtube.com/watch?v=I9h1c-121Uk&list=PL_pqkvxZ6ho3u8PJAsUU-rOAQ74D0TqZB&index=6')"
]
},
{
"cell_type": "markdown",
"id": "14c1d3dc",
"metadata": {},
"source": [
"### Debugging\n",
"\n",
"Wenn ein Syntax- oder Laufzeitfehler auftritt, enthält die Fehlermeldung oft eine überwältigende Menge an Information. Die hilfreichsten Teile davon sind üblicherweise:\n",
"- Welcher Art von Fehler aufgetreten ist und\n",
"- wo der Fehler aufgetreten ist.\n",
"\n",
"Syntaxfehler sind üblicherweise leichter zu finden, aber es gibt ein paar knifflige Fälle. Probleme mit Leerzeichen können schwierig zu finden sein, denn Leerzeichen (und auch Tabs) sind unsichtbar und wir ignorieren sie üblicherweise:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b82642f6",
"metadata": {
"tags": [
"raises-exception"
]
},
"outputs": [],
"source": [
"%%expect IndentationError\n",
"x = 5\n",
" y = 6"
]
},
{
"cell_type": "markdown",
"id": "d1d06263",
"metadata": {},
"source": [
"In diesem Beispiel ist das Problem, dass die zweite Zeile durch ein Leerzeichen eingerückt ist. Aber die Fehlermeldung zeigt auf `y`, was verwirrend ist. Im allgemeinen gibt eine Fehlermeldung an, wo das Problem entdeckt wurde, aber der tatsächliche Fehler kann sich weiter vorne im Code befinden, manchmal auch in der vorhergehenden Zeile.\n",
"\n",
"Das gleiche gilt für Laufzeitfehler. Angenommen, wir versuchen das Signal-Rausch-Verhältnis in Dezibel zu berechnen. Die Formel dafür ist $SNR_{db} = 10\\log_{10}(P_{signal}/P_{noise})$. In Python könnten wir das so aufschreiben:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "583ef53c",
"metadata": {
"tags": [
"remove-cell"
]
},
"outputs": [],
"source": [
"%xmode Context"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "2f4b6082",
"metadata": {
"tags": [
"raises-exception"
]
},
"outputs": [],
"source": [
"%%expect ValueError\n",
"import math\n",
"signal_power = 9\n",
"noise_power = 10\n",
"ratio = signal_power // noise_power\n",
"decibels = 10 * math.log10(ratio)\n",
"print(decibels)"
]
},
{
"cell_type": "markdown",
"id": "55914374",
"metadata": {},
"source": [
"Wenn wir dieses Programm ausführen, erhalten wir einen Fehler:\n",
"\n",
"```\n",
"Traceback (most recent call last)\n",
"<ipython-input-53-b5706bfbb8ff> in <module>()\n",
" 3 noise_power = 10\n",
" 4 ratio = signal_power // noise_power\n",
"----> 5 decibels = 10 * math.log10(ratio)\n",
" 6 print(decibels)\n",
"\n",
"ValueError: math domain error\n",
"```\n",
"\n",
"Die Fehlermeldung gibt Zeile 5 an, aber in dieser Zeile befindet sich kein Fehler. Um den tatsächlichen Fehler zu finden könnte es hilfreich sein, den Wert von `ratio` mit Hilfe der `print`-Funktion auszugeben. Tatsächlich ist der Wert 0. Das Problem ist also in Zeile 4, da dort Ganzzahldivision statt Gleitkommadivision genutzt wird.\n",
"\n",
"Sie sollten sich die Zeit nehmen und Fehlermeldungen sorgfältig durchlesen aber nicht davon ausgehen, dass alles was darin steht richtig ist."
]
},
{
"cell_type": "markdown",
"id": "8ffe690e",
"metadata": {},
"source": [
"## Glossar\n",
"\n",
"Legen wir uns eine Liste mit den wichtigsten Begriffen an, die wir im Kapitel 5 gelernt haben:\n",
"- Rekursion:\n",
"- Modulo (Restoperator): Ein Operator, bezeichnet durch ein Prozentzeichen (`%`), der auf ganzen Zahlen operiert und als Ergebnis den Rest zurückliefert, der sich bei Division der einen durch die andere Zahl ergibt.\n",
"- Boolescher Ausdruck:\n",
"- relationaler Operator:\n",
"- logischer Operator:\n",
"- Bedingung:\n",
"- Verzweigung:\n",
"- Verbundanweisung:\n",
"- Zweig:\n",
"- verkettete Verzweigung:\n",
"- verschachtelte Verzweigung:\n",
"- Basisfall:\n",
"- unendliche Rekursion:\n",
"- Zeilenumbruch:\n",
"\n",
"Ergänzen Sie die Liste in eigenen Worten. Das ist eine gute Erinnerungs- und Übungsmöglichkeit."
]
},
{
"cell_type": "markdown",
"id": "8d783953",
"metadata": {},
"source": [
"## Übung"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "66aae3cb",
"metadata": {
"tags": [
"remove-print"
]
},
"outputs": [],
"source": [
"# Diese Zelle weist Jupyter an, detallierte Debugging-Informationen auszugeben, wenn ein Laufzeitfehler\n",
"# passiert. Lassen Sie sie daher laufen, bevor Sie beginnen an den Aufgaben zu arbeiten.\n",
"\n",
"%xmode Verbose\n"
]
},
{
"cell_type": "markdown",
"id": "02f9f1d7",
"metadata": {},
"source": [
"### Fragen Sie einen virtuellen Assistenten\n",
"\n",
"* Fragen Sie einen virtuellen Assistenten: \"Was sind einige Anwendungsfälle des Modulo-Operators?\"\n",
"\n",
"* Python bietet Operatoren, um die logischen Operationen `and`, `or` und `not` auszuführen, es gibt allerdings keinen Operator für das exklusive `or`, das meist als `xor` dargestellt wird. Fragen Sie einen Assistenten: \"Was ist eine logische xor Operation und wie berechne ich sie in Python?\"\n",
"\n",
"In diesem Kapitel haben wir uns zwei Varianten angesehen, `if`-Anweisungen mit drei Verzweigungen zu schreiben: mit einer verketteten oder einer verschachtelten Verzweigung.\n",
"Sie können einen virtuellen Assistenten verwenden, um eine der Varianten in die andere zu konvertieren.\n",
"Weisen Sie den VA beispielsweise an: \"Konvertiere diese Anweisung in eine verkettete Verweigung.\":"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "ade1ecb4",
"metadata": {
"tags": [
"remove-cell"
]
},
"outputs": [],
"source": [
"x = 5\n",
"y = 7"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "dc7026c2",
"metadata": {},
"outputs": [],
"source": [
"if x == y:\n",
" print('x sind gleich')\n",
"else:\n",
" if x < y:\n",
" print('x ist kleiner als y')\n",
" else:\n",
" print('x ist größer als y')"
]
},
{
"cell_type": "markdown",
"id": "9c2a8466",
"metadata": {},
"source": [
"Bitten Sie den VA: \"Schreibe diese Anweisung so um, dass sie nur noch eine Verzweigung enthält.\":"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "1fd919ea",
"metadata": {},
"outputs": [],
"source": [
"if 0 < x:\n",
" if x < 10:\n",
" print('x ist eine positive einstellige Zahl.')"
]
},
{
"cell_type": "markdown",
"id": "e0fbed08",
"metadata": {},
"source": [
"Testen Sie, ob der VA diese unnötig komplexe Anweisung vereinfachen kann:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "1e71702e",
"metadata": {},
"outputs": [],
"source": [
"if not x <= 0 and not x >= 10:\n",
" print('x ist eine positive einstellige Zahl.')"
]
},
{
"cell_type": "markdown",
"id": "74ef776d",
"metadata": {},
"source": [
"Hier ist ein Versuch, eine rekursive Funktion zu schreiben, die in Zweierschritten herunterzählt:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "84cbd5a4",
"metadata": {},
"outputs": [],
"source": [
"def countdown_by_two(n):\n",
" if n == 0:\n",
" print('Blastoff!')\n",
" else:\n",
" print(n)\n",
" countdown_by_two(n-2)"
]
},
{
"cell_type": "markdown",
"id": "77178e79",
"metadata": {},
"source": [
"Er scheint zu funktionieren:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b0918789",
"metadata": {},
"outputs": [],
"source": [
"countdown_by_two(6)"
]
},
{
"cell_type": "markdown",
"id": "c9d3a8dc",
"metadata": {},
"source": [
"Allerdings enthält er einen Fehler. Fragen Sie einen virtuellen Assistenten, was falsch ist, und wie Sie den Code ausbessern können. \n",
"Fügen Sie die Lösung hier ein und testen Sie sie:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "e6e55ad0-8ff2-4d0f-90f6-a93f30cf687d",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"id": "240a3888",
"metadata": {},
"source": [
"### Aufgabe 1\n",
"\n",
"Das Modul `time` bietet eine Funktion, die ebenfalls `time` heißt, und die uns für die Zeitzone Greenwich Mean Time die Zeit (in Sekunden) zurückliefert, die seit einem Referenzpunkt vergangen ist. Der Referenzpunkt ist ziemlich willkürlich gewählt und ist meistens der 1. Januar 1970."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "1e7a2c07",
"metadata": {},
"outputs": [],
"source": [
"from time import time\n",
"\n",
"now = time()\n",
"now"
]
},
{
"cell_type": "markdown",
"id": "054c3197",
"metadata": {},
"source": [
"Schreiben Sie eine Funktion `print_time`, die die aktuelle Zeit mit Hilfe von `time` abfragt und diese in eine Tageszeit in Stunden, Minuten und Sekunden sowie die Anzahl der Tage die seit dem Referenzpunkt vergangen sind konvertiert und diese Werte ausgibt:\n",
"\n",
"Wie gehabt folgen hier einige Hinweise zu einer möglichen Lösung.\n",
"\n",
"\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-primary\">1. Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
"\n",
"Überlegen Sie zunächst wie der Zusammenhang zwischen Sekunden, Minuten, Stunden und Tagen aussieht. Wie viele Sekunden sind in einer Minute, wie viele Minuten sind in einer Stunde, wie viele Stunden sind in einem Tag?\n",
" \n",
" </div> \n",
"</details>\n",
"\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-primary\">2. Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
" \n",
"Wenn wir die Zeit seit dem Referenzzeitpunkt in sekunden haben, können wir damit ausrechnen, wie viele Minuten seit diesem Zeitpunkt vergangen sind. \n",
" \n",
" </div> \n",
"</details>\n",
"\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-primary\">3. Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
"\n",
" Wir verwenden Ganzzahldivision um die Anzahl in Minuten als ganze Zahl zu erhalten. Um zu lernen wie viele Sekunden dann noch übrig sind, führen wir eine Restberechnung durch. Dies ist die aktuelle Sekundenzahl für unsere Uhrzeit.\n",
" \n",
" </div> \n",
"</details>\n",
"\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-primary\">4. Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
"\n",
"Das ganze wird jetzt analog für die Anzahl and Stunden und Tagen seit dem Referenzzeitpunkt vorgenommen. Dabei wird die Uhrzeit über die Resteberechnung analog zur Sekundenzahl berechnet.\n",
"\n",
" </div> \n",
"</details>\n",
"\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-primary\">5. Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
"\n",
"Insgesamt werden 6 Berechnungen durchgeführt.\n",
"\n",
" </div> \n",
"</details>\n",
"\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-primary\">6. Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
"\n",
"Vergessen Sie nicht eine `print`-Anweisung zu schreiben, die Ihr Ergebnis ausgibt. Sie können ihr Ergebnis einfach überprüfen. Sie angegebene Zeit sollte genau eine Stunde (bzw. 2 Stunden bei mitteleuropäischer Sommerzeit) vor der aktuellen Zeit in Deutschland liegen.\n",
"\n",
" </div> \n",
"</details>\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "e1d88cc2-bdf7-4fee-b78f-12240ef7f77c",
"metadata": {},
"outputs": [],
"source": [
"import time\n",
"\n",
"\n",
"# Testaufruf\n",
"print_time()"
]
},
{
"cell_type": "markdown",
"id": "a26d4858-d933-433a-b8fe-450773a3c14b",
"metadata": {},
"source": [
"\n",
"\n",
"([2038](https://xkcd.com/607/), Randall Munroe) [Erklärung des Comics](https://www.explainxkcd.com/wiki/index.php/607:_2038) falls Sie mehr wissen möchten.\n",
"\n",
"\n",
"\n",
"([Spoiler Alert](https://xkcd.com/109/), Randall Munroe) [Erklärung des Comics](https://www.explainxkcd.com/wiki/index.php/109:_Spoiler_Alert) falls Sie mehr erfahren wollen."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "c5fa57b2",
"metadata": {},
"outputs": [],
"source": [
"def print_time():\n",
" total = time.time()\n",
" total_minutes = total//60\n",
" seconds = int(total % 60)\n",
" total_hours = total_minutes // 60\n",
" minutes = int(total_minutes % 60)\n",
" days = int(total_hours // 24)\n",
" hours = int(total_hours % 24)\n",
" \n",
" print(\"Es ist\", hours,\":\", minutes,\":\", seconds, \"Uhr.\", \"Es sind\", days, \"Tage seit dem Referenzzeitpunkt vergangen.\")\n",
" \n",
"print_time()"
]
},
{
"cell_type": "markdown",
"id": "310196ba",
"metadata": {
"tags": [
"remove-print"
]
},
"source": [
"Sie können unter <https://docs.python.org/3/library/time.html> mehr über das `time`-Modul lesen."
]
},
{
"cell_type": "markdown",
"id": "f792b093-83c9-493b-a3a5-7453d2ff9240",
"metadata": {},
"source": [
"### Aufgabe 2\n",
"\n",
"\n",
"\n",
"[Fermats letzter Satz](https://de.wikipedia.org/wiki/Gro%C3%9Fer_Fermatscher_Satz) besagt dass es keine positiven ganzen Zahlen $a, b$ und $c$ gibt, so dass\n",
"\\begin{equation}\n",
"a^n + b^n = c^n\n",
"\\end{equation}\n",
"für alle $n$ größer 2 gilt.\n",
"\n",
"1. Schreiben Sie eine Funktion `check_fermat` die vier Parameter erwartet – `a`, `b`, `c` und `n` – und prüft, ob Fermats letzter Satz gilt. Falls `n` größer als 2 ist und $a^n + b^n = c^n$ gilt, sollte das Programm \"Unglaublich, Fermat lag falsch!\" ausgeben, ansonsten \"Nein, das funktioniert nicht.\"\n",
"\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-primary\">1. Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
" \n",
"Schreiben Sie zunächst den Kopf der Funktion.\n",
" \n",
" </div> \n",
"</details>\n",
"\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-primary\">2. Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
" \n",
"Hier wollen wir testen, ob eine Aussage wahr oder falsch ist, daher verwenden wir eine einfache `if` Verzweigung.\n",
" \n",
" </div> \n",
"</details>\n",
"\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-primary\">3. Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
"\n",
"Die Formel, die hier genannt wird kann durch das Ersetzten des Gleichheitszeichens mit dem Vergleichsoperatoren `==` als Bedinung für die `if`-Verzeigung verwendet werden.\n",
" \n",
" </div> \n",
"</details>\n",
"\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-primary\">4. Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
"\n",
" Potenzen werden mit zwei Sternchen `**`dargestellt.\n",
"\n",
" </div> \n",
"</details>\n",
"\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-primary\">5. Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
"\n",
" Vergessen Sie nicht, die entsprechenden `print` Statements zu schreiben. \n",
" \n",
" </div> \n",
"</details>\n",
"\n",
"\n",
"2. Schreiben Sie eine Funktion, die den Nutzer bittet, Werte für `a, b, c` und `n` einzugeben, diese in ganze Zahlen umwandelt und dann die Funktion `check_fermat` nutzt, um zu prüfen, ob sie Fermats letzten Satz erfüllen. \n",
"\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-primary\">1. Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
" \n",
"Schreiben Sie den Kopf der Funktion und rufen Sie `check_fermat` innerhalb der Funktion auf. Die Variablen die wir übergeben wollen, werden wir im kommenden Schritt erzeugen.\n",
" \n",
" </div> \n",
"</details>\n",
"\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-primary\">2. Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
" \n",
"Die `input` Funktion sollte dem Nutzer mitteilen welche Werte sie eingeben dürfen, vergessen Sie daher nicht, einen Prompt zu schreiben.\n",
" \n",
" </div> \n",
"</details>\n",
"\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-primary\">3. Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
"\n",
"Der Input wird zunächst als eine Zeichenkette interpretiert, mit Hilfe von `int()` können Sie diese in eine ganze Zahl verwandeln.\n",
"\n",
" </div> \n",
"</details>\n",
"\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-primary\">4. Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
"\n",
"Schreiben Sie einen Input für jede der vier Zahlen und weisen sie diesen jeweils einer neuen Variablen zu. Diese sollten im `check_fermat` Aufruf stehen.\n",
" \n",
" </div> \n",
"</details>"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cda18ae7-b7cb-4b71-ab38-d2734a2ed14c",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"id": "4804fa5d-e06e-4bc2-ad5f-6e01f044cc76",
"metadata": {},
"source": [
"\n",
"\n",
"([Spoiler Alert](https://xkcd.com/109/), Randall Munroe) [Erklärung des Comics](https://www.explainxkcd.com/wiki/index.php/109:_Spoiler_Alert) falls Sie mehr erfahren wollen."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "a3bc7316-2a9c-4a44-b79e-1d0f3093bae9",
"metadata": {},
"outputs": [],
"source": [
"def check_fermat(a,b,c,n):\n",
" if a**n+b**n == c**n:\n",
" print (\"Unglaublich Fermat lag falsch\")\n",
" else: \n",
" print (\"Nein das Funktioniert nicht\")\n",
" "
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "48ccea1f-50bb-4718-a22b-060ae8ffecaf",
"metadata": {},
"outputs": [],
"source": [
"def fermat_in():\n",
" a = int(input (\"Bitte geben Sie eine ganze Zahl a ein \\n\"))\n",
" b = int(input (\"Bitte geben Sie eine ganze Zahl b ein \\n\")) \n",
" c = int(input (\"Bitte geben Sie eine ganze Zahl c ein \\n\"))\n",
" n = int(input (\"Bitte geben Sie die Potenz n ein \\n\"))\n",
" check_fermat(a,b,c,n)\n",
" \n",
"fermat_in()"
]
},
{
"cell_type": "markdown",
"id": "6b1fd514",
"metadata": {},
"source": [
"### Aufgabe 3\n",
"\n",
"Wenn uns drei Stöcke gegeben werden, kann es sein, dass wir sie als Dreieck anordnen können oder auch nicht. Wenn beispielsweise einer der Stöcke 12cm lang ist und die anderen beiden jeweils 1cm, dann klappt es nicht. Für jede Kombination von Längen gibt es einen einfachen Test, der uns anzeigt, ob sich daraus ein Dreieck formen lässt:\n",
"\n",
"*Falls eine der drei Längen größer als die Summe der anderen beiden Längen ist, dann lässt sich kein Dreieck formen. (Wenn die Summe der beiden Längen gleich der dritten Länge ist, dann bilden Sie ein sogenanntes \"degeneriertes\" Dreieck.)*\n",
"\n",
"1. Schreiben Sie eine Funktion `is_triangle` die drei ganze Zahlen als Argumente erwartet und dann entweder \"Ja\" oder \"Nein\" ausgibt, abhängig davon, ob man mit den gegebenen Längen ein Dreieck formen kann oder nicht.\n",
"\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-primary\">1. Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
"Schreiben Sie den Kopf der Funktion.\n",
" </div> \n",
"</details>\n",
"\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-primary\">2. Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
" \n",
"Wie viele Tests müssen wir schreiben, um zu prüfen ob eine der drei Längen die Bedingungen für ein Dreieck nicht erfüllt?\n",
" \n",
" </div> \n",
"</details>\n",
"\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-primary\">3. Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
"\n",
"Wir arbeiten mit `if` und `elif` Verzweigungen und nur wenn alle drei Tests `False` ausgeben und nicht ausgeführt werden, werden die Anweisungen in `else` erreicht und `ja` ausgegeben.\n",
" \n",
" </div> \n",
"</details>\n",
"\n",
"2. Schreiben Sie eine Funktion, die die Nutzerin oder den Nutzer bittet, drei Längen einzugeben, diese in ganze Zahlen umwandelt und dann `is_triangle` nutzt, um zu prüfen, ob aus Stöcken mit den gegebenen Längen ein Dreieck geformt werden kann oder nicht.\n",
"\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-primary\"> Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
"\n",
"Die Nutzereingabe funktioniert genau analog zu `fermat_in`.\n",
" \n",
" </div> \n",
"</details>"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "11cd964c-cf03-4c2f-863b-f8fe32525205",
"metadata": {},
"outputs": [],
"source": [
"# Implementieren Sie hier die Funktion `is_triangle`"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "a70196c3-3abf-4152-b4fe-6ae724625b0f",
"metadata": {},
"outputs": [],
"source": [
"# Implementieren Sie hier die Funktion die drei Längen entgegennimmt"
]
},
{
"cell_type": "markdown",
"id": "d182415e-7d03-4a4d-9aca-d986f2f29420",
"metadata": {},
"source": [
"\n",
"\n",
"([Spoiler Alert](https://xkcd.com/109/), Randall Munroe) [Erklärung des Comics](https://www.explainxkcd.com/wiki/index.php/109:_Spoiler_Alert) falls Sie mehr erfahren wollen."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "141d1160-50b4-43da-a97b-822536403a74",
"metadata": {},
"outputs": [],
"source": [
"def is_triangle (a,b,c):\n",
" if a+b < c: \n",
" print (\"Nein\")\n",
" elif a+c < b:\n",
" print (\"Nein\")\n",
" elif b+c < a:\n",
" print (\"Nein\")\n",
" else:\n",
" print (\"Ja\")\n",
" \n",
"is_triangle(1,3,6)\n",
"is_triangle(4,3,1)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "d7d6e2b9-07e9-44a2-b503-50df382a8c16",
"metadata": {},
"outputs": [],
"source": [
"def triangle_in():\n",
" a = int(input (\"Bitte geben Sie eine ganze Zahl ein\"))\n",
" b = int(input (\"Bitte geben Sie eine ganze Zahl ein\")) \n",
" c = int(input (\"Bitte geben Sie eine ganze Zahl ein\"))\n",
" is_triangle(a,b,c)\n",
" \n",
"triangle_in()"
]
},
{
"cell_type": "markdown",
"id": "2ba42106",
"metadata": {},
"source": [
"### Aufgabe 4\n",
"\n",
"Was gibt das folgende Programm aus? Zeichnen Sie (mit Stift und Papier) ein Stapeldiagramm, das den Zustand des Programms ausgibt, wenn `recurse(3, 0)` aufgerufen wird: "
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "dac374ad",
"metadata": {},
"outputs": [],
"source": [
"def recurse(n, s):\n",
" if n == 0:\n",
" print(s)\n",
" else:\n",
" recurse(n-1, n+s)\n",
"\n",
"recurse(3, 0)"
]
},
{
"cell_type": "markdown",
"id": "9e3e5d93-f0be-4d88-bf41-f8afc5153a19",
"metadata": {},
"source": [
"1. Was würde passieren, wenn wir diese Funktion so aufrufen würden: `recurse(-1, 0)`?\n",
"\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-success\">Lösung</summary>\n",
" <div class=\"alert alert-success\" role=\"alert\">\n",
" \n",
"Wenn die Funktion mit -1 aufgerufen wird, wird die Abbruchbedingung nie erreicht. Es findet eine unendliche Rekursion statt.\n",
" \n",
" </div> \n",
"</details>\n",
"\n",
"2. Schreiben Sie einen Docstring der alles erklärt, was man wissen sollte, um diese Funktion nutzen zu können (und nicht mehr!). "
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "a438cec5",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "2e3f56c7",
"metadata": {
"tags": [
"remove-cell"
]
},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"id": "bca9517d",
"metadata": {},
"source": [
"### Aufgabe 5\n",
"\n",
"Die folgenden Aufgaben nutzen das `jupyturtle`-Modul welches in [Kapitel 4](seminar04.ipynb) beschrieben wurde.\n",
"\n",
"Lesen Sie sich die folgende Funktion durch und versuchen Sie herauszufinden, was sie tut. Rufen Sie erst dann die Funktion auf und schauen Sie, ob Sie richtig liegen.\n",
"\n",
"Passen Sie die Werte von `length`, `angle` und `factor` an, und sehen Sie, welche Auswirkungen das auf das Ergebnis hat.\n",
"Wenn Sie sich nicht sicher sind, ob Sie verstehen wie das Ganze funktioniert, versuchen Sie, einen virtuellen Assistenten zu fragen."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "2b0d60a1",
"metadata": {},
"outputs": [],
"source": [
"from jupyturtle import forward, left, right, back, make_turtle\n",
"\n",
"def draw(length):\n",
" angle = 50\n",
" factor = 0.6\n",
" \n",
" if length > 5:\n",
" forward(length)\n",
" left(angle)\n",
" draw(factor * length)\n",
" right(2 * angle)\n",
" draw(factor * length)\n",
" left(angle)\n",
" back(length)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "ef0256ee",
"metadata": {},
"outputs": [],
"source": [
"make_turtle(delay=0.02)\n",
"draw(50)"
]
},
{
"cell_type": "markdown",
"id": "fa75972c-33d7-46c6-b693-388f48ea0753",
"metadata": {},
"source": [
""
]
},
{
"cell_type": "markdown",
"id": "2123467a-acf8-40a4-9313-acad6b79c4ff",
"metadata": {},
"source": [
"### Aufgabe 6\n",
"\n",
"Die [Koch-Kurve](https://de.wikipedia.org/wiki/Koch-Kurve) ist ein [Fraktal](https://de.wikipedia.org/wiki/Fraktal), welches ungefähr so aussieht:\n",
"\n",
"\n",
"\n",
"Um eine Koch-Kurve der Länge x zu zeichnen, müssen wir nur folgendes tun:\n",
"\n",
"1. Eine Koch-Kurve der Länge x/3 zeichnen.\n",
"2. Um 60° nach links drehen.\n",
"3. Eine Koch-Kurve der Länge x/3 zeichnen.\n",
"2. Um 120° nach rechts drehen.\n",
"3. Eine Koch-Kurve der Länge x/3 zeichnen.\n",
"2. Um 60° nach links drehen.\n",
"3. Eine Koch-Kurve der Länge x/3 zeichnen.\n",
"\n",
"Eine Ausnahme gibt es, falls x kleiner als 3 ist: dann zeichnen wir einfach eine Strecke der Länge 3.\n",
"\n",
"1. Schreiben Sie eine Funktion `koch`, die eine Schildkröte und eine Länge als Argumente erwartet und die Schildkröte nutzt, um eine Koch-Kurve der gegebenen Länge zu zeichnen.\n",
"\n",
"\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-primary\">1. Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
" \n",
"Schreiben Sie zunächst den Kopf der Funktion.\n",
" \n",
" </div> \n",
"</details>\n",
"\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-primary\">2. Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
" \n",
"Überlegen Sie, was die Abbruchbedingung ist, schreiben Sie diese mit Hilfe der `if` Verzweigung auf. \n",
" \n",
" </div> \n",
"</details>\n",
"\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-primary\">3. Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
"\n",
"Bewegen Sie die Schildkröte in der `if`-Bedingung und vergessen sie die `return`-Anweisung nicht, diese ist nötig, damit der Rest der Funktion ausgeführt wird.\n",
" \n",
" </div> \n",
"</details>\n",
"\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-primary\">4. Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
"\n",
"Als nächstes übersetzten wir die Anweisungen um eine Koch-Kurve zu zeichnen von Klartext in Code. \n",
" </div> \n",
"</details>\n",
"\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-primary\">5. Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
"\n",
" \"Eine Kochkurve der Länge $x/3$ zeichnen\" wird zu `koch(t, l/3)`.\n",
" \n",
" </div> \n",
"</details>\n",
"\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-primary\">6. Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
"\n",
"Die Drehungen sind `t.lt` für die Drehungen nach links und `t.rt` für die Drehungen nach rechts. Die Gradzahl wird als ganze Zahl in Klammern hinter der Anweisung angegeben.\n",
" \n",
" </div> \n",
"</details>\n",
"\n",
"2. Schreiben Sie eine Funktion `schneeflocke`, die drei Koch-Kurven zeichnet, so dass sich der Umriss einer Schneeflocke ergibt. Eine mögliche Lösung gibt es [hier](http://thinkpython2.com/code/koch.py)\n",
"\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-primary\">1. Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
" \n",
"Um eine Schneeflocke aus 3 Koch-Kurven zu zeichnen müssen wir die Schildkröte nach jeder Koch-Kurve so weit drehen, dass sie nach der 3. Kurve eine Drehung von 360° vorgenommen hat\n",
" \n",
" </div> \n",
"</details>\n",
"\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-primary\">2. Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
" \n",
"Das heißt die Drehung muss 120° betragen, testen Sie ob Sie die Schildkröte rechts oder links herum drehen müssen.\n",
" \n",
" </div> \n",
"</details>\n",
"\n",
"<details>\n",
" <summary type=\"button\" class=\"btn btn-primary\">3. Hinweis</summary>\n",
" <div class=\"alert alert-info\" role=\"alert\">\n",
"\n",
"Das Ganze sollte innerhalb einer Schleife stattfinden, damit Sie den selben Code nicht dreifach schreiben müssen.\n",
" \n",
" </div> \n",
"</details>\n",
"\n",
"3. Die Koch-Kurve kann auf verschiedene Art und Weise verallgemeinert werden. Schauen Sie sich die [Beispiele auf Wikipedia](https://en.wikipedia.org/wiki/Koch_snowflake#Variants_of_the_Koch_curve) an und implementieren Sie Ihren Favoriten."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "46b0a6df-44db-444a-9981-f898ce197ff5",
"metadata": {},
"outputs": [],
"source": [
"import jupyturtle\n",
"\n",
"# Implementieren Sie hier die Funktion `koch`"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "34a4e674-94fd-4f1d-93b8-8ab5718666de",
"metadata": {},
"outputs": [],
"source": [
"# Implementieren Sie hier die Funktion `schneeflocke`"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "d340ea5a-90e2-4449-a1c2-45e5c12e68e9",
"metadata": {},
"outputs": [],
"source": [
"# Implementieren Sie hier die Verallgemeinerung der Koch-Kurve"
]
},
{
"cell_type": "markdown",
"id": "8be97f12-530d-4967-92ca-8b2dcc4fcb10",
"metadata": {},
"source": [
"\n",
"\n",
"([Spoiler Alert](https://xkcd.com/109/), Randall Munroe) [Erklärung des Comics](https://www.explainxkcd.com/wiki/index.php/109:_Spoiler_Alert) falls Sie mehr erfahren wollen."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "1e2088b4-e119-4553-954f-cbda51922d49",
"metadata": {},
"outputs": [],
"source": [
"import jupyturtle\n",
"\n",
"bob = jupyturtle.Turtle(delay=0.01)\n",
"\n",
"def koch(t,l):\n",
" if l <= 3:\n",
" t.forward(3)\n",
" return\n",
" \n",
" koch(t, l/3)\n",
" t.left(60)\n",
" koch(t, l/3)\n",
" t.right(120)\n",
" koch(t, l/3)\n",
" t.left(60)\n",
" koch(t, l/3)\n",
"\n",
" \n",
"koch(bob, 50)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "e54fded6-e1e1-4d00-9c8d-ce1d62c1dfe3",
"metadata": {},
"outputs": [],
"source": [
"import jupyturtle\n",
"\n",
"bob = jupyturtle.Turtle(delay=0.01)\n",
"\n",
"\n",
"def schneeflocke(t,l):\n",
" for i in range (3):\n",
" koch (t,l)\n",
" t.right(120)\n",
" \n",
"schneeflocke(bob, 30)"
]
},
{
"cell_type": "markdown",
"id": "04e4ae66-1a0e-4c2d-a36c-d08d31e8f5c7",
"metadata": {},
"source": [
"\n",
"\n",
"([Eric Baird](https://commons.wikimedia.org/wiki/File:Koch_Curve_in_Three_Dimensions_%28%22Delta%22_fractal%29.jpg))"
]
},
{
"cell_type": "markdown",
"id": "4c964239",
"metadata": {},
"source": [
"### Aufgabe 7\n",
"Virtuelle Assistenten kennen sich mit den Funktionen im `jupyturtle`-Modul aus, es gibt aber so viele verschiedene Versionen dieser Funktionen mit unterschiedlichen Namen, dass ein VA möglicherweise nicht weiß, welche Sie genau meinen.\n",
"\n",
"Um dieses Problem zu lösen, können Sie zusätzliche Informationen liefern, bevor Sie eine Frage stellen.\n",
"Sie können einen Prompt zum Beispiel mit \"Hier ist ein Programm, das das `jupyturtle`-Modul verwendet,\" beginnen, und dann eines der Beispiele aus diesem Kapitel einfügen.\n",
"Danach sollte der VA in der Lage sein, Code zu generieren, der dieses Modul verwendet.\n",
"\n",
"Als Beispiel, fragen Sie einen VA nach einem Programm, das ein [Sierpiński-Dreieck](https://de.wikipedia.org/wiki/Sierpinski-Dreieck) zeichnet.\n",
"Der Code, den Sie erhalten sollte ein guter Startpunkt sein, trotzdem müssen Sie vielleicht noch debuggen.\n",
"Wenn der erste Versuch nicht funktioniert, teilen Sie dem VA mit, was passiert ist und fragen Sie nach Hilfe -- oder debuggen Sie den Code selbst."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "68439acf",
"metadata": {},
"outputs": [],
"source": [
"import jupyturtle\n",
"\n",
"# Implementieren Sie hier die Funktion `draw_sierpinski`"
]
},
{
"cell_type": "markdown",
"id": "6a95097a",
"metadata": {},
"source": [
"Hier ist ein Beispiel dafür, wie das Ergebnis aussehen könnte, auch wenn die Version, die Sie erhalten eventuell ein wenig anders aussieht:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "43470b3d",
"metadata": {},
"outputs": [],
"source": [
"make_turtle(delay=0, height=200)\n",
"\n",
"draw_sierpinski(bob, 100, 3)"
]
},
{
"cell_type": "markdown",
"id": "aadee942-b8dd-4679-a331-e6023b569ad6",
"metadata": {},
"source": [
" Speichern Sie dieses Notebook, so dass Ihre Änderungen nicht verlorengehen (nicht auf einem Pool-Rechner). Rufen Sie dazu im Menü *File* den Punkt *Download as* → *Notebook* auf und nutzen Sie beispielsweise einen USB-Stick, E-Mail, Google Drive, Dropbox oder Ihre [HU-Box](https://box.hu-berlin.de/). \n"
]
},
{
"cell_type": "markdown",
"id": "3f98530e-bfe6-4319-9898-50940c840ba4",
"metadata": {},
"source": [
"\n",
"Herzlichen Glückwunsch! Sie haben das 4. Kapitel geschafft!"
]
},
{
"cell_type": "markdown",
"id": "5cf853f4-5575-408c-8446-bc993452dc66",
"metadata": {},
"source": [
"<img src=\"https://scm.cms.hu-berlin.de/ibi/python/-/raw/master/img/by-nc-sa.png\" alt=\"CC BY-NC-SA\" style=\"width: 150px;\"/>\n",
"\n",
"Der Text dieses Notebooks ist als freies Werk unter der Lizenz [CC BY-NC-SA 4.0 ](https://creativecommons.org/licenses/by-nc-sa/4.0/) verfügbar.\n",
"Der Code dieses Notebooks ist als freies Werk unter der Lizenz [MIT License](https://mit-license.org/) verfügbar.\n",
"\n",
"Es handelt sich um übersetzte und leicht veränderte Notebooks von [Allen B. Downey](https://allendowney.com) aus [Think Python: 3rd Edition](https://allendowney.github.io/ThinkPython/index.html).\n"
]
}
],
"metadata": {
"celltoolbar": "Tags",
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.12.2"
}
},
"nbformat": 4,
"nbformat_minor": 5
}