From 1a858eda3f7395de2305432a96d5ab6fab029d91 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Robert=20J=C3=A4schke?= <jaeschke@l3s.de>
Date: Wed, 6 Dec 2017 08:02:19 +0000
Subject: [PATCH] =?UTF-8?q?Flie=C3=9Fkommazahl=20>=20Gleitkommazahl=20+=20?=
=?UTF-8?q?Seminar=205?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
img/stapeldiagramm_countdown.pdf | Bin 0 -> 18756 bytes
img/stapeldiagramm_countdown.svg | 211 ++++++
notebooks/hausaufgabe1.ipynb | 2 +-
notebooks/seminar01.ipynb | 8 +-
notebooks/seminar03.ipynb | 8 +-
notebooks/seminar04.ipynb | 1 +
notebooks/seminar05.ipynb | 1025 ++++++++++++++++++++++++++++++
7 files changed, 1246 insertions(+), 9 deletions(-)
create mode 100644 img/stapeldiagramm_countdown.pdf
create mode 100644 img/stapeldiagramm_countdown.svg
create mode 100644 notebooks/seminar05.ipynb
diff --git a/img/stapeldiagramm_countdown.pdf b/img/stapeldiagramm_countdown.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..e8708a889d5b4b8eb59a19a7ea7b60fbb769c4da
GIT binary patch
literal 18756
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
literal 0
HcmV?d00001
diff --git a/img/stapeldiagramm_countdown.svg b/img/stapeldiagramm_countdown.svg
new file mode 100644
index 0000000..dae7863
--- /dev/null
+++ b/img/stapeldiagramm_countdown.svg
@@ -0,0 +1,211 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Created with Inkscape (http://www.inkscape.org/) -->
+
+<svg
+ xmlns:dc="http://purl.org/dc/elements/1.1/"
+ xmlns:cc="http://creativecommons.org/ns#"
+ xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+ xmlns:svg="http://www.w3.org/2000/svg"
+ xmlns="http://www.w3.org/2000/svg"
+ xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+ xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+ width="210mm"
+ height="297mm"
+ viewBox="0 0 210 297"
+ version="1.1"
+ id="svg8"
+ inkscape:version="0.92.1 r15371"
+ sodipodi:docname="stack_diagram_countdown.svg">
+ <defs
+ id="defs2" />
+ <sodipodi:namedview
+ id="base"
+ pagecolor="#ffffff"
+ bordercolor="#666666"
+ borderopacity="1.0"
+ inkscape:pageopacity="0.0"
+ inkscape:pageshadow="2"
+ inkscape:zoom="3.0227835"
+ inkscape:cx="250.94239"
+ inkscape:cy="966.01732"
+ inkscape:document-units="mm"
+ inkscape:current-layer="layer1"
+ showgrid="false"
+ inkscape:window-width="1920"
+ inkscape:window-height="1010"
+ inkscape:window-x="0"
+ inkscape:window-y="33"
+ inkscape:window-maximized="1" />
+ <metadata
+ id="metadata5">
+ <rdf:RDF>
+ <cc:Work
+ rdf:about="">
+ <dc:format>image/svg+xml</dc:format>
+ <dc:type
+ rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+ <dc:title />
+ </cc:Work>
+ </rdf:RDF>
+ </metadata>
+ <g
+ inkscape:label="Ebene 1"
+ inkscape:groupmode="layer"
+ id="layer1">
+ <text
+ xml:space="preserve"
+ style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:4.23333311px;line-height:100%;font-family:arial;-inkscape-font-specification:arial;text-align:center;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:middle;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.26458332px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+ x="29.623943"
+ y="26.790508"
+ id="text4487"><tspan
+ sodipodi:role="line"
+ id="tspan4485"
+ x="29.623943"
+ y="26.790508"
+ style="stroke-width:0.26458332px">__main__</tspan><tspan
+ sodipodi:role="line"
+ x="29.623943"
+ y="31.023842"
+ style="stroke-width:0.26458332px"
+ id="tspan4489" /></text>
+ <text
+ id="text4495"
+ y="37.232071"
+ x="29.024496"
+ style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:4.23333311px;line-height:100%;font-family:arial;-inkscape-font-specification:arial;text-align:center;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:middle;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.26458332px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+ xml:space="preserve"><tspan
+ id="tspan4493"
+ style="stroke-width:0.26458332px"
+ y="37.232071"
+ x="29.024496"
+ sodipodi:role="line">countdown</tspan></text>
+ <text
+ xml:space="preserve"
+ style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:4.23333311px;line-height:100%;font-family:arial;-inkscape-font-specification:arial;text-align:center;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:middle;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.26458332px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+ x="29.024496"
+ y="56.531811"
+ id="text4501"><tspan
+ sodipodi:role="line"
+ x="29.024496"
+ y="56.531811"
+ style="stroke-width:0.26458332px"
+ id="tspan4499">countdown</tspan></text>
+ <g
+ id="g4506"
+ transform="translate(-0.43764877,-0.765871)">
+ <rect
+ y="52.354485"
+ x="44.727676"
+ height="6.6522536"
+ width="18"
+ id="rect4537"
+ style="opacity:0.99823531;fill:#aaccff;fill-opacity:0.60784314;stroke:#0067ff;stroke-width:0.26499999;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1" />
+ <text
+ xml:space="preserve"
+ style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:4.23333311px;line-height:100%;font-family:arial;-inkscape-font-specification:arial;text-align:center;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:middle;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.26458332px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+ x="48.266571"
+ y="56.955494"
+ id="text4527"><tspan
+ sodipodi:role="line"
+ x="48.266571"
+ y="56.955494"
+ style="text-align:start;text-anchor:start;stroke-width:0.26458332px"
+ id="tspan4525">n → 1</tspan></text>
+ </g>
+ <rect
+ y="22.244329"
+ x="44.290028"
+ height="6.6522541"
+ width="18"
+ id="rect4501"
+ style="opacity:0.99823531;fill:#aaccff;fill-opacity:0.60784314;stroke:#0067ff;stroke-width:0.26499999;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1" />
+ <g
+ id="g4514"
+ transform="translate(-0.43764877,-10.547299)">
+ <rect
+ style="opacity:0.99823531;fill:#aaccff;fill-opacity:0.60784314;stroke:#0067ff;stroke-width:0.26499999;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
+ id="rect4508"
+ width="18"
+ height="6.6522536"
+ x="44.727676"
+ y="52.354485" />
+ <text
+ id="text4512"
+ y="56.955494"
+ x="48.266571"
+ style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:4.23333311px;line-height:100%;font-family:arial;-inkscape-font-specification:arial;text-align:center;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:middle;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.26458332px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+ xml:space="preserve"><tspan
+ id="tspan4510"
+ style="text-align:start;text-anchor:start;stroke-width:0.26458332px"
+ y="56.955494"
+ x="48.266571"
+ sodipodi:role="line">n → 2</tspan></text>
+ </g>
+ <g
+ transform="translate(-0.43764877,-20.328727)"
+ id="g4522">
+ <rect
+ y="52.354485"
+ x="44.727676"
+ height="6.6522536"
+ width="18"
+ id="rect4516"
+ style="opacity:0.99823531;fill:#aaccff;fill-opacity:0.60784314;stroke:#0067ff;stroke-width:0.26499999;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1" />
+ <text
+ xml:space="preserve"
+ style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:4.23333311px;line-height:100%;font-family:arial;-inkscape-font-specification:arial;text-align:center;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:middle;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.26458332px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+ x="48.266571"
+ y="56.955494"
+ id="text4520"><tspan
+ sodipodi:role="line"
+ x="48.266571"
+ y="56.955494"
+ style="text-align:start;text-anchor:start;stroke-width:0.26458332px"
+ id="tspan4518">n → 3</tspan></text>
+ </g>
+ <g
+ id="g4530"
+ transform="translate(-0.43764877,9.0155572)">
+ <rect
+ style="opacity:0.99823531;fill:#aaccff;fill-opacity:0.60784314;stroke:#0067ff;stroke-width:0.26499999;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
+ id="rect4524"
+ width="18"
+ height="6.6522536"
+ x="44.727676"
+ y="52.354485" />
+ <text
+ id="text4528"
+ y="56.955494"
+ x="48.266571"
+ style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:4.23333311px;line-height:100%;font-family:arial;-inkscape-font-specification:arial;text-align:center;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:middle;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.26458332px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+ xml:space="preserve"><tspan
+ id="tspan4526"
+ style="text-align:start;text-anchor:start;stroke-width:0.26458332px"
+ y="56.955494"
+ x="48.266571"
+ sodipodi:role="line">n → 0</tspan></text>
+ </g>
+ <text
+ xml:space="preserve"
+ style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:4.23333311px;line-height:100%;font-family:arial;-inkscape-font-specification:arial;text-align:center;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:middle;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.26458332px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+ x="29.024496"
+ y="46.881939"
+ id="text4534"><tspan
+ sodipodi:role="line"
+ x="29.024496"
+ y="46.881939"
+ style="stroke-width:0.26458332px"
+ id="tspan4532">countdown</tspan></text>
+ <text
+ id="text4538"
+ y="66.181686"
+ x="29.024496"
+ style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:4.23333311px;line-height:100%;font-family:arial;-inkscape-font-specification:arial;text-align:center;letter-spacing:0px;word-spacing:0px;writing-mode:lr-tb;text-anchor:middle;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.26458332px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+ xml:space="preserve"><tspan
+ id="tspan4536"
+ style="stroke-width:0.26458332px"
+ y="66.181686"
+ x="29.024496"
+ sodipodi:role="line">countdown</tspan></text>
+ </g>
+</svg>
diff --git a/notebooks/hausaufgabe1.ipynb b/notebooks/hausaufgabe1.ipynb
index cf2b7b0..239d07e 100644
--- a/notebooks/hausaufgabe1.ipynb
+++ b/notebooks/hausaufgabe1.ipynb
@@ -183,7 +183,7 @@
"Hinweise:\n",
"- Sie können die Aufgabe auch ohne eine Schleife lösen, aber schöner ist es mit einer Schleife. Sie kennen die Syntax und Semantik der `while`-Schleife schon aus der Vorlesung. Sie funktioniert in Python genau so, wie sie für den Pseudocode definiert wurde. \n",
"- Sie müssen selbst entscheiden, wieviele Werte Sie im verlangten Intervall berechnen. Die Kurve oben wurde mit einem Rasterabstand von 0.2 berechnet (d.h., für die Werte 0, 0.2, 0.4, 0.6, ..., 6.2). \n",
- "- Denken Sie daran, dass Sie mit der `int`-Funktion eine Fließkommazahl in eine ganze Zahl umwandeln können (der Dezimalanteil wird abgeschnitten).\n",
+ "- Denken Sie daran, dass Sie mit der `int`-Funktion eine Gleitkommazahl in eine ganze Zahl umwandeln können (der Dezimalanteil wird abgeschnitten).\n",
"- Damit Sie die Funktion `math.sin` nutzen können, müssen Sie anfangs das `math`-Modul importieren."
]
},
diff --git a/notebooks/seminar01.ipynb b/notebooks/seminar01.ipynb
index 45756ef..f1ca714 100644
--- a/notebooks/seminar01.ipynb
+++ b/notebooks/seminar01.ipynb
@@ -153,7 +153,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "Die 17 ist eine **ganze Zahl** (Englisch: *Integer*), wir können aber auch Zahlen mit Dezimalanteil, sogenannte **Fließkommazahlen** (Englisch: *Float*) verwenden:"
+ "Die 17 ist eine **ganze Zahl** (Englisch: *Integer*), wir können aber auch Zahlen mit Dezimalanteil, sogenannte **Gleitkommazahlen** (Englisch: *Float*) verwenden:"
]
},
{
@@ -234,7 +234,7 @@
"Ein **Wert**, also z.B. eine Zahl oder eine Zeichenkette, ist eines der grundlegenden Dinge, die in einem Programm verarbeitet werden. Beispiele für Werte, die wir schon gesehen haben sind `\"Hello World!\"`, `17` und `3.1415926`. Diese Werte haben verschiedenen **Datentypen**:\n",
"- `\"Hello World!\"` ist eine **Zeichenkette** (*string* auf Englisch)\n",
"- `17` ist eine **ganze Zahl** (*integer* auf Englisch)\n",
- "- `3.1415926` ist eine **Fließkommazahl** (*float* auf Englisch)\n",
+ "- `3.1415926` ist eine **Gleitkommazahl** (*float* auf Englisch)\n",
"\n",
"Wenn wir uns nicht sicher sind, welchen Datentyp ein Wert hat, können wir es mit der Funktion `type` herausfinden:"
]
@@ -359,7 +359,7 @@
"- Datentyp: \n",
"- Zeichenkette:\n",
"- ganze Zahl:\n",
- "- Fließkommazahl:\n",
+ "- Gleitkommazahl:\n",
"- bug:\n",
"- debugging:\n",
"\n",
@@ -374,7 +374,7 @@
"\n",
"Neben vielen neuen Begriffen haben wir folgende wichtige Programmierfähigkeiten gelernt:\n",
"- wir können Werte und Berechnungen durchführen und mit Hilfe der `print`-Funktion ausgeben\n",
- "- wir können die Datentypen Zeichenkette, ganze Zahl und Fließkommazahl voneinander unterscheiden und den Datentyp eines gegebenen Wertes mit Hilfe der `type`-Funktion herausfinden\n",
+ "- wir können die Datentypen Zeichenkette, ganze Zahl und Gleitkommazahl voneinander unterscheiden und den Datentyp eines gegebenen Wertes mit Hilfe der `type`-Funktion herausfinden\n",
"- wir können mehrere Anweisungen hintereinanderausführen, indem wir sie als Folge zeilenweise untereinander schreiben"
]
},
diff --git a/notebooks/seminar03.ipynb b/notebooks/seminar03.ipynb
index 8a3583b..64e6035 100644
--- a/notebooks/seminar03.ipynb
+++ b/notebooks/seminar03.ipynb
@@ -113,7 +113,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "Mit Hilfe der `int`-Funktion können wir zum Beispiel Fließkommazahlen in ganze Zahlen umwandeln:"
+ "Mit Hilfe der `int`-Funktion können wir zum Beispiel Gleitkommazahlen in ganze Zahlen umwandeln:"
]
},
{
@@ -145,7 +145,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "Analog dazu können wir mit der `float`-Funktion ganze Zahlen und Zeichenketten in Fließkommazahlen umwandeln:"
+ "Analog dazu können wir mit der `float`-Funktion ganze Zahlen und Zeichenketten in Gleitkommazahlen umwandeln:"
]
},
{
@@ -705,7 +705,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "### Stapel-Diagramme\n",
+ "### 3.9 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",
@@ -1149,7 +1149,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "Tipp zur Lösung: Mit dem Operator `//` können wir zwei ganze Zahlen so teilen, dass eine ganze Zahl (*integer*) herauskommt. Während `7 / 2` die Fließkommazahl `3.5` ergibt, erhalten wir bei `7 // 2` die ganze Zahl `3` (es wird stets abgerundet).\n",
+ "Tipp zur Lösung: 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",
"Ein Aufruf der Funktion mit den folgenden Argumenten:"
]
diff --git a/notebooks/seminar04.ipynb b/notebooks/seminar04.ipynb
index 6aa6d35..110baea 100644
--- a/notebooks/seminar04.ipynb
+++ b/notebooks/seminar04.ipynb
@@ -83,6 +83,7 @@
"import turtle\n",
"bob = turtle.Turtle()\n",
"print(bob)\n",
+ "bob.fd(100)\n",
"turtle.mainloop()"
]
},
diff --git a/notebooks/seminar05.ipynb b/notebooks/seminar05.ipynb
new file mode 100644
index 0000000..9b444c4
--- /dev/null
+++ b/notebooks/seminar05.ipynb
@@ -0,0 +1,1025 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Seminar Problemorientierte Programmierung\n",
+ "\n",
+ "## Exkurs: Was mir an Python gefällt\n",
+ "\n",
+ "In dieser Rubrik, die immer am Anfang eines Kapitels steht, möchte ich Ihnen zeigen, wofür ich Python nutze und warum ich es mag. Sie werden vielleicht noch nicht verstehen, was ich genau mache, aber Sie sehen damit schon einmal die Möglichkeiten von Python und können später darauf zurückgreifen. Da dies auch ein Exkurs ist, können Sie diese Rubrik gerne auch erst einmal überspringen.\n",
+ "\n",
+ "Mit den Operatoren aus diesem Kapitel können wir ganz leicht das Verfahren zur Umwandlung einer Dezimalzahl in ihre Binärdarstellung implementieren:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Umwandlung einer positiven, ganzen Dezimalzahl in Binärdarstellung (als Zeichenkette)\n",
+ "def dez_zu_bin(n):\n",
+ " ergebnis = \"\"\n",
+ " while n > 0:\n",
+ " ergebnis = str(n % 2) + ergebnis\n",
+ " n = n // 2\n",
+ " return ergebnis\n",
+ "\n",
+ "print(dez_zu_bin(42))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## 5 Verzweigungen und Rekursion\n",
+ "\n",
+ "Das Thema dieses Kapitels ist die `if`-Anweisung, die unterschiedlichen Code ausführt, je nach Zustand des Programms. Aber schauen wir uns zunächst zwei neue Operatoren an: Ganzzahldivision und Restberechnung.\n",
+ "\n",
+ "### 5.1 Ganzzahldivision und Restberechnung\n",
+ "\n",
+ "Der Operator `//` für die **Ganzzahldivision** teilt zwei ganze Zahlen und rundet das Ergebnis zu einer ganzen Zahl ab. \n",
+ "\n",
+ "Angenommen, wir wollen wissen, wie lang ein Film über 105 Minuten in Stunden ist. Bei der üblichen Division erhalten wir eine Gleitkommazahl: "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "minuten = 105\n",
+ "minuten/60"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Aber normalerweise schreiben wir Stundenangaben nicht mit Dezimalpunkt. Mit der Ganzzahldivision können wir die Stunden als ganze Zahl berechnen, wobei abgerundet wird:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "minuten = 105\n",
+ "stunden = minuten // 60\n",
+ "print(stunden)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Um den Rest der Division zu berechnen, könnten wir eine Stunde in Minuten abziehen:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "rest = minuten - stunden * 60\n",
+ "print(rest)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Alternativ können wir auch den Operator `%` zur **Restberechnung** verwenden. Dieser teilt zwei ganze Zahlen und gibt uns den Rest zurück:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "rest = minuten % 60\n",
+ "print(rest)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Dieser Operator ist nützlicher, als es auf den ersten Blick erscheinen mag. Beispielsweise können wir damit leicht prüfen, ob eine Zahl durch eine andere Zahl teilbar ist - wenn `x % y` gleich Null ist, dann ist `x` durch `y` teilbar.\n",
+ "\n",
+ "Außerdem können wir damit die am weitesten rechts liegende Ziffer einer Zahl extrahieren. Beispielsweise ergibt `x % 10` die am weitesten rechts liegende Ziffer von `x`, also die Einerstelle (in der Basis 10). Analog liefert uns `x % 100` die letzten beiden Ziffern:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "4711 % 100"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Berechnen Sie, wie viele Stunden und Minuten 1270 Minuten ergeben: "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "zeit = 1270\n",
+ "\n",
+ "# Fügen Sie hier den Code ein, um die Anzahl Stunden und Minuten zu berechnen\n",
+ "\n",
+ "print(zeit, \"Minuten entsprechen\", stunden, \"Stunden und\", minuten, \"Minuten\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "```1270 Minuten entsprechen 21 Stunden und 10 Minuten``` ist die richtige Ausgabe"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### 5.2 Boolesche Ausdrücke\n",
+ "\n",
+ "Ein **Boolescher Ausdruck** 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,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "5 == 5"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "5 == 6"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "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,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "type(True)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "type(False)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Der `==`-Operator ist einer der sogenannten **relationalen Operatoren**; 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. Wir merken uns: `=` ist der Zuweisungsoperator und `==` ist ein relationaler Operator. Die Operatoren `=<` und `=>` gibt es nicht."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### 5.3 Logische Operatoren\n",
+ "\n",
+ "Es gibt drei **logische Operatoren**: `and`, `or` und `not`. Die Semantik (Bedeutung) dieser drei Operatoren ist ähnlich der Bedeutung der englischen Wörter. Beispielsweise ist `x > 0 and x < 10` genau dann wahr, wenn `x` größer als 0 *und* kleiner als 10 ist.\n",
+ "\n",
+ "`n%2 == 0 or n%3 == 0` ist wahr wenn *eine oder beide* der Bedingungen wahr ist, das heißt wenn die Zahl `n` durch 2 *oder* drei teilbar ist.\n",
+ "\n",
+ "Genaugenommen sollten die Operanden der logischen Operatoren Boolesche Ausdrücke sein, aber Python erlaubt uns da mehr Freiheit. Jede Zahl ungleich Null wird als `True` interpretiert:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "42 and True"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Diese Flexibilität kann nützlich sein, aber es gibt ein paar Feinheiten, die verwirrend sein könnten. Daher sollten Sie diese Variante eher vermeiden (außer, Sie wissen, was Sie tun)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### 5.4 Verzweigungen\n",
+ "\n",
+ "Um nützliche Programme zu schreiben, benötigen wir fast immer die Möglichkeit, Bedingungen zu prüfen und das Verhalten des Programms entsprechend anzupassen. **Verzweigungen** ermöglichen uns dies. Die einfachste Form ist die `if`-Anweisung:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "if x > 0:\n",
+ " print('x ist eine positive Zahl')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "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",
+ "Fügen Sie im folgenden Beispiel eine Anweisung vor der Verzweigung ein, so dass die Bedingung erfüllt ist: "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "if x % 2 == 0:\n",
+ " print(\"x ist eine gerade Zahl\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "`if`-Anweisungen haben die gleiche Struktur wie Funktionsdefinitionen: ein (Verzweigungs-)Kopf gefolgt von einem eingerückten (Verzweigungs-)Rumpf. Anweisungen dieser Art werden **Verbundanweisungen** genannt. \n",
+ "\n",
+ "Die Anzahl an Anweisungen, die im Rumpf stehen können ist nicht begrenzt, aber es muss mindestens eine Anweisung 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,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "if x < 0:\n",
+ " pass # TODO: Behandlung negativer Werte implementieren!"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### 5.5 Alternative Verzweigung\n",
+ "\n",
+ "Eine zweite Form der `if`-Anweisung ist die \"alternative Verzweigung\", bei der es zwei Möglichkeiten gibt und die Bedingung festglegt, welche davon ausgeführt wird. Die Syntax ist folgendermaßen:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "if x % 2 == 0:\n",
+ " print(\"x ist gerade\")\n",
+ "else:\n",
+ " print(\"x ist ungerade\") "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "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. 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",
+ "metadata": {},
+ "source": [
+ "### 5.6 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**:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "if x < y:\n",
+ " print(x, '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",
+ "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, aber es muss 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",
+ "metadata": {},
+ "source": [
+ "### 5.7 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,
+ "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",
+ "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 möglichst 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 einfach Verzweigung umschreiben:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "if 0 < x:\n",
+ " if x < 10:\n",
+ " print(x, 'ist eine positive einstellige Zahl.')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "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,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "if 0 < x and x < 10:\n",
+ " print(x, 'ist eine positive einstellige Zahl.')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Für diese Art der Bedingung bietet Python sogar eine noch kürzere Schreibweise:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "if 0 < x < 10:\n",
+ " print(x, 'ist eine positive einstellige Zahl.')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Schreiben Sie die folgende verschachtelte Verzweigung so um, dass nur noch eine Verzweigung verwendet wird:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "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 oder 4 teilbar\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Fügen Sie hier Ihren Code ein"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### 5.8 Rekursion\n",
+ "\n",
+ "Um Rekursion zu verstehen, gehen Sie zu [Abschnitt 5.8](#5.8-Rekursion) und lesen Sie diesen.\n",
+ "\n",
+ " \n",
+ "\n",
+ "([Tabletop Roleplaying](https://xkcd.com/244/), Randall Munroe)\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:\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "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",
+ "metadata": {},
+ "source": [
+ "Wenn `n` Null ist oder negativ, 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,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "countdown(3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "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 selber auf ...\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 selber auf ...\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 selber auf ...\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",
+ "Als weiteres Beispiel schreiben wir eine Funktion die eine Zeichenkette `n` mal ausgibt:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def print_n(s, n):\n",
+ " if n <= 0:\n",
+ " return\n",
+ " print(s)\n",
+ " print_n(s, n-1)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Wenn `n <= 0` ist, dann beendet die **return-Anweisung** die Funktion. Der Kontrollfluss kehrt dann sofort zur aufrufenden Stelle zurück und die übrigen Anweisungen in der Funktion werden nicht ausgeführt. \n",
+ "\n",
+ "Der Rest der Funktion ist ähnlich zu `countdown`: `s` wird ausgegeben und dann ruft die Funktion sich selbst auf, um `s` `n-1` mal auszugeben. Die Anzahl der Zeilen die ausgegeben werden ist also 1 + (n - 1), was gleich `n` ist.\n",
+ "\n",
+ "Für solche einfachen Beispiele ist es wohl einfacher, eine `for`-Schleife zu verwenden. Aber wir werden später Beispiele sehen, die eher schwierig mit einer `for`-Schleife zu implementieren sind, jedoch sehr einfach mittels Rekursion. "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### 5.9 Stapeldiagramme für rekursive Funktionen\n",
+ "\n",
+ "In [Abschnitt 3.9](seminar03.ipynb#3.9-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",
+ "Die folgende Abbildung zeigt ein Stapeldiagramm für den Aufruf von `countdown(3)`:\n",
+ "\n",
+ "\n",
+ "\n",
+ "Wie üblich, ist oben auf dem Stapel der Block für `__main__`. Dieser ist leer, denn wir haben in `main` keine Variablen erstellt oder Argumente übergeben.\n",
+ "\n",
+ "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** genannt. In diesem gibt es keinen rekursiven Aufruf, daher gibt es keine weiteren Blöcke.\n",
+ "\n",
+ "Zeichnen Sie als Übung ein Stapeldiagramm für `print_n`, wenn es mit `s = 'Hallo'` und `n = 2` aufgerufen wird. 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. \n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### 5.10 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** genannt und ist im Allgemeinen keine gute Idee. Das hier ist ein minimales Programm mit unendlicher Rekursion:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def recurse():\n",
+ " recurse()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "In den meisten Ausführungsumgebungen läuft ein Programm mit unendlicher Rekursion nicht wirklich für immer. Python gibt uns eine Fehlermeldung aus wenn die maximale Rekursionstiefe erreicht ist:\n",
+ "\n",
+ "```\n",
+ "Traceback (most recent call last):\n",
+ " File \"<stdin>\", line 1, in <module>\n",
+ " File \"<stdin>\", line 2, in recurse\n",
+ " File \"<stdin>\", line 2, in recurse\n",
+ " .\n",
+ " .\n",
+ " .\n",
+ " File \"<stdin>\", line 2, in recurse\n",
+ "RecursionError: maximum recursion depth exceeded\n",
+ "```\n",
+ "\n",
+ "Dieser Traceback ist etwas größer als der, den wir im vorherigen Kapitel gesehen haben. Wenn der Fehler auftritt, befinden sich 1000 `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."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### 5.11 Tastatur-Eingaben\n",
+ "\n",
+ "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,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "text = input()\n",
+ "print(text)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "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,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "name = input(\"Wie lautet Ihr Name?\\n\")\n",
+ "print(name)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Die Folge `\\n` am Ende des Hinweises repräsentiert einen **Zeilenumbruch** -- 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,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "prompt = \"Wie hoch ist die Fluggeschwindigkeit einer unbeladeten Schwalbe?\\n\"\n",
+ "speed = input(prompt)\n",
+ "int(speed)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Wenn der Nutzer etwas anderes als eine Zeichenkette mit Ziffern eintippt, erhalten wir einen Fehler:\n",
+ "\n",
+ "```\n",
+ "ValueError: invalid literal for int() with base 10: 'Eine afrikanische oder eine europäische Schwalbe?'\n",
+ "```\n",
+ "\n",
+ "Wir werden später sehen, wie wir diese Art von Fehler behandeln können."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### 4.12 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,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x = 5\n",
+ " y = 6"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "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,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "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",
+ "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",
+ "metadata": {},
+ "source": [
+ "### 5.13 Glossar\n",
+ "\n",
+ "Legen wir uns eine Liste mit den wichtigsten Begriffen an, die wir im Kapitel 5 gelernt haben:\n",
+ "- Ganzzahldivision:\n",
+ "- 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",
+ "- Verzweigung:\n",
+ "- Bedingung:\n",
+ "- Verbundanweisung:\n",
+ "- Zweig:\n",
+ "- verkettete Verzweigung:\n",
+ "- verschachtelte Verzweigung:\n",
+ "- `return`-Anweisung\n",
+ "- Rekursion:\n",
+ "- Basisfall:\n",
+ "- unendliche Rekursion:\n",
+ "\n",
+ "Ergänzen Sie die Liste in eigenen Worten. Das ist eine gute Erinnerungs- und Übungsmöglichkeit."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### 5.14 Ãœbung\n",
+ "\n",
+ "#### 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,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import time\n",
+ "time.time()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "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:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import time\n",
+ "\n",
+ "def print_time():\n",
+ " # Implementieren Sie hier die Funktion\n",
+ " \n",
+ "# Testaufruf\n",
+ "print_time()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### Aufgabe 2\n",
+ "\n",
+ "[Fermats letzter Satz](https://de.wikipedia.org/wiki/Fermazs_letzter_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",
+ "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. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Implementieren und testen Sie hier die beiden Funktionen"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "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 aber 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",
+ "2. Schreiben Sie eine Funktion die die Nutzerin 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."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Implementieren und testen Sie hier die beiden Funktionen"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### Aufgabe 4\n",
+ "\n",
+ "Was gibt das folgende Programm aus? Zeichnen Sie ein Stapeldiagramm, das den Zustand des Programms ausgibt, wenn `recurse(3, 0)` aufgerufen wird: "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "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",
+ "metadata": {},
+ "source": [
+ "1. Was würde passieren, wenn wir diese Funktion so aufrufen würden: `recurse(-1, 0)`?\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": "markdown",
+ "metadata": {},
+ "source": [
+ "Die folgenden Aufgaben nutzen das `turtle`-Modul welches in [Kapitel 4](seminar04.ipynb) beschrieben wurde.\n",
+ "\n",
+ "#### Aufgabe 5\n",
+ "Lesen Sie sich die folgende Funktion durch und versuchen Sie herauszufinden, was sie tut (schauen Sie sich auch die Beispiele in Kapitel 4 an). Rufen Sie erst dann die Funktion auf und schauen Sie, ob Sie richtig liegen."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def draw(t, length, n):\n",
+ " if n == 0:\n",
+ " return\n",
+ " angle = 50\n",
+ " t.fd(length*n)\n",
+ " t.lt(angle)\n",
+ " draw(t, length, n-1)\n",
+ " t.rt(2*angle)\n",
+ " draw(t, length, n-1)\n",
+ " t.lt(angle)\n",
+ " t.bk(length*n)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### Aufgabe 6\n",
+ "\n",
+ "Die [Kochkurve](https://de.wikipedia.org/wiki/Kochkurve) ist ein [Fraktal](https://de.wikipedia.org/wiki/Fraktal), welches ungefähr so aussieht:\n",
+ "\n",
+ "\n",
+ "\n",
+ "Um eine Kochkurve der Länge x zu zeichnen, müssen wir nur folgendes tun:\n",
+ "\n",
+ "1. Eine Kochkurve der Länge x/3 zeichnen.\n",
+ "2. Um 60° nach links drehen.\n",
+ "3. Eine Kochkurve der Länge x/3 zeichnen.\n",
+ "2. Um 120° nach rechts drehen.\n",
+ "3. Eine Kochkurve der Länge x/3 zeichnen.\n",
+ "2. Um 60° nach links drehen.\n",
+ "3. Eine Kochkurve 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 Kochkurve der gegebenen Länge zu zeichnen.\n",
+ "2. Schreiben Sie eine Funktion `schneeflocke`, die drei Kochkurven zeichnet, so dass sich der Umriss einer Schneeflocke ergibt.\n",
+ "\n",
+ " Lösung: http://thinkpython2.com/code/koch.py\n",
+ "3. Die Kochkurve kann auf verschiedene Art und Wiese verallgemeinert werden. Schauen Sie sich die Beispiele auf http://en.wikipedia.org/wiki/Koch_snowflake an und implementieren Sie ihren Favoriten."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ " Speichern Sie dieses Notebook, so dass Ihre Änderungen nicht verlorengehen (nicht auf einem Pool-Rechner). Klicken Sie dazu oben links auf das Disketten-Icon und nutzen Sie beispielsweise einen USB-Stick, E-Mail, Google Drive, Dropbox oder Ihre [HU-Box](https://box.hu-berlin.de/). "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "\n",
+ "Herzlichen Glückwunsch! Sie haben das 4. Kapitel geschafft. Weiter geht es in [5: Bedingungen und Rekursion](seminar05.ipynb)."
+ ]
+ }
+ ],
+ "metadata": {
+ "language_info": {
+ "name": "python",
+ "pygments_lexer": "ipython3"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
--
GitLab