From eb3508dd32779fc7805f30a6820be050eaa6eca7 Mon Sep 17 00:00:00 2001
From: schwabmi <michel.j.schwab@gmail.com>
Date: Thu, 19 Nov 2020 16:38:34 +0100
Subject: [PATCH] added mb changes and some minor corrections
---
notebooks/seminar03.ipynb | 678 +++++++++++++++++++++++++++++++++-----
1 file changed, 590 insertions(+), 88 deletions(-)
diff --git a/notebooks/seminar03.ipynb b/notebooks/seminar03.ipynb
index 05799e5..803a57c 100644
--- a/notebooks/seminar03.ipynb
+++ b/notebooks/seminar03.ipynb
@@ -1,27 +1,33 @@
{
"cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Kapitel 3: Funktionen\n",
+ "[Chapter 3: Functions](http://greenteapress.com/thinkpython2/html/thinkpython2004.html)\n",
+ "\n",
+ "**Funktionen** bezeichnen eine benannte Folge von Anweisungen. Wenn wir eine Funktion definieren, dann geben wir der Funktion einen Namen und fügen die Folge von Anweisungen, die die Funktion ausführen sollen, hinzu. Später können wir die Funktion mit ihrem Namen **aufrufen**. \n",
+ "\n",
+ "\n",
+ "\n",
+ "\n",
+ "**Bevor Sie mit diesem Notebook starten, sollten Sie wiederholen, was Sie im letzten Notebook gelernt haben. Gehen Sie zurück und schauen Sie sich mindestens das Glossar an und wiederholen Sie die dort genannten Begriffe.**"
+ ]
+ },
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<h1>Inhalt<span class=\"tocSkip\"></span></h1>\n",
- "<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#Kapitel-3:-Funktionen\" data-toc-modified-id=\"Kapitel-3:-Funktionen-1\"><span class=\"toc-item-num\">1 </span>Kapitel 3: Funktionen</a></span><ul class=\"toc-item\"><li><span><a href=\"#Ihre-Lernziele\" data-toc-modified-id=\"Ihre-Lernziele-1.1\"><span class=\"toc-item-num\">1.1 </span>Ihre Lernziele</a></span></li><li><span><a href=\"#Exkurs:-Was-mir-an-Python-gefällt\" data-toc-modified-id=\"Exkurs:-Was-mir-an-Python-gefällt-1.2\"><span class=\"toc-item-num\">1.2 </span>Exkurs: Was mir an Python gefällt</a></span></li><li><span><a href=\"#Warum?\" data-toc-modified-id=\"Warum?-1.3\"><span class=\"toc-item-num\">1.3 </span>Warum?</a></span></li><li><span><a href=\"#3.1-Funktionsaufrufe\" data-toc-modified-id=\"3.1-Funktionsaufrufe-1.4\"><span class=\"toc-item-num\">1.4 </span>3.1 Funktionsaufrufe</a></span></li><li><span><a href=\"#3.2-Mathematische-Funktionen\" data-toc-modified-id=\"3.2-Mathematische-Funktionen-1.5\"><span class=\"toc-item-num\">1.5 </span>3.2 Mathematische Funktionen</a></span></li><li><span><a href=\"#3.3-Verknüpfung\" data-toc-modified-id=\"3.3-Verknüpfung-1.6\"><span class=\"toc-item-num\">1.6 </span>3.3 Verknüpfung</a></span></li><li><span><a href=\"#3.4-Neue-Funktionen-hinzufügen\" data-toc-modified-id=\"3.4-Neue-Funktionen-hinzufügen-1.7\"><span class=\"toc-item-num\">1.7 </span>3.4 Neue Funktionen hinzufügen</a></span></li><li><span><a href=\"#3.5-Definition-von-Funktionen-und-deren-Aufruf\" data-toc-modified-id=\"3.5-Definition-von-Funktionen-und-deren-Aufruf-1.8\"><span class=\"toc-item-num\">1.8 </span>3.5 Definition von Funktionen und deren Aufruf</a></span></li><li><span><a href=\"#3.6-Kontrollfluss\" data-toc-modified-id=\"3.6-Kontrollfluss-1.9\"><span class=\"toc-item-num\">1.9 </span>3.6 Kontrollfluss</a></span></li><li><span><a href=\"#3.7-Parameter-und-Argumente\" data-toc-modified-id=\"3.7-Parameter-und-Argumente-1.10\"><span class=\"toc-item-num\">1.10 </span>3.7 Parameter und Argumente</a></span></li><li><span><a href=\"#3.8-Variablen-und-Parameter-sind-lokal\" data-toc-modified-id=\"3.8-Variablen-und-Parameter-sind-lokal-1.11\"><span class=\"toc-item-num\">1.11 </span>3.8 Variablen und Parameter sind lokal</a></span></li><li><span><a href=\"#3.9-Stapel-Diagramme\" data-toc-modified-id=\"3.9-Stapel-Diagramme-1.12\"><span class=\"toc-item-num\">1.12 </span>3.9 Stapel-Diagramme</a></span></li><li><span><a href=\"#3.10-Funktionen-mit-Rückgabewert\" data-toc-modified-id=\"3.10-Funktionen-mit-Rückgabewert-1.13\"><span class=\"toc-item-num\">1.13 </span>3.10 Funktionen mit Rückgabewert</a></span></li><li><span><a href=\"#3.11-Exkurs:-Eigene-Funktionen-mit-Rückgabewert\" data-toc-modified-id=\"3.11-Exkurs:-Eigene-Funktionen-mit-Rückgabewert-1.14\"><span class=\"toc-item-num\">1.14 </span>3.11 Exkurs: Eigene Funktionen mit Rückgabewert</a></span></li><li><span><a href=\"#3.12-Debugging\" data-toc-modified-id=\"3.12-Debugging-1.15\"><span class=\"toc-item-num\">1.15 </span>3.12 Debugging</a></span></li><li><span><a href=\"#3.13-Glossar\" data-toc-modified-id=\"3.13-Glossar-1.16\"><span class=\"toc-item-num\">1.16 </span>3.13 Glossar</a></span></li></ul></li><li><span><a href=\"#3.14-Übung\" data-toc-modified-id=\"3.14-Übung-2\"><span class=\"toc-item-num\">2 </span>3.14 Übung</a></span><ul class=\"toc-item\"><li><span><a href=\"#Aufgabe-1\" data-toc-modified-id=\"Aufgabe-1-2.1\"><span class=\"toc-item-num\">2.1 </span>Aufgabe 1</a></span><ul class=\"toc-item\"><li><span><a href=\"#Aufgabe-1a\" data-toc-modified-id=\"Aufgabe-1a-2.1.1\"><span class=\"toc-item-num\">2.1.1 </span>Aufgabe 1a</a></span><ul class=\"toc-item\"><li><span><a href=\"#Lückentext\" data-toc-modified-id=\"Lückentext-2.1.1.1\"><span class=\"toc-item-num\">2.1.1.1 </span>Lückentext</a></span></li></ul></li><li><span><a href=\"#Aufgabe-1b\" data-toc-modified-id=\"Aufgabe-1b-2.1.2\"><span class=\"toc-item-num\">2.1.2 </span>Aufgabe 1b</a></span></li><li><span><a href=\"#Aufgabe-2\" data-toc-modified-id=\"Aufgabe-2-2.1.3\"><span class=\"toc-item-num\">2.1.3 </span>Aufgabe 2</a></span></li><li><span><a href=\"#Aufgabe-3\" data-toc-modified-id=\"Aufgabe-3-2.1.4\"><span class=\"toc-item-num\">2.1.4 </span>Aufgabe 3</a></span><ul class=\"toc-item\"><li><span><a href=\"#1.\" data-toc-modified-id=\"1.-2.1.4.1\"><span class=\"toc-item-num\">2.1.4.1 </span>1.</a></span></li><li><span><a href=\"#2.\" data-toc-modified-id=\"2.-2.1.4.2\"><span class=\"toc-item-num\">2.1.4.2 </span>2.</a></span></li></ul></li><li><span><a href=\"#Bonusaufgabe\" data-toc-modified-id=\"Bonusaufgabe-2.1.5\"><span class=\"toc-item-num\">2.1.5 </span>Bonusaufgabe</a></span></li></ul></li></ul></li></ul></div>"
+ "<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#Ihre-Lernziele\" data-toc-modified-id=\"Ihre-Lernziele-1\"><span class=\"toc-item-num\">1 </span>Ihre Lernziele</a></span></li><li><span><a href=\"#Exkurs:-Was-mir-an-Python-gefällt\" data-toc-modified-id=\"Exkurs:-Was-mir-an-Python-gefällt-2\"><span class=\"toc-item-num\">2 </span>Exkurs: Was mir an Python gefällt</a></span></li><li><span><a href=\"#Warum?\" data-toc-modified-id=\"Warum?-3\"><span class=\"toc-item-num\">3 </span>Warum?</a></span></li><li><span><a href=\"#Funktionsaufrufe\" data-toc-modified-id=\"Funktionsaufrufe-4\"><span class=\"toc-item-num\">4 </span>Funktionsaufrufe</a></span></li><li><span><a href=\"#Mathematische-Funktionen\" data-toc-modified-id=\"Mathematische-Funktionen-5\"><span class=\"toc-item-num\">5 </span>Mathematische Funktionen</a></span></li><li><span><a href=\"#Verknüpfung\" data-toc-modified-id=\"Verknüpfung-6\"><span class=\"toc-item-num\">6 </span>Verknüpfung</a></span></li><li><span><a href=\"#Neue-Funktionen-hinzufügen\" data-toc-modified-id=\"Neue-Funktionen-hinzufügen-7\"><span class=\"toc-item-num\">7 </span>Neue Funktionen hinzufügen</a></span></li><li><span><a href=\"#Definition-von-Funktionen-und-deren-Aufruf\" data-toc-modified-id=\"Definition-von-Funktionen-und-deren-Aufruf-8\"><span class=\"toc-item-num\">8 </span>Definition von Funktionen und deren Aufruf</a></span></li><li><span><a href=\"#Kontrollfluss\" data-toc-modified-id=\"Kontrollfluss-9\"><span class=\"toc-item-num\">9 </span>Kontrollfluss</a></span></li><li><span><a href=\"#Parameter-und-Argumente\" data-toc-modified-id=\"Parameter-und-Argumente-10\"><span class=\"toc-item-num\">10 </span>Parameter und Argumente</a></span></li><li><span><a href=\"#Variablen-und-Parameter-sind-lokal\" data-toc-modified-id=\"Variablen-und-Parameter-sind-lokal-11\"><span class=\"toc-item-num\">11 </span>Variablen und Parameter sind lokal</a></span></li><li><span><a href=\"#Stapel-Diagramme\" data-toc-modified-id=\"Stapel-Diagramme-12\"><span class=\"toc-item-num\">12 </span>Stapel-Diagramme</a></span></li><li><span><a href=\"#Funktionen-mit-Rückgabewert\" data-toc-modified-id=\"Funktionen-mit-Rückgabewert-13\"><span class=\"toc-item-num\">13 </span>Funktionen mit Rückgabewert</a></span></li><li><span><a href=\"#Exkurs:-Eigene-Funktionen-mit-Rückgabewert\" data-toc-modified-id=\"Exkurs:-Eigene-Funktionen-mit-Rückgabewert-14\"><span class=\"toc-item-num\">14 </span>Exkurs: Eigene Funktionen mit Rückgabewert</a></span></li><li><span><a href=\"#Debugging\" data-toc-modified-id=\"Debugging-15\"><span class=\"toc-item-num\">15 </span>Debugging</a></span></li><li><span><a href=\"#Glossar\" data-toc-modified-id=\"Glossar-16\"><span class=\"toc-item-num\">16 </span>Glossar</a></span></li><li><span><a href=\"#Übung\" data-toc-modified-id=\"Übung-17\"><span class=\"toc-item-num\">17 </span>Übung</a></span><ul class=\"toc-item\"><li><span><a href=\"#Aufgabe-1\" data-toc-modified-id=\"Aufgabe-1-17.1\"><span class=\"toc-item-num\">17.1 </span>Aufgabe 1</a></span><ul class=\"toc-item\"><li><span><a href=\"#Aufgabe-1a\" data-toc-modified-id=\"Aufgabe-1a-17.1.1\"><span class=\"toc-item-num\">17.1.1 </span>Aufgabe 1a</a></span><ul class=\"toc-item\"><li><span><a href=\"#Lückentext\" data-toc-modified-id=\"Lückentext-17.1.1.1\"><span class=\"toc-item-num\">17.1.1.1 </span>Lückentext</a></span></li></ul></li><li><span><a href=\"#Aufgabe-1b\" data-toc-modified-id=\"Aufgabe-1b-17.1.2\"><span class=\"toc-item-num\">17.1.2 </span>Aufgabe 1b</a></span></li></ul></li><li><span><a href=\"#Aufgabe-2\" data-toc-modified-id=\"Aufgabe-2-17.2\"><span class=\"toc-item-num\">17.2 </span>Aufgabe 2</a></span></li><li><span><a href=\"#Aufgabe-3\" data-toc-modified-id=\"Aufgabe-3-17.3\"><span class=\"toc-item-num\">17.3 </span>Aufgabe 3</a></span><ul class=\"toc-item\"><li><span><a href=\"#Aufgabe-3.1\" data-toc-modified-id=\"Aufgabe-3.1-17.3.1\"><span class=\"toc-item-num\">17.3.1 </span>Aufgabe 3.1</a></span></li><li><span><a href=\"#Aufgabe-3.2\" data-toc-modified-id=\"Aufgabe-3.2-17.3.2\"><span class=\"toc-item-num\">17.3.2 </span>Aufgabe 3.2</a></span></li></ul></li><li><span><a href=\"#Bonusaufgabe\" data-toc-modified-id=\"Bonusaufgabe-17.4\"><span class=\"toc-item-num\">17.4 </span>Bonusaufgabe</a></span></li></ul></li></ul></div>"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
- "# Seminar Problemorientierte Programmierung\n",
- "\n",
- "**Bevor Sie mit diesem Notebook starten, gehen Sie zurück in das vorherige Notebook und schauen Sie sich zumindesten das Glossar an, um zu wiederholen, was Sie im letzten Notebook gelernt haben.**\n",
- "\n",
- "## Kapitel 3: Funktionen\n",
- "[Chapter 3: Functions](http://greenteapress.com/thinkpython2/html/thinkpython2004.html)\n",
- "\n",
- "**Funktionen** bezeichnen eine benannte Folge von Anweisungen. Wenn wir eine Funktion definieren, dann geben wir der Funktion einen Namen und fügen die Folge von Anweisungen, die die Funktion ausführen sollen, hinzu. Später können wir die Funktion mit ihrem Namen **aufrufen**. \n",
- "\n",
- "### Ihre Lernziele\n",
+ "## Ihre Lernziele\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",
@@ -30,7 +36,7 @@
"- \n",
"\n",
"\n",
- "### Exkurs: Was mir an Python gefällt\n",
+ "## Exkurs: Was mir an Python gefällt\n",
"\n",
"Es ist sehr leicht, Ergebnisse mit Hilfe eines Plots darzustellen und auch mathematische Funktionen können professionell geplottet werden:"
]
@@ -60,7 +66,7 @@
"metadata": {},
"source": [
" \n",
- "### Warum?\n",
+ "## Warum?\n",
"\n",
"Warum ist es sinnvoll, ein Programm in Funktionen aufzuteilen?\n",
"Hier einige Beispiele: \n",
@@ -77,7 +83,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "### 3.1 Funktionsaufrufe\n",
+ "## Funktionsaufrufe\n",
"\n",
"Wir haben schon einige Funktionsaufrufe gesehen:"
]
@@ -206,14 +212,14 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "**Tipp**: Nutzen Sie http://pythontutor.com, um ihren Code nachvollziehen zu können und Fehler zu finden!"
+ "**Tipp**: Nutzen Sie [Pythontutor](http://pythontutor.com), um Ihren Code nachvollziehen zu können und Fehler zu finden!"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
- "### 3.2 Mathematische Funktionen\n",
+ "## Mathematische Funktionen\n",
"\n",
"Mit Python wird ein Mathematik-Modul mitgeliefert, das die üblichen mathematischen Funktionen enthält. Ein **Modul** ist eine Datei, die eine Sammlung von verwandten Funktionen enthält. \n",
"\n",
@@ -308,7 +314,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "### 3.3 Verknüpfung\n",
+ "## Verknüpfung\n",
"\n",
"Bisher haben wir uns die Elemente von Programmen - Variablen, Ausdrücke, Anweisungen - einzeln angeschaut aber nicht darüber gesprochen, wie wir sie kombinieren können. \n",
"\n",
@@ -383,7 +389,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "### 3.4 Neue Funktionen hinzufügen\n",
+ "## Neue Funktionen hinzufügen\n",
"\n",
"Bisher haben wir nur Funktionen genutzt, die bei Python schon \"mitgeliefert\" werden. Es ist aber auch möglich, eigene Funktionen hinzuzufügen. Eine **Funktionsdefinition** gibt den Namen der Funktion an und beschreibt die Folge von Anweisungen, die ausgeführt werden, wenn die Funktion aufgerufen wird:"
]
@@ -477,7 +483,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "### 3.5 Definition von Funktionen und deren Aufruf\n",
+ "## Definition von Funktionen und deren Aufruf\n",
"\n",
"Schauen wir uns noch einmal an, was Sie gerade programmiert haben:\n",
"\n",
@@ -523,7 +529,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "*(Falls Sie keine Fehlermeldung erhalten, müssen Sie den Jupyter-Kernel neustarten, da sich Jupyter die ursprüngliche Funktionsdefinition gemerkt hat. Wählen Sie dafür \"Restart & Clear Output\" im \"Kernel\"-Menü.)*\n",
+ "***Achtung:** Falls Sie keine Fehlermeldung erhalten, müssen Sie den Jupyter-Kernel neustarten, da sich Jupyter die ursprüngliche Funktionsdefinition gemerkt hat. Wählen Sie dafür \"Restart & Clear Output\" im \"Kernel\"-Menü.*\n",
"\n",
"Verschieben Sie den Aufruf jetzt wieder ans Ende und vertauschen Sie die Reihenfolge der beiden Funktionsdefinitionen. Was passiert dabei?"
]
@@ -532,7 +538,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "### 3.6 Kontrollfluss\n",
+ "## Kontrollfluss\n",
"\n",
"Damit wir sicherstellen können, dass eine Funktion definiert ist, bevor wir sie aufrufen, müssen wir die Reihenfolge kennen, in der Anweisungen ausgeführt werden - den sogenannten **Kontrollfluss**.\n",
"\n",
@@ -577,7 +583,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "### 3.7 Parameter und Argumente\n",
+ "## Parameter und Argumente\n",
"\n",
"Einige der Funktionen, die wir schon gesehen haben, benötigen **Argumente** (z.B. `print` oder `type`). Wenn wir `math.sin` aufrufen, müssen wir eine Zahl als Argument übergeben. Einige Funktionen benötigen auch mehrere Argumente (z.B. benötigt `math.pow` zwei Argumente: die Basis und den Exponenten).\n",
"\n",
@@ -663,7 +669,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "### 3.8 Variablen und Parameter sind lokal\n",
+ "## Variablen und Parameter sind lokal\n",
"\n",
"Wenn wir eine Variable innerhalb einer Funktion erzeugen, ist dies eine **lokale** Variable; das heißt diese Variable existiert nur innerhalb der Funktion. Zum Beispiel:"
]
@@ -733,7 +739,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "### 3.9 Stapel-Diagramme\n",
+ "## Stapel-Diagramme\n",
"\n",
"Um den Ãœberblick zu behalten, wo welche Variable genutzt werden kann, ist es manchmal hilfreich, ein sogenanntes **Stapel-Diagramm** (Englisch: *stack diagram*) zu zeichnen:\n",
"\n",
@@ -811,7 +817,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "### 3.10 Funktionen mit Rückgabewert\n",
+ "## Funktionen mit Rückgabewert\n",
"\n",
"Einige der Funktionen, die wir bisher verwendet haben (z.B. die mathematischen Funktionen) geben einen Wert zurück. Andere führen eine Aktion aus, geben aber keinen Wert zurück (z.B. `print_twice`). Diese werden auch **void functions** — also leere Funktionen genannt.\n",
"\n",
@@ -897,7 +903,7 @@
"metadata": {},
"source": [
"\n",
- "### 3.11 Exkurs: Eigene Funktionen mit Rückgabewert\n",
+ "## Exkurs: Eigene Funktionen mit Rückgabewert\n",
"\n",
"Dieser Abschnitt taucht nicht im englischen Python-Kurs auf und gibt einen Ausblick auf ein späteres Kapitel. Wir können selbst eine Funktion mit Rückgabewert schreiben, indem wir das Schlüsselwort `return` verwenden:\n"
]
@@ -942,7 +948,49 @@
"\n",
"mit $s = (a+b+c)/2$ ist. \n",
"\n",
- "*(Hinweis: Sie können die Quadratwurzel einer Zahl mit der Funktion `math.sqrt` berechnen.)*"
+ "\n",
+ "<details>\n",
+ " <summary type=\"button\" class=\"btn btn-info\"> Hinweis</summary>\n",
+ " <div class=\"alert alert-info\" role=\"alert\">\n",
+ " \n",
+ "Sie können die Quadratwurzel einer Zahl mit der Funktion `math.sqrt` berechnen. Stellen Sie sicher, dass Sie das `math`- Modul importiert haben. Führen Sie die entsprechende Zeile im Zweifelsfall erneut aus.\n",
+ " \n",
+ " </div> \n",
+ "</details> \n",
+ "\n",
+ "\n",
+ "\n",
+ "Versuchen Sie die Aufgabe zunächst selber zu lösen, wenn nötig nutzen Sie die folgenenden Hinweise\n",
+ " \n",
+ "\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",
+ "In der Aufgabenstellung oben werden zwei Formeln gegeben. Wie stehen Sie miteinander in Verbindung? Ãœbersetzten Sie beide Formeln in Python Code und schreiben Sie sie innerhalb der Funktionsdefinition auf.\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",
+ "Vergessen Sie nicht die Formeln Variablen zuzuweisen und schreiben Sie eine `return`-Anweisung \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 beiden Formeln sind: `s = (a + b + c) / 2` und `area = math.sqrt(s * (s - a) * (s - b) * (s - c))` \n",
+ " \n",
+ " </div> \n",
+ "</details> \n",
+ " "
]
},
{
@@ -983,7 +1031,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "### 3.12 Debugging\n",
+ "## Debugging\n",
"\n",
"Eine der wichtigsten Fähigkeiten des Programmierens ist **Debugging**. Obwohl es manchmal frustrierend ist, ist es einer der intellektuell anspruchsvollsten, herausforderndsten und interessantesten Aspekte des Programmierens.\n",
"\n",
@@ -1004,7 +1052,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "### 3.13 Glossar\n",
+ "## Glossar\n",
"\n",
"Legen wir uns eine Liste mit den wichtigsten Begriffen an, die wir im Kapitel 3 gelernt haben:\n",
"- Funktion:\n",
@@ -1035,7 +1083,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "## 3.14 Ãœbung\n",
+ "## Ãœbung\n",
"\n",
"### Aufgabe 1\n",
"\n",
@@ -1054,7 +1102,89 @@
" monty\n",
"```\n",
"\n",
- "*Hinweis: Nutzen Sie die Zeichenkettenverknüpfung und -wiederholung. Python bietet uns auch eine Funktion an, mit der wir die Länge einer Zeichenkette ermitteln können. Diese Funktion heißt `len`. Sie erwartet als Argument eine Zeichenkette und gibt ihre Länge zurück. Der Rückgabewert von `len('monty')` ist also `5`.*\n"
+ "Zunächst ein allgemeiner Hinweis, der Elemente von Python aufzeigt, die für die Lösung des Problems wichtig sind: \n",
+ "\n",
+ "<details>\n",
+ " <summary type=\"button\" class=\"btn btn-info\">Hinweis</summary>\n",
+ " <div class=\"alert alert-info\" role=\"alert\">\n",
+ " \n",
+ "Nutzen Sie die Zeichenkettenverknüpfung und -wiederholung. Python bietet uns auch eine Funktion an, mit der wir die Länge einer Zeichenkette ermitteln können. Diese Funktion heißt `len`. Sie erwartet als Argument eine Zeichenkette und gibt ihre Länge zurück. Der Rückgabewert von `len('monty')` ist also `5`.\n",
+ " \n",
+ " </div> \n",
+ "</details> \n",
+ "\n",
+ "\n",
+ "Jetzt ein paar Tipps, wie Sie das Problem angehen könnten. Lesen Sie nicht alles auf einmal durch, sondern nur jeweils einen Tipp und versuchen Sie dann erstmal wieder, das Problem zu zweit zu lösen. Wenn Sie mit diesen Tipps nicht weiterkommen, finden Sie ein wenig weiter Unten einen Lückentext, den Sie vervollständigen sollen. Die Beste Übung für Sie ist es diese Aufgabe mit so wenigen Hinweisen wie möglich zu lösen.\n",
+ "\n",
+ "<details>\n",
+ " <summary type=\"button\" class=\"btn btn-primary\">1. Hinweis</summary>\n",
+ " <div class=\"alert alert-info\" role=\"alert\">\n",
+ " \n",
+ "Fangen Sie damit an den Kopf der Funktion zu schreiben, welche Elemente benötigen Sie hier?\n",
+ " \n",
+ " </div> \n",
+ "</details> \n",
+ " \n",
+ " \n",
+ "<details>\n",
+ " <summary type=\"button\" class=\"btn btn-primary\">2. Hinweis</summary>\n",
+ " <div class=\"alert alert-info\" role=\"alert\">\n",
+ " \n",
+ "Lösen Sie die Aufgabe zunächst für die Zeichenkette 'monty' und verallgemeinern Sie diese Lösung anschließend.\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",
+ "Wie können Sie die Anzahl an benötigten Leerzeichen berechnen? Welche Werte und Funktionen benötigen Sie?\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",
+ "Geben Sie das Wort 'monty' rechtsbündig aus, verwenden Sie dabei nicht die konkret berechneten Zahlen, sondern die Berechnungen, die Sie durchgeführt haben. \n",
+ " \n",
+ " </div> \n",
+ "</details>\n",
+ "<details>\n",
+ " <summary type=\"button\" class=\"btn btn-primary\">5. Hinweis</summary>\n",
+ " <div class=\"alert alert-info\" role=\"alert\">\n",
+ " \n",
+ "Wenn Sie unsicher sind, wie Sie mehrere Elemente in einer 'print' Anweisung ausgeben können, schauen Sie sich noch einmal das 'print'- Tutorium aus dem 2. Notebook an. \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",
+ "Mit dem '*' Operator können Sie ein Leerzeichen beliebig oft ausgeben, nutzen Sie das um die korrekte Anzahl an Leerzeichen zu drucken.\n",
+ " \n",
+ " </div> \n",
+ "</details>\n",
+ "<details>\n",
+ " <summary type=\"button\" class=\"btn btn-primary\">7. Hinweis</summary>\n",
+ " <div class=\"alert alert-info\" role=\"alert\">\n",
+ " \n",
+ "An welchen Stellen wird der Parameter 's' eingesetzt um eine beliebige Zeichenkette ausgeben zu können?\n",
+ " \n",
+ " </div> \n",
+ "</details>\n",
+ "<details>\n",
+ " <summary type=\"button\" class=\"btn btn-primary\">8. Hinweis</summary>\n",
+ " <div class=\"alert alert-info\" role=\"alert\">\n",
+ " \n",
+ "Ersetzen Sie 'monty' durch den Buchstaben s. (Dies müsste an 2 Stellen notwendig sein, einmal in der Berechnung der Leerzeichen und einmal in der print- Anweisung.)\n",
+ " \n",
+ " </div> \n",
+ "</details>"
]
},
{
@@ -1078,6 +1208,33 @@
"# (und testen Sie die Funktion zwischendurch immer mal)"
]
},
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Macht Ihre Funktion auch wirklich, was sie soll? Ein paar Ideen zum Testen:\n",
+ "- Zählen Sie die Leerzeichen bis zum Wort. Das ist schwierig, da Leerzeichen schwer zu sehen sind. Zum Zählen können Sie das Leerzeichen durch ein anderes Zeichen — zum Beispiel einen Punkt — ersetzen.\n",
+ "- Bei kurzen Wörtern sind es recht viele Punkte; als Abhilfe könnten Sie, statt in der 70. Spalte, alles rechtsbündig in der 10. Spalte ausgeben, also 70 Zeichen auf 10 reduzieren. Dann lässt es sich leichter zählen.\n",
+ "\n",
+ "Wenn Ihre Funktion so richtig funktioniert, sollte sie auch mit Leerzeichen statt Punkten und rechtsbündig in Spalte 70 statt Spalte 10 korrekt funktionieren. Das ist auch Debugging und Testen — es ist wichtig, um Fehler zu finden und hilft Ihnen, mit Ihrem Programm vertrauter zu werden."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Abschlussfrage: was passiert, wenn Sie die Funktion mit einer Zeichenkette aufrufen, die länger als 70 Zeichen ist? Probieren Sie es aus:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "right_justify('Abschlussfrage: was passiert, wenn Sie die Funktion mit einer Zeichenkette aufrufen, die länger als 70 Zeichen ist?')"
+ ]
+ },
{
"cell_type": "markdown",
"metadata": {},
@@ -1087,22 +1244,13 @@
"\n",
"\n",
"\n",
- "Bitte hier nur weiterlesen, wenn Sie Hilfe benötigen. Versuchen Sie es aber vorher unbedingt erst einmal zu zweit. Es lohnt sich die Lösung selber herauszufinden; so lernen Sie am meisten dazu. \n",
+ "Bitte hier nur weiterlesen, wenn Sie weitere Hilfe benötigen. Versuchen Sie es aber vorher unbedingt erst einmal zu zweit. Es lohnt sich die Lösung selber herauszufinden; so lernen Sie am meisten dazu. \n",
"\n",
- ".\n",
+ ". \n",
"\n",
- ".\n",
+ ". \n",
"\n",
- ".\n",
- "\n",
- "\n",
- "([Spoiler Alert](https://xkcd.com/109/), Randall Munroe)\n",
- "\n",
- ".\n",
- "\n",
- ".\n",
- "\n",
- ".\n",
+ ". \n",
"\n",
"So sollte der Kopf Ihrer Funktion ausehen (alle notwendigen Informationen dazu stehen im ersten Teil des ersten Satzes der Aufgabe):\n",
"\n",
@@ -1112,7 +1260,11 @@
"\n",
".\n",
"\n",
- "."
+ ". \n",
+ "\n",
+ ". \n",
+ "\n",
+ "Daraus resultiert dann dieser Lückentext:"
]
},
{
@@ -1158,7 +1310,16 @@
"\n",
"Wenn Ihre Funktion so richtig funktioniert, sollte sie auch mit Leerzeichen statt Punkten und rechtsbündig in Spalte 70 statt Spalte 10 korrekt funktionieren. Das ist auch Debugging und Testen — es ist wichtig, um Fehler zu finden und hilft Ihnen, mit Ihrem Programm vertrauter zu werden.\n",
"\n",
- "Abschlussfrage: was passiert, wenn Sie die Funktion mit einer Zeichenkette aufrufen, die länger als 70 Zeichen ist? Probieren Sie es aus:"
+ "\n",
+ "([Spoiler Alert](https://xkcd.com/109/), Randall Munroe)\n",
+ "\n",
+ ".\n",
+ "\n",
+ ".\n",
+ "\n",
+ ".\n",
+ "\n",
+ "Wenn Sie Ihren Lösungsweg mit einer möglichen Lösung vergleichen wollen können Sie diese hier finden. Allerdings gibt es häufig mehr als einen Lösungsweg, wenn Ihre Lösung anders aussieht ist dies nicht zwingend falsch. Wenn Sie sich unsicher sind, fragen Sie bitte nach:"
]
},
{
@@ -1167,7 +1328,13 @@
"metadata": {},
"outputs": [],
"source": [
- "right_justify('Abschlussfrage: was passiert, wenn Sie die Funktion mit einer Zeichenkette aufrufen, die länger als 70 Zeichen ist?')"
+ "def right_justify(s):\n",
+ " # Anzahl Leerzeichen berechnen\n",
+ " anzahl_leerzeichen = 70 - len(s)\n",
+ " # Zeichenkette erzeugen\n",
+ " ergebnis = \" \" * anzahl_leerzeichen + s\n",
+ " # und ausgeben\n",
+ " print(ergebnis)"
]
},
{
@@ -1178,6 +1345,51 @@
"Testen Sie folgendermaßen, ob Sie verstanden haben, wie die Funktion `right_justify` funktioniert: Schreiben Sie eine Funktion `center`, die eine als Argument übergebene Zeichenkette zentriert ausgibt (bei einer angenommen maximalen Spaltenbreite von 70, wie gerade eben):"
]
},
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "<details>\n",
+ " <summary type=\"button\" class=\"btn btn-info\">Hinweis</summary>\n",
+ " <div class=\"alert alert-info\" role=\"alert\">\n",
+ " \n",
+ "Mit dem Operator `//` können wir zwei ganze Zahlen so teilen, dass eine ganze Zahl (*integer*) herauskommt. Während `7 / 2` die Gleitkommazahl `3.5` ergibt, erhalten wir bei `7 // 2` die ganze Zahl `3` (es wird stets abgerundet).\n",
+ " \n",
+ " </div> \n",
+ "</details> \n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Wie auch schon in der vorherigen Aufgabe finden Sie anschließend Hinweise, die einzelne Schritte der Lösung erklären und aufzeigen, versuchen Sie zunächst die Aufgabe ohne Hilfe zu lösen und schauen Sie die Hinweise wenn nötig Schritt für Schritt an."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "<details>\n",
+ " <summary type=\"button\" class=\"btn btn-primary\">1. Hinweis</summary>\n",
+ " <div class=\"alert alert-info\" role=\"alert\">\n",
+ " \n",
+ "Diese Aufgabe ist eine Abwandlung der Aufgabe 1a, überlegen Sie an welcher Stelle die Aufgaben sich unterscheiden.\n",
+ " \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",
+ "Benötigen Sie insgesamt die selbe Anzahl an Leerzeichen um die Zeichenkette zu zentrieren? Wie viele davon müssen vor der Zeichenkette stehen? Wie können Sie diese Anzahl berechnen?\n",
+ " \n",
+ " </div> \n",
+ "</details> \n"
+ ]
+ },
{
"cell_type": "code",
"execution_count": null,
@@ -1229,10 +1441,8 @@
"\n",
"([Spoiler Alert](https://xkcd.com/109/), Randall Munroe)\n",
"\n",
- "1. Diese Aufgabe ist Aufgabe 1a sehr ähnlich, schreiben sie den Kopf auf. Die folgenden Hinweise zeigen den Unterschied zu `right_justify`\n",
- "2. Wie viele Leerzeichen benötigen Sie insgesamt? Wie können Sie das berechnen?\n",
- "3. Diesmal stehen die Leerzeichen auf beiden Seiten des Texts. Wie viele Leerzeichen benötigen Sie vor, wie viele hinter der Zeichenkette?\n",
- "4. Verknüpfen Sie die Leerzeichen und das Argument und geben Sie es mit `print` aus."
+ "\n",
+ "Wenn Sie Ihren Lösungsweg mit einer möglichen Lösung vergleichen wollen, können Sie diese hier finden. Allerdings gibt es häufig mehr als einen Lösungsweg; wenn Ihre Lösung anders aussieht, ist dies nicht zwingend falsch. Wenn Sie sich unsicher sind, fragen Sie bitte nach:"
]
},
{
@@ -1242,8 +1452,8 @@
"outputs": [],
"source": [
"def center(s):\n",
- " space=(70-len(s))//2\n",
- " print(' '*space+s+' '*space)\n",
+ " space=(70 - len(s)) // 2\n",
+ " print(' ' * space + s)\n",
" \n",
"center (\"Das ist der Test\")"
]
@@ -1252,7 +1462,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "#### Aufgabe 2\n",
+ "### Aufgabe 2\n",
"\n",
"Ein Funktionsobjekt ist ein Wert, den wir einer Variablen zuweisen oder auch einer Funktion als Argument übergeben können. Zum Beispiel ist `do_twice` eine Funktion, die ein Funktionsobjekt als Argument erwartet und die Funktion dann zweimal aufruft:"
]
@@ -1286,7 +1496,14 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "***(Hinweis: Mit der Tastenkombination `SHIFT STRG -` können wir einen Block teilen - also `SHIFT` und `STRG` gleichzeitig gedrückt halten und dann die Minustaste drücken. So können Sie Ihren Code direkt hinter jeder der folgenden Teilaufgaben einfügen.)*** "
+ "<details>\n",
+ " <summary type=\"button\" class=\"btn btn-info\">Hinweis</summary>\n",
+ " <div class=\"alert alert-info\" role=\"alert\">\n",
+ " \n",
+ "Mit der Tastenkombination `SHIFT STRG -` können wir einen Block teilen - also `SHIFT` und `STRG` gleichzeitig gedrückt halten und dann die Minustaste drücken. So können Sie Ihren Code direkt hinter jeder der folgenden Teilaufgaben einfügen.\n",
+ "\n",
+ " </div> \n",
+ "</details> "
]
},
{
@@ -1297,10 +1514,107 @@
"2. Ändern Sie `do_twice`, so dass \n",
" - es zwei Argumente erwartet: ein Funktionsobjekt und einen Wert und\n",
" - die übergebene Funktion zweimal aufruft und ihr den Wert als Argument übergibt.\n",
+ " \n",
+ "<details>\n",
+ " <summary type=\"button\" class=\"btn btn-primary\">1. Hinweis</summary>\n",
+ " <div class=\"alert alert-info\" role=\"alert\">\n",
+ " \n",
+ "Wenn die Funktion Argumente erwartet, müssen diese in den Funktionskopf eingefügt werden.\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 Argumente sollten in der Funktionsdefinition Platzhalter und daher Variablen sein.\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",
+ "Verwenden Sie dieselben Platzhaltervariablen im Rumpf der Funktion, um der Funktion zu sagen, was sie mit den Argumenten tun soll.\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",
+ "Haben Sie den Platzhalter für das 'Wertargument' an den Platzhalter der Funktion übergeben?\n",
+ "\n",
+ " </div> \n",
+ "</details>\n",
+ "\n",
+ "\n",
"3. Rufen Sie mit der geänderten Funktion `do_twice` die Funktion `print_twice` (die wir weiter vorne definiert hatten) auf und übergeben Sie ein Wort Ihrer Wahl als Argument.\n",
"4. Definieren Sie eine Funktion `do_four`, die ein Funktionsobjekt und einen Wert erwartet und die übergebene Funktion viermal aufruft und ihr dabei den Wert als Parameter übergibt. Die Funktion `do_four` sollte dabei aus nur zwei Zeilen im Rumpf bestehen, nicht aus vier!\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 den Funktionsaufruf für `do-twice` und übergeben Sie die korrekte Anzahl an Argumenten.\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 wo genau Sie das Wort übergeben müssen, damit `print_twice` es innerhalb der Funktion `do-twice` verwenden kann.\n",
+ " \n",
+ " \n",
+ " </div> \n",
+ "</details>\n",
+ "<details>\n",
+ " <summary type=\"button\" class=\"btn btn-primary\">3. Hinweis</summary>\n",
+ " <div class=\"alert alert-info\" role=\"alert\">\n",
+ " \n",
+ "Schreiben Sie `print_twice` und den Wert mit Kommas getrennt hintereinander in den Funktionsaufruf.\n",
+ " </div> \n",
+ "</details>\n",
+ "\n",
+ "\n",
+ "4. Definieren Sie eine Funktion `do_four`, die ein Funktionsobjekt und einen Wert erwartet und die übergebene Funktion viermal aufruft und ihr dabei den Wert als Parameter übergibt. Die Funktion `do_four` sollte dabei aus nur zwei Zeilen im Rumpf bestehen, nicht aus vier! Rufen Sie die Funktion auf und testen Sie diese!\n",
+ "\n",
+ "<details>\n",
+ " <summary type=\"button\" class=\"btn btn-primary\">1. Hinweis</summary>\n",
+ " <div class=\"alert alert-info\" role=\"alert\">\n",
+ " \n",
+ "Wir überschreiben hier keine der bereits definierten Funktionen und können alle Funktionen, die wir schon verwendet haben, wiederverwenden.\n",
+ " \n",
+ " </div> \n",
+ "</details>\n",
+ "<details>\n",
+ " <summary type=\"button\" class=\"btn btn-primary\">2. Hinweis</summary>\n",
+ " <div class=\"alert alert-info\" role=\"alert\">\n",
+ " \n",
+ "Was passiert wenn Sie `do_twice` zweimal hintereinander ausführen? \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",
+ "Wie müssen Sie die Werte übergeben, sodass diese an der korrekten Stelle verwendet werden können? \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",
+ "`do_four` muss die Werte lediglich direkt an `do_twice` weiterreichen, `do_twice` sollte bereits korrekt mit den Werten umgehen, wenn Sie die Aufgabe schrittweise gelöst haben.\n",
+ " \n",
+ " </div> \n",
+ "</details>"
]
},
{
@@ -1360,11 +1674,19 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "#### Aufgabe 3\n",
+ "### Aufgabe 3\n",
"\n",
- "*Hinweis: Nutzen Sie nur Anweisungen und Funktionen, die wir bereits kennengelernt haben.*\n",
+ "<details>\n",
+ " <summary type=\"button\" class=\"btn btn-info\">Hinweis</summary>\n",
+ " <div class=\"alert alert-info\" role=\"alert\">\n",
+ " \n",
+ "Nutzen Sie nur Anweisungen und Funktionen, die wir bereits kennengelernt haben.\n",
+ " \n",
+ " </div> \n",
+ "</details>\n",
"\n",
- "##### 1.\n",
+ "\n",
+ "#### Aufgabe 3.1\n",
"\n",
"Schreiben Sie eine Funktion, die das folgende Gitter \"zeichnet\":\n",
"\n",
@@ -1381,27 +1703,179 @@
"| | |\n",
"+ - - - - + - - - - +\n",
"```\n",
- "*Hinweis: Um mehr als ein Zeichen pro Zeile zu drucken, können Sie die Zeichen durch Kommata getrennt schreiben. (`print(\"+\",\"-\")`)*\n",
+ "<details>\n",
+ " <summary type=\"button\" class=\"btn btn-info\">Hinweis</summary>\n",
+ " <div class=\"alert alert-info\" role=\"alert\">\n",
+ " \n",
+ "Zeichenketten lassen sich durch den Plus-Operator `+` verbinden.\n",
+ "Außerdem nimmt die `print()`-Funktion auch mehrere Argumente entgegen. Diese müssen durch Kommata getrennt werden:\n",
+ "`print(\"+\", Variable, \"-\")`.\n",
+ " \n",
+ " </div> \n",
+ "</details>\n",
+ "\n",
+ "\n",
+ "\n",
+ "------------------------\n",
+ "\n",
+ "\n",
+ "Wenn Sie nicht wissen, wie Sie an die Aufgabe herangehen können, können Sie die folgenden Hinweise nutzen um den Anfang zu finden. Schauen Sie sich dabei immer so wenige Hinweise an, wie möglich.\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 die verschiedenen Zeilentypen auf, die Sie für das Gitter brauchen.\n",
+ " \n",
+ " </div> \n",
+ "</details>\n",
+ "\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 sich, in welchem Muster die verschiedenen Zeilentypen angeordnet sind. \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",
+ "Überlegen Sie sich, in welchem Muster die verschiedenen Zeilentypen angeordnet sind. Haben Sie bereits eine Funktion definiert, mit der Sie dieselbe Zeile mehrfach hintereinander ausgeben lassen können? \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",
+ " Wenn Sie eine Funktion definieren, die genau eine der Seiten (`| | |`) ausgibt, können Sie `do_four()` verwenden, um diese viermal hintereinander ausgeben zu lassen. Sie können sich dann noch überlegen, ob Sie die Querbalken manuell in der `grid()` Funktion aufschreiben oder ob Sie diese auch in eine Funktion packen und dann an der entsprechenden Stelle diese Funktion aufrufen. \n",
+ " </div> \n",
+ "</details>\n",
+ "\n",
+ "\n",
+ "Beachten Sie bitte, dass es fast immer mehr als einen Weg gibt, die Aufgaben zu lösen. Solange die Ausgabe stimmt, haben Sie wahrscheinlich alles richtig gemacht.\n",
+ "\n",
+ "#### Aufgabe 3.2 \n",
+ "\n",
+ "Schreiben Sie eine ähnliche Funktion, die ein Gitter mit je 4 Reihen und Zeilen zeichnet.\n",
+ "\n",
+ "Bevor Sie anfangen Ihre eigene Lösung zu entwickeln, schauen Sie sich den folgenden Code an und versuchen Sie zu verstehen, was er macht. Führen Sie ihn aus und beschreiben Sie, warum er die Aufgabe nicht löst."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def do_two(f):\n",
+ " f()\n",
+ " f()\n",
+ " \n",
+ "def setup():\n",
+ " print(\"+ - + - +\")\n",
+ " print(\"| | |\")\n",
+ "\n",
+ "\n",
+ "def minigrid():\n",
+ " do_two(setup)\n",
+ " print(\"+ - + - +\")\n",
+ " \n",
+ "minigrid()\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "<details>\n",
+ " <summary type=\"button\" class=\"btn btn-success\">Lösung</summary>\n",
+ " <div class=\"alert alert-success\" role=\"alert\">\n",
+ " \n",
+ "Hier wird ein Gitter gezeichnet, welches auch aus 4 Kästchen besteht, die aber viel kleiner sind als die Kästchen in Aufgabenteil 1. In dieser Aufgabe wird nicht verlangt, dass die Kästchengröße verändert wird. Es sollen stattdessen insgesamt 16 Kästchen gezeichnet werden, das Muster soll sich also vergrößern, nicht verkleinern. \n",
+ " </div> \n",
+ "</details>\n",
+ "\n",
+ "\n",
+ "Wenn Sie verstanden haben, warum die obige Lösung nicht korrekt ist, können Sie versuchen, eine korrekte Lösung zu entwickeln.\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 das gewünschte Gitter aussehen soll. Wie unterscheidet es sich von dem ersten Gitter? Erstellen Sie eventuell per Hand eine grobe Skizze, damit Sie sich anschauen können, wo sich das Muster wiederholt. \n",
+ " \n",
+ " </div> \n",
+ "</details>\n",
+ "\n",
+ "\n",
+ "<details>\n",
+ " <summary type=\"button\" class=\"btn btn-primary\">2. Hinweis</summary>\n",
+ " <div class=\"alert alert-info\" role=\"alert\">\n",
+ " \n",
+ "Zuerst müssen wir die beiden Zeilentypen korrekt erstellen. Dafür könnten wir schlicht und ergreifend jeweils die Zeile einmal aufschreiben. Dieser Ansatz ist aber sehr fehleranfällig, stattdessen ist es besser, wenn wir mit der Verkettung durch `*` und `+` arbeiten.\n",
+ " </div> \n",
+ "</details>\n",
"\n",
- "##### 2. \n",
"\n",
- "Schreiben Sie eine ähnliche Funktion die ein Gitter mit je 4 Reihen und Zeilen zeichnet."
+ "<details>\n",
+ " <summary type=\"button\" class=\"btn btn-primary\">3. Hinweis</summary>\n",
+ " <div class=\"alert alert-info\" role=\"alert\">\n",
+ " \n",
+ "Um die Zeile optimiert aufzuschreiben, können Sie eine Variable erstellen und ihr das erste Viertel der Zeile zuweisen. Dann können Sie mit Hilfe von Verkettung dieses Viertel vier mal ausgeben und mit dem Schlusszeichen abschließen.\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",
+ "Überlegen Sie sich, was Sie aus der vorherigen Lösung übernehmen können, um das Gitter darzustellen. Wie müssen Sie die Zeilenwiederholung anpassen, damit das korrekte Ergebnis angezeigt wird?\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",
+ "Sie müssen je 4 mal *den horizontal Balken gefolgt von 4 Seitenwänden* ausgeben lassen und zum Schluss noch einen horizontalen Balken zeichnen.\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",
+ "Auch wenn diese Version funktioniert, ist sie doch nicht sehr effektiv und wir können Sie verbessern. Eine Folge von Anweisungen wird 4 mal ausgeführt. Wenn wir diese Folge in eine eigene Funktion packen, können wir `do_four()` verwenden, um diese Folge viermal auszuführen und unseren Code somit beträchtlich kürzen.\n",
+ " \n",
+ " </div> \n",
+ "</details>\n",
+ "\n",
+ "\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
- "Wie gehabt, folgt jetzt die Lösung, lesen Sie erst weiter, wenn Sie die Aufgabe gelöst haben oder Schritt für Schritt wenn Sie überhaupt nicht weiterkommen.\n",
+ "Wie gehabt, folgt jetzt die Lösung. Lesen Sie erst weiter, wenn Sie die Aufgabe gelöst haben und sich eine Musterlösung anschauen wollen. Nutzen Sie zunächst die Hinweise, die Sie weiter oben im Text finden, um Ihre eigene Lösung zu entwickeln.\n",
"\n",
"\n",
"([Spoiler Alert](https://xkcd.com/109/), Randall Munroe)\n",
"\n",
- "Zuerst ein paar Tipps um die Aufgabe selber zu lösen. Lesen Sie nicht alle Tipps auf einmal durch:\n",
+ "Zuerst ein paar Tipps, um die Aufgabe selber zu lösen. Lesen Sie nicht alle Tipps auf einmal durch:\n",
"\n",
- "1. Welche Zeilen müssen wir überhaupt ausgeben? Schreiben Sie die Zeilen einzel auf.\n",
- "2. Wie sieht das Gitter aus? Können sie es mit einer Reihe von `print`-Statements darstellen?\n",
- "3. Welche Zeilen wiederholen sich? Können sie diese mit Hilfe von Funktionen zusammenfassen?\n",
+ "1. Welche Zeilen müssen wir überhaupt ausgeben? Schreiben Sie die Zeilen einzeln auf.\n",
+ "2. Wie sieht das Gitter aus? Können Sie es mit einer Reihe von `print`-Statements darstellen?\n",
+ "3. Welche Zeilen wiederholen sich? Können Sie diese mit Hilfe von Funktionen zusammenfassen?\n",
"\n",
"\n",
"Dies ist nur eine mögliche Lösung, weitere Lösungsmöglichkeiten finden sie [hier](http://greenteapress.com/thinkpython2/code/grid.py)"
@@ -1413,18 +1887,33 @@
"metadata": {},
"outputs": [],
"source": [
- "def print_sides():\n",
- " print(\"|\", \" \"*8,\"|\", \" \"*8,\"|\")\n",
- " print(\"|\", \" \"*8,\"|\", \" \"*8,\"|\")\n",
- " print(\"|\", \" \"*8,\"|\", \" \"*8,\"|\")\n",
- " print(\"|\", \" \"*8,\"|\", \" \"*8,\"|\")\n",
+ "#Für Aufgabe 3.1 ein 2*2 Grid:\n",
+ "\n",
+ "# Wir verwenden vorher definierte Funktionen, um uns Aufwand zu sparen.\n",
+ "def do_twice(f):\n",
+ " f()\n",
+ " f()\n",
+ "\n",
+ "def do_four(f):\n",
+ " do_twice(f)\n",
+ " do_twice(f)\n",
"\n",
+ "def print_innerSide(): \n",
+ " '''Die Funktion definiert eine der mittleren Seiten (| | |) und gibt diese aus.'''\n",
+ " print(\"|\" + \" \" * 9 + \"|\" + \" \" * 9 + \"|\")\n",
+ " \n",
+ "def print_edge(): \n",
+ " '''Die Funktion definiert die Kanten (+ - - - - + - - - - +) und gibt diese aus.''' \n",
+ " print (\"+ \" + \"- \" * 4 + \"+ \" + \"- \" * 4 + \"+\") \n",
+ " \n",
+ " \n",
"def print_grid():\n",
- " print (\"+\", \"- \"*4, \"+\", \"- \"*4, \"+\")\n",
- " print_sides()\n",
- " print(\"+\", \"- \"*4, \"+\", \"- \"*4, \"+\")\n",
- " print_sides()\n",
- " print(\"+\", \"- \"*4, \"+\", \"- \"*4, \"+\")\n",
+ " '''Wir nutzen die vorher definierten Funktionen, um das Gitter zu definieren und auszugeben.''' \n",
+ " print_edge()\n",
+ " do_four(print_innerSide)\n",
+ " print_edge()\n",
+ " do_four(print_innerSide)\n",
+ " print_edge()\n",
" \n",
"print_grid()"
]
@@ -1435,27 +1924,40 @@
"metadata": {},
"outputs": [],
"source": [
- "def do_two(f):\n",
- " f()\n",
- " f()\n",
+ "#Für Aufgabe 3.2 ein 4*4 Grid:\n",
" \n",
- "def setup():\n",
- " print(\"+\",\"-\",\"+\",\"-\",\"+\")\n",
- " print(\"|\", \" \",\"|\", \" \",\"|\")\n",
+ "def print_innerSide_bigGrid():\n",
+ " '''Ausgabe einer inneren Seite'''\n",
+ " \n",
+ " side_part = \"|\" + \" \" * 9\n",
+ " print(side_part * 4 + \"|\")\n",
"\n",
+ " \n",
+ "\n",
+ "def print_edge_bigGrid():\n",
+ " '''Ausgabe einer Kante'''\n",
+ " edge_part = \"+ \" + \"- \" * 4\n",
+ " print(edge_part * 4 + \"+\")\n",
"\n",
- "def minigrid():\n",
- " do_two(setup)\n",
- " print(\"+\",\"-\",\"+\",\"-\",\"+\")\n",
" \n",
- "minigrid()\n"
+ "def print_gridRow():\n",
+ " '''Ausgabe einer Gitterzeile'''\n",
+ " print_edge_bigGrid()\n",
+ " do_four(print_innerSide_bigGrid)\n",
+ "\n",
+ "def print_row():\n",
+ " '''Ausgabe des vollständigen Gitters'''\n",
+ " do_four(repeat)\n",
+ " print_edge_bigGrid()\n",
+ " \n",
+ "fullgrid()\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
- "#### Bonusaufgabe\n",
+ "### Bonusaufgabe\n",
"\n",
" Finden Sie einen Algorithmus zur Lösung des folgenden Problems:\n",
" *Gegeben sei eine positive ganze Zahl `n`. Finden Sie eine Liste\n",
--
GitLab