seminar02.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Seminar Problemorientierte Programmierung\n",
    "\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",
    "- \n",
    "- \n",
    "- \n",
    "\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."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "                                                                            \n",
    "query = \"Experiment\"\n",
    "\n",
    "# Suche nach query in s; falls gefunden: Fundstelle + hervorgehobene Anfrage zurückgeben\n",
    "def search(s, query, context = 20):\n",
    "    i = s.find(query)\n",
    "    if i >= 0:\n",
    "        return s[max(0, i-context):i] + \"*\" + s[i:i + len(query)] + \"*\" + s[i + len(query):min(len(s), i+context)]\n",
    "    return None\n",
    "\n",
    "print(\"Suche nach '\" + query + \"':\")\n",
    "# alle Python-Notebooks im aktuellen Verzeichnis durchsuchen\n",
    "for entry in os.listdir():\n",
    "    if entry.endswith(\".ipynb\"):\n",
    "        with open(entry, \"rt\") as f:\n",
    "            for line in f:\n",
    "                result = search(line, query)\n",
    "                if result:\n",
    "                    print(entry + \":\", result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2: Variablen, Ausdrücke und Anweisungen\n",
    "\n",
    "Weiter geht es in [Kapitel 2](http://greenteapress.com/thinkpython2/html/thinkpython2003.html).\n",
    "\n",
    "Eine der mächtigsten Fähigkeiten von Programmiersprachen ist, **Variablen** zu verändern. Variablen sind Namen, die auf einen Wert verweisen. \n",
    "\n",
    "### Zuweisung\n",
    "\n",
    "Die **Zuweisung** ist eine besondere Form der Anweisung. Sie erzeugt eine neue Variable (falls Sie nicht schon existierte) und gibt ihr einen Wert:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nachricht = \"Das ist ein ganz einfacher Mechanismus.\"\n",
    "n = 17\n",
    "pi = 3.141592653589793"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In diesem Beispiel sehen wir drei Zuweisungen:\n",
    "1. die erste weist die Zeichenkette `\"Das ist ein ganz einfacher Mechanismus.\"` einer Variable mit dem Namen `nachricht` zu\n",
    "2. die zweite weist die Zahl `17` der Variablen `n` zu und\n",
    "3. die dritte weist (einen Näherungswert für) Pi der Variablen `pi` zu.\n",
    "\n",
    "Legen Sie selbst ein paar Variablen an und weisen Sie Ihnen Werte zu:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### (Variablen)Namen\n",
    "\n",
    "Variablen (und auch Funktionen) benötigen Namen. Als Programmierer/in sollten wir Namen wählen, die aussagekräftig sind und dokumentieren, wofür die Variable (oder Funktion) verwendet wird. Folgende Regeln gelten: Variablennamen\n",
    "- dürfen beliebig lang sein"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "diesistabereinelangevariableundtrotzdemmeckertpythonnicht = 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- dürfen Zahlen (0-9), Buchstaben (A-Z, a-z) und Unterstrich (`_`) enthalten"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "so_ist_es_besser_lesbar = \"richtig\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- aber nicht mit einer Zahl beginnen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "0das_gibt_Aerger = 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Der Name `0das_gibt_Aerger` ist nicht erlaubt, weil er mit einer Zahl beginnt. Probieren wir ein paar andere Namen aus (führen Sie den Code aus, um die Fehlermeldungen zu sehen):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mehr@ = 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class = 'Advanced Theoretical Zymurgy'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Erklärungen:\n",
    "- Der Name `mehr@` ist nicht erlaubt, weil das Zeichen `@` nicht zu den Zeichen gehört, aus denen ein Name bestehen darf.\n",
    "- Der Name `class` ist anders, denn er enthält nur erlaubte Zeichen. Warum gibt es dennoch einen Fehler? Der Grund ist, dass `class` ein sogenanntes **Schlüsselwort** ist. Schlüsselwörter helfen Python, die Struktur eines Programms zu erkennen und dürfen daher nicht als Namen für Variablen (und Funktionen) verwendet werden. In Python 3 gibt es die folgenden Schlüsselwörter: `False None True and as assert break class continue def del elif else except finally for from global if import in is lambda nonlocal not or pass raise return try while with yield`. Sie brauchen sich die Liste nicht zu merken. In den meisten Entwicklungsumgebungen (Programmen zum Bearbeiten von Quellcode - wie z.B. Jupyter) werden diese Wörter farblich hervorgehoben und Sie werden somit gewarnt, falls Sie eines dieser Wörter als Variablennamen verwenden wollen."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ausdrücke und Anweisungen\n",
    "\n",
    "Ein **Ausdruck** ist eine Kombination von Werten, Variablen und Operatoren. Wir haben Ausdrücke bereits kennengelernt: In der Anweisung"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(1 + 2 + 3 + 4 + 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "weiter oben gibt die `print`-Funktion den Wert des Ausdrucks `1 + 2 + 3 + 4 + 5` aus. In diesem Beispiel ist der Ausdruck `1 + 2 + 3 + 4 + 5` eine Kombination von Werten (1, 2, 3, 4, und 5) und dem Operator `+`. \n",
    "\n",
    "Jeder Wert ist selbst ein Ausdruck und auch jede Variable ist ein Ausdruck. Das folgende sind also alles Ausdrücke: \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "42"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n + 25\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wenn wir einen Ausdruck am Ende einer Code-Box in Jupyter eingeben, dann wird der Ausdruck **ausgewertet** (also dessen Wert berechnet) und das Ergebnis ausgegeben. Allerdings passiert sonst nicht viel - der Wert wird nicht gespeichert und kann so nicht weiterverwendet werden. Wir können aber beispielsweise mit einer Zuweisung (wie oben gesehen) den Wert eines Ausdrucks einer Variablen zuweisen.\n",
    "\n",
    "**Anweisungen** haben wir in Kapitel 1 schon kennengelernt (als die Bausteine eines Programms). Anweisungen sind Codestücke, die eine Auswirkung haben - also z.B. einer Variablen einen Wert zuweisen oder ein Ergebnis anzeigen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = 17\n",
    "print(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Die erste Zeile ist eine Zuweisung, die der Variablen `n` einen Wert zuweist. Die zweite Zeile ruft die Funktion `print` auf, um den Wert von `n` auszugeben.\n",
    "\n",
    "Wenn wir eine Anweisung starten (mit \"Run Cell\" aus dem \"Cell\"-Menü, oder `STRG-ENTER`), dann wird die Anweisung **ausgeführt**, d.h., der Python-Interpreter tut, was immer die Anweisung verlangt. \n",
    "\n",
    "Schreiben Sie eine Folge von drei Anweisungen:\n",
    "1. Weisen Sie einer Variable `radius` den Wert 3 zu.\n",
    "2. Weisen Sie einer Variable `umfang` den (Wert des) Ausdrucks zu, der den Umfang eines Kreises mit dem Radius `radius` berechnet\n",
    "3. Geben Sie den Wert der Variablen `umfang` mit der Funktion `print` aus."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Prüfen Sie ihr Ergebnis - ist alles korrekt? Notieren Sie hier kurz, welche Schwierigkeiten Ihnen begegnet sind:\n",
    "- \n",
    "- \n",
    "- \n",
    "\n",
    "### Reihenfolge von Operatoren\n",
    "\n",
    "Enthält ein Ausdruck mehrere Operatoren, so werden diese in der folgenden Reihenfolge ausgewertet:\n",
    "- Zuerst werden Klammern ausgewertet (wie in der Mathematik dürfen wir Klammern verwenden, um die Reihenfolge bei der Berechnung festzulegen):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    " 2 * (3-1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "   ist also 4 und"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    " (1+1)**(5-2) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "   ist 8\n",
    "- Exponentiation hat die nächsthöhere Priorität, daher ergibt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1 + 2**3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "9 (und nicht 27) und "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2 * 3**2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "   ergibt 18 (und nicht 36). \n",
    "\n",
    "- Multiplikation und Division haben eine höhere Priorität als Addition und Subtraktion. Daher ergibt "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2*3-1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5 und nicht 4 und "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "6+4/2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ergibt 8 und nicht 5. \n",
    "\n",
    "- Operatoren mit der gleichen Priorität werden von links nach rechts ausgewertet (ausser Exponentiation). Im Ausdruck `degrees / 2 * pi` wird also zuerst dividiert und dann wird mit `pi` multipliziert. Um stattdessen durch `pi` zu dividieren, können wir Klammern verwenden oder stattdessen `degrees / 2 / pi` schreiben.\n",
    "\n",
    "Wir müssen uns die Reihenfolge nicht merken. Wenn wir uns nicht sicher sind, verwenden wir einfach Klammern, um die Reihenfolge festzulegen. \n",
    "\n",
    "Ändern Sie den folgenden Ausdruck so ab, dass zuerst 2 und 3.141 addiert werden und das Ergebnis mit 4 multipliziert wird:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2 + 3.141 * 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Die Ausgabe sollte dann 20.564 statt 14.564 betragen.\n",
    "\n",
    "### Operatoren für Zeichenketten\n",
    "\n",
    "Im allgemeinen können wir mathematische Operatoren nicht für Zeichenketten verwenden, auch wenn die Zeichenketten wie Zahlen aussehen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'2' - '1'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'acht' / 'zwei'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es gibt aber zwei Ausnahmen: `+` und `*`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = \"Donau\"\n",
    "b = \"dampf\"\n",
    "c = \"schiff\"\n",
    "a + b + c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mit dem Operator `+` können wir Zeichenketten verknüpfen (oder verketten). D.h., die beiden Zeichenketten werden hinereinander geschrieben. \n",
    "\n",
    "Mit dem Operator `*` können wir eine Zeichkette wiederholen: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c * 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dabei muss einer der beiden Werte eine Zeichenkette sein und der andere eine ganze Zahl. Probieren Sie aus, ob die Reihenfolge von Zeichenkette und Zahl egal ist:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Die beiden Operatoren funktionieren ähnlich wie bei Zahlen: So wie `4*3` gleich `4+4+4` ist, ist `dampf*3` gleich `dampfdampfdampf`. Allerdings gibt es einen wichtigen Unterschied: Welche Eigenschaft erfüllt die Addition bei Zahlen, die die Verknüpfung von Zeichenketten nicht erfüllt?\n",
    "- \n",
    "\n",
    "### Kommentare \n",
    "\n",
    "Sobald Programme größer und komplexer werden, wird es schwer, sie zu verstehen. Die Information, die im Programmcode steckt ist sehr dicht und es fällt oft schwer, nur durch einen Blick auf den Programmcode herauszufinden, was der Code macht und warum. \n",
    "\n",
    "Daher ist es eine gute Idee, Notizen in natürlicher Sprache einzufügen, die erklären, was das Programm macht. Diese Notizen heißen **Kommentare** und sie beginnen mit dem Zeichen `#`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pi = 3.1415926\n",
    "radius = 7\n",
    "# die Fläche eines Kreises berechnen\n",
    "flaeche = 2 * pi * radius**2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wir können Kommentare auch am Ende einer Zeile hinzufügen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "flaeche = 2 * pi * radius**2 # die Fläche eines Kreises berechnen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alles ab `#` bis zum Ende der Zeile wird ignoriert und hat keine Auswirkung auf die Ausführung des Programms.\n",
    "\n",
    "- Kommentare werden in der Entwicklungsumgebung oft farblich hervorgehoben, was zusätzlich die Orientierung erleichtert.\n",
    "- Kommentare sind am hilfreichsten, wenn sie das nicht-Offensichtliche erklären\n",
    "- Wir können davon ausgehen, dass der/die Leser/in herausfinden kann, *was* das Programm macht, daher sollten wir eher erklären *warum* das an der Stelle gemacht wird.\n",
    "\n",
    "Der folgende Kommentar ist beispielsweise redundant und daher nutzlos:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v = 5 # assign 5 to v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dieser Kommentar dagegen enthält nützliche Information, die sich nicht im Quellcode befindet:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v = 5 # Geschwindigkeit in Meter pro Sekunde"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Übrigens können wir uns mit aussagekräftigen Variablennamen auch Kommentare sparen. (Andererseits werden Ausdrücke durch sehr lange Namen auch schwerer lesbar ... wir müssen also einen guten Mittelweg finden.) \n",
    "\n",
    "Finden Sie heraus, was das folgende Programm tut und fügen Sie aussagekräftige Kommentare hinzu:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "x1 = 5\n",
    "y1 = 4\n",
    "x2 = 1\n",
    "y2 = 1\n",
    "\n",
    "distance_h = x1 - x2\n",
    "distance_v = y1 - y2\n",
    "\n",
    "distance = math.sqrt(distance_h**2 + distance_v**2)\n",
    "\n",
    "print(\"distance((x1, y1), (x2, y2)) = \", distance)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Exkurs: Wieviele Kommentare in einem Programm gut und notwendig sind, ist durchaus umstritten. Wenn Sie mögen, können Sie einen Ausschnitt des Diskurses dazu hier verfolgen:\n",
    "- \"Good code is its own best documentation.\" ([Steve McConnell](http://en.wikipedia.org/wiki/Steve_McConnell))\n",
    "- http://mikegrouchy.com/blog/2013/03/yes-your-code-does-need-comments.html\n",
    "- https://stackoverflow.com/questions/184618/what-is-the-best-comment-in-source-code-you-have-ever-encountered"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Debugging\n",
    "\n",
    "Programme können drei Arten von Fehlern enthalten:\n",
    "\n",
    "- Syntax-Fehler (\"syntax error\")\n",
    "- Laufzeit-Fehler (\"runtime error\")\n",
    "- Semantische Fehler\n",
    "\n",
    "Lesen Sie mehr zu den Unterschieden in [Abschnitt 2.8](http://greenteapress.com/thinkpython2/html/thinkpython2003.html#sec23)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Glossar\n",
    "\n",
    "Legen wir uns eine Liste mit den wichtigsten Begriffen an, die wir im Kapitel 2 gelernt haben:\n",
    "- Variable:\n",
    "- Zuweisung:\n",
    "- Schlüsselwort:\n",
    "- Ausdruck:\n",
    "- Zeichenketten verknüpfen:\n",
    "- Kommentar:\n",
    "- Syntaxfehler:\n",
    "- Laufzeitfehler:\n",
    "- semantischer Fehler:\n",
    "\n",
    "Ergänzen Sie die Liste in eigenen Worten. Das ist eine gute Erinnerungs- und Übungsmöglichkeit.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Übung\n",
    "\n",
    "#### Aufgabe 1\n",
    "\n",
    "Wenn wir etwas neues lernen, sollten wir es immer gleich ausprobieren. Wir sollten auch versuchen, absichtlich ein paar Fehler einzubauen, um zu schauen, was dann passiert. \n",
    "\n",
    "- Wir haben gesehen, dass `n = 42` erlaubt ist. Was ist mit `42 = n`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Und wie schaut es mit `x = y = 1` aus? (Lassen Sie sich danach die Werte für `x` und `y` mit Hilfe der `print`-Funktion ausgeben.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- In einigen Programmiersprachen müssen Anweisungen mit einem Semikolon (;) beendet werden. Was passiert, falls wir in Python ein Semikolon ans Ende einer Anweisung schreiben?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Und was passiert, wenn wir einen Punkt (.) ans Ende einer Anweisung schreiben?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Aufgabe 2\n",
    "\n",
    "Nutzen Sie Python als Taschenrechner:\n",
    "- Das Volumen einer Kugel mit dem Radius r ist 4/3 π r³. Wie groß ist das Volumen einer Kugel mit dem Radius 5?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Geben Sie hier Ihren Ausdruck zur Berechnung ein"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Angenommen, der Preis des Buches \"Once upon an Algorithm\" ist 29,99€, aber wir bekommen es mit 40% Rabatt, weil wir eine Bildungseinrichtung sind. Der Versand kostet 3€ für das erste Buch und 0,75€ für jedes weitere Buch. Wir wollen 60 Exemplare für das IBI bestellen - was kostet uns das insgesamt?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Geben Sie hier Ihren Ausdruck zur Berechnung ein"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(Ergebniskontrolle: Die gesamte Bestellung würde 1126,89€ kosten.)\n",
    "\n",
    "- Wenn ich mein Haus um 6:52 Uhr verlasse und 1 Meile gemütlich laufe (8:15 Minuten pro Meile), dann 3 Meilen schneller (7:12 Minuten pro Meile) und dann nochmal 1 Meile gemütlich, wann komme ich dann zum Frühstück an?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Geben Sie hier Ihren Ausdruck zur Berechnung ein"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(Ankunft ist 7:30 Uhr und 6 Sekunden.) \n",
    "\n",
    "![Speichern](https://amor.cms.hu-berlin.de/~jaeschkr/teaching/spp/floppy.png) Speichern Sie dieses Notebook, so dass Ihre Änderungen nicht verlorengehen (nicht auf einem Pool-Rechner). Rufen Sie dazu im Menü \"File\" den Punkt \"Download as\"->\"Notebook\" auf und nutzen Sie beispielsweise einen USB-Stick, E-Mail, Google Drive, Dropbox oder Ihre [HU-Box](https://box.hu-berlin.de/).  \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Smiley](https://upload.wikimedia.org/wikipedia/commons/thumb/b/bc/Face-grin.svg/240px-Face-grin.svg.png)\n",
    "\n",
    "Herzlichen Glückwunsch! Sie haben das 2. Kapitel geschafft. Weiter geht es in [3: Funktionen](seminar03.ipynb)."
   ]
  }
 ],
 "metadata": {
  "language_info": {
   "name": "python",
   "pygments_lexer": "ipython3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}