notebook-Ianni's instanz.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Jupyter Notebook\n",
    "Dieses Notebook ist in Zellen organisiert, es gibt Textzellen wie diese  \n",
    "und es gibt Codezellen in denen ihr Pythoncode schreiben und ausführen könnt.  \n",
    "Dabei entscheidet ihr über die Reihenfolge in der die Zellen ausgeführt werden, das kann zu Fehlern führen!!!  \n",
    "Um eine Zelle auszuführen klickt ihr entweder Cell -> Run Cell  \n",
    "oder ihr nutzt den Shortcut: `Shift` + `Enter`  \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Konzept\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Eine Zeile eines Python-Programmes heißt Anweisung.  \n",
    "Diese werden von oben nach unten ausgeführt.  \n",
    "\n",
    "Kommentare beginnen mit \\# und werden von Python ignoriert.  \n",
    "Mit print(\"&lt;Text&gt;\") kann ein beliebiger &lt;Text&gt; ausgegeben werden (dazu später noch mehr)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Beispiel Code von Emil\n",
    "print(\"Hallo liebe Teilnehmenden\")\n",
    "\n",
    "print(\"Hier könnte Ihre Werbung stehen\") # Ein weiterer Kommentar\n",
    "\n",
    "\"Ein weiterer Test\" # In dieser Online-Umgebung werden auch alleinstehende Werte ausgegebenen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Variablen und Werte\n",
    "Wir benutzen Variablen um Werte abzuspeichern. Die generelle Syntax um eine Variable zu erzeugen ist:  \n",
    "`<Name> = <Wert>`  \n",
    "Der Name der Variable spielt dabei keine Rolle, es gibt allerdings ein paar Dinge bei der Wahl des Namens zu beachten:  \n",
    "- Keine Leerzeichen\n",
    "- Muss mit Buchstaben anfangen\n",
    "- Keine Umlaute  \n",
    "Beispiele:  \n",
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 42\n",
    "y = 1337  \n",
    "name = \"lebowski\"\n",
    "zahl = \"definitv keine Zahl\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mit den Werten verhält es sich etwas komplizierter:  \n",
    "Da relativ offen ist, was ein Wert ist, kategorisiert man Werte nach Datentypen.  \n",
    "Folgende Datentypen und ihre Darstellung in Python sollte man auf jeden Fall kennen:\n",
    "- Integer, Ganzzahlen z.B. `42`\n",
    "- Float, Dezimalzahlen z.B. `4.2` (ACHTUNG, \".\" statt \",\")\n",
    "- String, Zeichenketten z.B. \"Hallo\" oder \"Welt\"\n",
    "- Boolean, Wahrheitswerte z.B. `True` oder `False` (genau genommen sind das alle... alle beide)  \n",
    "Das sind fast alles sehr simple und grundlegende Datentypen.  \n",
    "Es gibt aber auch kompliziertere, z.b. Listen.  \n",
    "Die Sytax von Listen ist: `[<Wert 1>, <Wert 2>, <Wert 3>, ...]`  \n",
    "Beispiele:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "eineZahl = 1\n",
    "eineDezimalzahl = 1.1\n",
    "die_erde_ist_flach = False \n",
    "wasser_ist_nass = True\n",
    "liste_von_zahlen = [23, 723, 23, 62, 23]\n",
    "liste_von_buchstaben = ['a', 'b', 'c', 'ß']\n",
    "liste_von_allem = [1, 'a', 3.2, True, [2, 3, False], \"the end\"]\n",
    "fib = [1, 1, 2, 3, 5, 8, 13, 21]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Operatoren\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Verknüpfen mehrere (meist zwei) Ausdrücke (Operanden, meist links/rechts vom Operator) zu einem einzelnen Ausdruck"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\"+\" berechnet die Summe zweier Zahlen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "5 + 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "+, -, * (mal) und / (geteilt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5 + 3 / 2 - 1 * 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Die Ausführungsreihenfolge kann mit runden Klammern verändert werden"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(5 + 3) / (2 - 1) * 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Operatoren können auch mit Variablen verwendet werden"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "part_of_x = x / 5\n",
    "print(part_of_x + 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Auch für andere Datentypen sind manche dieser Operatoren sinnvoll definiert!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name + \" earth\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "liste_von_zahlen + [42,45]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[1, 2] * 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Neben den arithmetischen Operatoren gibt es auch die boolschen Operatoren"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(not die_erde_ist_flach) and wasser_ist_nass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "True or False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "False or False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Und die Vergleichsoperatoren"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 1\n",
    "y = 1\n",
    "z = 2\n",
    "print(x == y)\n",
    "print(y != z)\n",
    "print(x > z)\n",
    "print(z <= z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Auch der Zugriff auf Listenelemente ist ein Operator! (Verknüpft Liste und Index (Position) zum ensprechenden Wert in der Liste)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "liste_von_zahlen[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Anweisungen der Form x = x + y können auch abgekürzt werden"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 3\n",
    "x *= 2\n",
    "x -= 1\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Verzweigungen\n",
    "Wir verwenden Verzweigungen um Entscheidungen zu treffen.  \n",
    "Die Syntax ist:  \n",
    "<code>if (Bedingung):  \n",
    "    (Codeblock 1)  \n",
    " else:  \n",
    "    (Codeblock 2)</code>  \n",
    "(Bedingung) muss ein Wahrheitswert (True oder False) sein,  \n",
    "und die Codeblöcke sind beliebige Zeilen Code.  \n",
    "Beispiel:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 10\n",
    "if x > 10:\n",
    "    print(\"x ist größer als 10\")\n",
    "else:\n",
    "    print(\"x ist kleiner gleich 10\")\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if x % 2 == 0:\n",
    "    print(\"x ist eine gerade Zahl\")\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wenn wir nun mehr als eine Bedingung überprüfen wollen:  \n",
    "<code>if (Bedingung 1):\n",
    "    (Block 1)\n",
    "elif (Bedingung 2):\n",
    "    (Block 2)\n",
    "...\n",
    "elif (Bedingung n):\n",
    "    (Block 2)\n",
    "else: \n",
    "    (Default Block)\n",
    "</code>  \n",
    "Wenn eine der Bedingungen zutrifft wird der entsprechende Codeblock ausgeführt und  \n",
    "ans Ende der Verzweigung gesprungen. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "state = input(\"Wie geht es dir? \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "resonse = None\n",
    "if state == \"sehr gut\":\n",
    "    response = \"Schön für dich.\"\n",
    "elif state == \"gut\":\n",
    "    response = \"okay\"\n",
    "elif state == \"mässig\":\n",
    "    response = \"Trink mal einen Tee, das kann Wunder bewirken :)\"\n",
    "elif state == \"schlecht\":\n",
    "    response = \"uff\"\n",
    "else:\n",
    "    response = \"Bitte?\"\n",
    "print(response)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Damit kann man auch komplizierte Zusammenhänge auf Eigenschaften überprüfen und entsprechend behandeln.  \n",
    "Zum Beispiel, ob ein Punkt innerhalb einer Box liegt:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "box_center = (3,3)\n",
    "box_width = 6\n",
    "box_height = 4\n",
    "point = (1,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "in_box = False\n",
    "if point[0] >= box_center[0] - box_width / 2 and point[0] <= box_center[0] + box_width / 2:\n",
    "    if point[1] >= box_center[1] - box_height / 2 and point[1] <= box_center[1] + box_height / 2:\n",
    "        in_box = True\n",
    "print(\"It is {} that the point is in the box\".format(in_box))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Schleifen\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Schleifen führen einen bestimmten (eingerückten) Programmabschnitt für jedes Element einer Liste aus."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "zahlen = [1, 2, 3]\n",
    "for zahl in zahlen:\n",
    "    print(zahl)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hauptsächlich zwei Verwendungen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "zahlen = [1, 2, 3]\n",
    "doppelt = []\n",
    "for zahl in zahlen:\n",
    "    doppelt += [zahl * 2]\n",
    "print(doppelt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "zahlen = [1, 2, 3]\n",
    "summe = 0\n",
    "for zahl in zahlen:\n",
    "    summe += zahl\n",
    "print(summe)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Schleifen können auch mit anderen Datentypen benutzt werden"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "buchstaben = [\"a\", \"b\", \"c\"]\n",
    "for buchstabe in buchstaben:\n",
    "    print(buchstabe)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wenn es nur wichtig ist eine Schleife n-mal zu wiederholen gibt es auch dafür einen Trick"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(10): # 0, 1, 2, ..., 9 (0-basiert (für Verwendung mit Listen))\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Aufgabe 1: Spaß mit Schleifen\n",
    "Die folgenden Aufgaben sollen mit for-Schleifen gelöst werden.  \n",
    "Die Lösungen der einzelnen Teilaufgaben sollen dann in solution1a, solution1b... gespeichert werden.  \n",
    "In der Zelle unter der zu erstellenden Zelle werden diese Lösungen dann überprüft."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from random import randint\n",
    "solution1a = None\n",
    "solution1b = None\n",
    "solution1c = None\n",
    "lst = [randint(0,10000000) for i in range(100)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " - a) Summiert alle Zahlen von 1 bis 1000 auf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Korrekt!\" if solution1a == sum(list(range(1001))) else \"Leider Falsch ;(\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- b) Gegeben ist die Liste: \"lst\" mit 100 Einträgen, die Aufgabe ist es das Maximum dieser Liste zu bestimmen  \n",
    "Auf den i-ten Eintrag kann so zugegriffen werden: `lst[i]`  \n",
    "Beachte, dass bei 0 angefangen wird zu zählen: `erste_element = lst[0]`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Korrekt!\" if solution1c == max(lst) else \"Leider Falsch ;(\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- c) Gib die ersten n Fibonaccizahlen aus.  \n",
    "fib(0) = 1  \n",
    "fib(1) = 1  \n",
    "fib(n) = fib(n-1) + fib(n-2)  \n",
    "also:\n",
    "1, 1, 2, 3, 5, 8, 13, ...  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Aufgabe 2: Lonely Island\n",
    "In dieser Aufgabe ist eine Liste von Tupeln (Paaren) gegeben, die Punkte auf einer Ebene darstellen:  \n",
    "z.B. `points = [(0, 0), (3, 2), (5, 2)]`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from random import randint\n",
    "from math import sqrt\n",
    "import matplotlib.pyplot as plt\n",
    "n = 100\n",
    "points = [(randint(0,100), randint(0,100)) for x in range(n)]\n",
    "plt.scatter(*zip(*points))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Die Aufgabe ist es den Punkt zu finden, der am weitesten von den anderen entfernt ist.  \n",
    "Als Hilfestellung geben wir euch eine Hilfsfunktion, die die Distanz zwischen zwei Punkten bestimmt:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def distance(a, b):\n",
    "    return sqrt((b[0] - a[0])**2 + (b[1] - a[1])**2)\n",
    "print(distance((0, 0), (1,1)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Diese Hilfsfunktion kann man wie folgt benutzen:  \n",
    "Angenommen wir haben zwei Punkte: `a = (1 , 23)`, `b = (3, 5)`   \n",
    "Dann errechnet dist die Distanz: `dist = distance(a, b)`  \n",
    "Speichere deine Lösung in der Variable `lonely_island` ab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.scatter(*zip(*points))\n",
    "plt.scatter(*lonely_island, color = \"r\")\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}