Python-Intro/Python-Syntax.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Syntax"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. Grundlagen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Grundrechenarten und Regeln"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n",
      "1\n",
      "20\n",
      "1.25\n",
      "625\n",
      "1\n",
      "1\n",
      "27\n"
     ]
    }
   ],
   "source": [
    "print(5 + 4) # Addition\n",
    "print(5 - 4) # Subtraktion\n",
    "print(5 * 4) # Multiplikation\n",
    "print(5 / 4) # Division\n",
    "print(5 ** 4)# Exponent\n",
    "print(5 % 4) # Modulus/Remaider\n",
    "print(5 // 4)# Integer division\n",
    "print((5 + 4) *3) #Punkt vor Strich"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Datentypen\n",
    "### Zahlen\n",
    "Bei Zahlen wird zwischen Integers (ganzen Zahlen) und Floating-pint Numbers (Kommazahlen) oder kurz Floats unterschieden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "1.5\n"
     ]
    }
   ],
   "source": [
    "print(1) # Zahlen können ohne Markup eingefügt werden\n",
    "print(1.5) # Kommata werden anstatt mit ',' mit einem '.' geschrieben"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Strings (Zeichenketten)\n",
    "Zeichen die zwischen Anführungszeichen stehen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hallo Welt\n",
      "Alex\n"
     ]
    }
   ],
   "source": [
    "print(\"Hallo Welt\") #Einfacher String in Anführungszeichen\n",
    "name =\"Alex\"  # Strings können in Variablen gespeichert werden\n",
    "print(name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Strings zusammenführen\n",
    "Mehrere Strings können durch **+** oder **Leerzeichen** zusammengefügt werden"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mein Name ist Alex. Wie ist dein Name?\n",
      "Mein Name ist Alex. Wie ist dein Name?\n"
     ]
    }
   ],
   "source": [
    "print(\"Mein Name ist Alex. \" + \"Wie ist dein Name?\")\n",
    "print(\"Mein Name ist Alex. \"  \"Wie ist dein Name?\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Strings replizieren\n",
    "Strings können einfach repliziert werden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AlexAlexAlexAlexAlex\n"
     ]
    }
   ],
   "source": [
    "print(\"Alex\" * 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Strings kürzen\n",
    "Strings können über **[Zahl:Zahl]** gekürzt werden. Wobei die Zahlen die zu überspringenden Zeichen angeben."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Welt\n"
     ]
    }
   ],
   "source": [
    "print(\"Hallo Welt!\"[6:-1]) #Die ersten 0-6 Zeichen werden übersprungen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Bestimmte Zeichen eines Strings ausgeben\n",
    "Einzelne String-Zeichen können mittel **[Zahl]** ausgegeben werden, wobei Zahl die gesuchte Position ist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "W\n"
     ]
    }
   ],
   "source": [
    "print(\"Hallo Welt\"[6]) # das 7. Zeichen wird ausgegeben"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Groß- und Kleinschreibung\n",
    "Mit der `.upper()`- bzw. `.lower()`-Methode können alle Zeichen in Groß- bzw. Kleinbuchstaben angezeigt werden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "HALLO\n",
      "HALLO\n",
      "hallo\n",
      "hallo\n"
     ]
    }
   ],
   "source": [
    "w = \"Hallo\"\n",
    "print(w.upper())\n",
    "print(\"Hallo\".upper())\n",
    "print(w.lower())\n",
    "print(\"Hallo\".lower())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String Anfang und Ende\n",
    "Mit der `.startswith()`- bzw. `.endswith()`-Methode kann man prüfen, ob ein String mit einem anderen String beginnt/\n",
    "aufhört."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Der Satz endet mit drei Fragezeichen\n",
      "Der Satz beginnt mit einem 'ist'\n"
     ]
    }
   ],
   "source": [
    "sentence = \"Ist das Wetter heute gut???\"\n",
    "\n",
    "if sentence.endswith(\"???\"):\n",
    "    print(\"Der Satz endet mit drei Fragezeichen\")\n",
    "    \n",
    "if sentence.startswith(\"Ist\"):\n",
    "    print(\"Der Satz beginnt mit einem 'ist'\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `.strip()`-Methode\n",
    "Standardmäßig entfernt die `.strip()`-Methode Leerzeichen vom Anfang und vom Ende des Strings:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hallo Welt.'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"   Hallo Welt.    \".strip() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Der `strip()`-Methode können Parameter übergeben werden, welche Zeichen entfernt werden sollen.<br>\n",
    "Die `.lstrip()`- bzw. `.rstrip()`-Methode funktioniert analog der `.strip()`-Methode, wobei aber `.lstrip()` nur die linke Seite und `.rstrip()` nur die rechte Seite betrachtet:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hallo\n",
      "Hallo.__\n",
      "____Hallo.\n"
     ]
    }
   ],
   "source": [
    "word = \"____Hallo.__\"\n",
    "print(word.strip(\"_.\"))\n",
    "print(word.lstrip(\"_\"))\n",
    "print(word.rstrip(\"_\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `.find()`- Methode\n",
    "Mit der `.find()`-Methode kann man herausfinden, an welcher Stelle ein Zeichen in einem String vorkommt.<br>\n",
    "Wenn die `.find()`-Methode die Zahl `-1` zurückgibt, bedeutet dass, dass das Zeichen im String nicht vorkommt:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sentence = \"Ist das Wetter heute, und morgen gut???\"\n",
    "print(sentence.find(\",\"))\n",
    "print(sentence.find(\"!\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Zeichen ersetzen (`.replace()`)\n",
    "Mit der `.replace()`-Methode können Ersetzungen durchgeführt werden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sentence = \"Ist das Wetter heute, und morgen gut???\"\n",
    "\n",
    "print(sentence.replace(\",\", \";\"))\n",
    "print(sentence.replace(\"u\", \"ü\"))\n",
    "print(sentence.replace(\"und\", \"oder\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Strings formatieren\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ich habe 5 Hunde\n"
     ]
    }
   ],
   "source": [
    "n = 5\n",
    "print(\"Ich habe \" + str(n) + \" Hunde\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wie bekommst du es jetzt hin, dass der Sprachbaustein austauschbar ist und nicht mit dem `+ str(n) +`Befehl \"verwoben\" ist?\n",
    "\n",
    "**Idee:** Du könntest die Sprachbausteine in einem Dictionary definieren und einen Platzhalter per `.replace()` einsetzen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "translations = {\n",
    "    \"number_of_dogs\": \"Ich habe XXX Hunde\"\n",
    "}\n",
    "print(translations[\"number_of_dogs\"].replace(\"XXX\", str(n)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Problem:** Das wird aber schnell unübersichtlich. \n",
    "\n",
    "**Lösung:** Glücklicherweise stellt uns Python hier eine `.format()`-Methode zur Verfügung, die das ganze sehr viel einfacher macht. Hierbei verwenden wir `{0}` für die Position, wo wir den Parameter `n` des `.format(n)`-Aufrufs einsetzen möchten:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Ich habe {0} Hunde\".format(n))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Diese `.format()`-Methode funktioniert auch mit mehreren Parametern. Hierbei definiert dann `{0}` die Position für den ersten Parameter, `{1}` die Position, wo der 2. Parameter hin gesetzt werden soll. \n",
    "\n",
    "Hier in folgendem Fall wird also die `{1}` durch `\"Katzen\"` ersetzt, und `{0}` durch die Zahl 5:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Ich habe {1} {0}x\".format(5, \"Katzen\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Kommazahlen und runden\n",
    "\n",
    "Der `format()`-Befehl erlaubt es, Kommazahlen komfortabel zu runden. Hierbei wird an einen Formatierungs-Befehl (das war z. B. `{0}` oder `{1}`) noch innerhalb der geschweiften Klammern ein `f` drangehängt.\n",
    "\n",
    "Dadurch sagen wir Python, dass diese Zahl als Kommazahl betrachtet werden soll. Entsprechend wird hier jetzt die Zahl 5 eingesetzt, die `.000000` werden aber ergänzt, weil es als Kommazahl ausgegeben wird:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"So viele Katzen habe ich: {0:f}\".format(5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wenn wir die Anzahl der Stellen beschränken möchten, können wir das tun, indem wir nach dem Doppelpunkt .2 schreiben, um z. B. die Kommazahl auf 2 Nachkommastellen zu limitieren:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"So viele Katzen habe ich: {0:.2f}\".format(5))\n",
    "print(\"Pi hat den Wert: {0:.3f}\".format(3.141529))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Parameter bennennen\n",
    "\n",
    "Wenn du einen String hast, in dem viele Platzhalter eingesetzt werden, wird die Schreibweise `{0}`, `{1}`, `{2}`, `{3}`, `{4}`, `{5}`, ... irgendwann unübersichtlich.\n",
    "\n",
    "Glücklicherweise können wir die Parameter auch benennen. Hierbei ist wichtig, dass, wenn auf der linken Seiten ein Parameter z. B. `{animal}` heißt, der Parameter `animal` dann entsprechend auch der `.format()`-Funktion übergeben wird. \n",
    "\n",
    "Hier in dem Fall ist es also so, dass an die Stelle, an der `{animal}` steht, der Wert vom `.format()`-Aufruf `animal = \"Hunde\"` (konkret das Wort \"Hunde\") eingesetzt wird: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Ich habe {number:.3f} {animal}\".format(number = 5, animal = \"Hunde\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Boolean\n",
    "Für Wahr oder Falsch werden die Booleans **True** und **False** ausgegeben"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "b = False\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variablen\n",
    "Variablen können benutzt werden, um Werte zuzuweisen und später einfach aufzurufen.<br>\n",
    "Für Variablen gelten drei Regeln:\n",
    " - nur ein Wort\n",
    " - nur Buchstaben, Zahlen und der Underscore (_)\n",
    " - darf nicht mit einer Zahl beginnen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "11\n",
      "16\n"
     ]
    }
   ],
   "source": [
    "a = 5         # Einfache Variable\n",
    "print(a)\n",
    "b = 5 + 6     # Zahlen können in Variablen verrechnet werden\n",
    "print(b)\n",
    "print(a + b)  # Variablen können verrechnet werden"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Kommentare\n",
    "Kommentare im Code erleichtern die Lesbarkeit und werden nicht ausgeführt. Dafür nutzt man **#**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Welt\n"
     ]
    }
   ],
   "source": [
    "# Dies ist ein Kommentar\n",
    "# print(\"Hallo Welt\")  Diese Zeile wird nicht ausgeführt\n",
    "print(\"Hello Welt\")  # Diese Zeile wird ausgeführt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Grundfunktionen\n",
    "Python liefert einige Grundfunktionen.\n",
    "### Print() - Funktion\n",
    "Mit der **print()**-Funktion können Ausgaben über die Konsole getätigt werden. Die erforderliche Ausgabe wird in den Klammern **()** getätigt. Für Funktionen die in dieser Klammer ausgeführt werden, wird nur das Ergebnis ausgegeben."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dies ist ein String\n",
      "1\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "print(\"dies ist ein String\")\n",
    "print(1) # eine Zahl\n",
    "print(1 + 2) # eine Rechnung in der Print()-Funktion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### input Function\n",
    "Mithilfe der **input()** Funktion können Eingaben über die Konsole an das Programm übergeben werden. Die Eingabe kann in einer Variable gespeichert werden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wie ist dein Name? Alex\n",
      "Hallo Alex\n"
     ]
    }
   ],
   "source": [
    "myName = input(\"Wie ist dein Name? \") # eine Zeile mit Eingabe wird geöffnet, der String wird davor ausgegeben\n",
    "print('Hallo {}'.format(myName))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### len Function\n",
    "Berechnet die Länge eines Strings als Integer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len('hello')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Strings aus einer Liste zu einem String zusammenfügen\n",
    "**join()**-Befehl auf einen String: **string.join(liste)**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Alex, Bob, Cedric, Erika\n"
     ]
    }
   ],
   "source": [
    "students = [\"Alex\", \"Bob\", \"Cedric\", \"Erika\"]\n",
    "print(\", \".join(students))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. Datenstrukturen\n",
    "\n",
    "- Listen: Geordnete Auflistung von Elementen. Bsp: `liste = [\"Hallo\", \"Welt\"]`\n",
    "- Dictionaries: Zuordnung von Schlüssel zu Wert. Bsp: `d = {\"Hallo\": 5, \"Welt\": 4}`\n",
    "- Tupel: Geordnete Auflistung von Elementen, jedoch unveränderlich\n",
    "- Set: Ungeordnete Sammlung von Elementen, deren Elemente innerhalb nur einmal vorkommen dürfen\n",
    "- Queue: Ähnlich wie Liste, sind Elemente sortiert und werden in Reihenfolge der Eingabe ausgegeben\n",
    "- PriorityQueue (Prioritätswarteschlange): Automatische Sortierung der Elemente\n",
    "\n",
    "## Listen\n",
    "Listen können mehrere Elemente enthalten und sind veränderliche Datenstruktur.<br>\n",
    "**Listenname = [\"Element1\", Element2\", ... ]**\n",
    "- Kann nachträglich erweitert werden\n",
    "- Reihenfolge wird beibehalten\n",
    "- Elemente dürfen mehrfach vorkommen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Alex', 'Bob', 'Cedric', 'Erika']\n"
     ]
    }
   ],
   "source": [
    "students = [\"Alex\", \"Bob\", \"Cedric\", \"Erika\"]\n",
    "print(students)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Element aus Liste auswählen\n",
    "Elemente einer Liste sind aufsteigend von 0 an nummeriert.<br>\n",
    "Per Index kann ein einzelnes Element über seine Listenposition angewählt werden: **Listenname[Position]**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Alex\n"
     ]
    }
   ],
   "source": [
    "print(students[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Über eine **negative** Positionsnummer kann die Liste vom **Ende zum Anfang** ausgelesen werden. \n",
    "Die Ausgabe ist wieder in Reihenfolge der orginalen Liste"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Erika\n"
     ]
    }
   ],
   "source": [
    "print(students[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Liste Trennen\n",
    "Eine Liste kann auch aufgeteilt (gesliced) werden. Hierfür wird **Zahl:Zahl**. Wobei die Zahlen die zu überspringenden Indexe angeben."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Cedric', 'Erika']\n",
      "['Bob', 'Cedric']\n",
      "['Bob', 'Cedric', 'Erika']\n"
     ]
    }
   ],
   "source": [
    "print(students[2:4])\n",
    "print(students[1:-1]) #auch hier können negative Positionen benutzt werden\n",
    "print(students[1:]) # mit auslassen einer Zahl wird die Liste bis zum Ende ausgeführt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Element einer Liste anhängen\n",
    "über **append()** kann ein Element an das Ende einer Liste hinzugefügt werden"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Alex', 'Bob', 'Cedric', 'Erika', 'Franz']\n"
     ]
    }
   ],
   "source": [
    "students.append(\"Franz\")\n",
    "print(students)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ebenso mit **+** können weitere Elemente hinzugefügt werden"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Alex', 'Bob', 'Cedric', 'Erika', 'Ferdinand']\n"
     ]
    }
   ],
   "source": [
    "students = [\"Alex\", \"Bob\", \"Cedric\", \"Erika\"] + [\"Ferdinand\"]\n",
    "print(students)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Elemente aus Liste entfernen\n",
    "mit **del** kann ein bestimmtes Element anhand der **Position** aus einer Liste entfernt werden"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Alex', 'Bob', 'Cedric', 'Ferdinand']\n"
     ]
    }
   ],
   "source": [
    "del students[3]\n",
    "print(students)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "mit **remove** kann ein bestimmtes Element anhand des **Strings** aus einer Liste entfernt werden"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Bob', 'Cedric', 'Ferdinand']\n"
     ]
    }
   ],
   "source": [
    "students.remove(\"Alex\")\n",
    "print(students)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "über **.pop()** kann das **letzte** Element aus der Liste entfernt werden"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Bob', 'Cedric']\n",
      "Ferdinand\n"
     ]
    }
   ],
   "source": [
    "x = students.pop() #aus Students wird das letzte Element entfernt\n",
    "print(students) #restliche Liste\n",
    "print(x)  #entferntes Element"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List Comprehension\n",
    "Einfache Umwandlung bzw Neuerstellung einer Liste. Beachte, dass die Variablen ungleich der Listennamen vergeben werden müssen!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4]\n",
      "[1, 4, 9, 16]\n"
     ]
    }
   ],
   "source": [
    "xs = [1,2,3,4]\n",
    "ys = [x * x for x in xs] # für jeden Wert in xs wird das Quadrat in ys gespeichert\n",
    "print(xs)\n",
    "print(ys)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 3, 6, 5, 9]\n"
     ]
    }
   ],
   "source": [
    "students = [\"Alex\", \"Bob\", \"Cedric\", \"Erika\", \"Ferdinand\"]\n",
    "lengths = [len(student) for student in students] \n",
    "#für jede Länge eines Studentennames wird das Ergebnis in \"lenghts\" gespeichert\n",
    "print(lengths)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]\n",
      "[0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]\n"
     ]
    }
   ],
   "source": [
    "#Zu viele Zeilen!\n",
    "xs = []\n",
    "for x in range(0,10):\n",
    "    xs.append(x/10)\n",
    "print(xs)\n",
    "\n",
    "#einfacher:\n",
    "xs = [x/10 for x in range(0,10)]\n",
    "print(xs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Listen verschachteln\n",
    "Listen können ineinander verschachtelt werden um z.B. eine Matrix zu modellieren.<br>\n",
    "**[[Liste1],[Liste2]]**<br>\n",
    "Beachte, dass verschachtelte Listen mit einem Kommata getrennt werden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Element3\n",
      "Element5\n"
     ]
    }
   ],
   "source": [
    "liste = [\n",
    "    [\"Element1\", \"Element2\", \"Element3\"],\n",
    "    [\"Element4\", \"Element5\", \"Element6\"]\n",
    "]\n",
    "print(liste[0][2])\n",
    "print(liste[1][1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionaries\n",
    "Die Verknüpfung verschiedener Strings und Listen wird mit Dictionaries erfolgen.\n",
    " - Speichert eine Zuordnung von einem Schlüssel (key) zu einem Wert (value)\n",
    " - Reihenfolge wird nicht beibehalten\n",
    " - Werte dürfen mehrfach vorkommen\n",
    " - Jeder Schlüssel darf aber nur 1x existieren"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Berlin': 'BER', 'Helsinki': 'Hel', 'Barcelona': 'BAC'}\n",
      "Hel\n",
      "Hel\n",
      "None\n",
      "dict_items([('Berlin', 'BER'), ('Helsinki', 'Hel'), ('Barcelona', 'BAC')])\n"
     ]
    }
   ],
   "source": [
    "d = {\"Berlin\":\"BER\", \"Helsinki\":\"Hel\", \"Barcelona\":\"BAC\"} # Aufbau eines Dictionaries\n",
    "print(d) # Ausgabe des gesamten Dictionaries\n",
    "print(d[\"Helsinki\"]) # Ausgabe der Wertzuweisung für den Schlüssel \"Helsinki\"\n",
    "print(d.get(\"Helsinki\")) # vermeidet Fehler falls Schlüssel nicht im Dictionarie enthalten\n",
    "print(d.get(\"Budapest\")) # Beispiel für nicht-existenz\n",
    "print(d.items())  # Ausgabe des Dictionaries als Liste mit Tupel"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dictionaries kann jedem Element/Schlüssel auch eine Definition zugewiesen werden"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Berlin : BER\n",
      "Helsinki : Hel\n",
      "Barcelona : BAC\n"
     ]
    }
   ],
   "source": [
    "for key, wert in d.items():\n",
    "\n",
    "    print(key + \" : \" + wert)  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Listen in Dictionaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['BER', 'Berlin']\n"
     ]
    }
   ],
   "source": [
    "staedte = {\n",
    "    \"München\": [\"MUC\", \"Bayern\"],\n",
    "    \"Berlin\": [\"BER\", \"Berlin\"]\n",
    "}\n",
    "\n",
    "print(staedte[\"Berlin\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tupel\n",
    "Ähnlich zu Listen, jedoch unveränderliche Datenstruktur (nicht erweiterbar)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3)\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "t = (1, 2, 3) # ein Tupel wird mit runden Klammern gebildet\n",
    "\n",
    "print(t)      # abrufen des gesamten Tupel\n",
    "\n",
    "print(t[1])   # abrufen eines bestimmten Tupel-Elements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tupel definieren\n",
    "Der Inhalt eines Tupels kann durch Variablen definiert und zugewiesen werden. Erleichtert den Zugriff und das Entpacken"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Maschinenbau\n"
     ]
    }
   ],
   "source": [
    "student = (\"Max Mustermann\", 20, \"Maschinenbau\") # Tupel bilden\n",
    "name, alter, fach = student # Tupel entpacken und Definition zuweisen\n",
    "print(fach)   # Information aus Tupel anhand der Definition entpacken"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Eine Liste mit Tupel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Max\n",
      "Alex\n"
     ]
    }
   ],
   "source": [
    "students = [\n",
    "    (\"Max\", 20), # Komma zwischen Tupel nicht vergessen!\n",
    "    (\"Alex\", 30)\n",
    "]\n",
    "\n",
    "for name, alter in students: # Definitionen zuweisen \n",
    "    print(name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set\n",
    "Ungeordnete Sammlung von Elementen, deren Elemente innerhalb nur einmal vorkommen dürfen.\n",
    "    - Kann nachträglich erweitert werden\n",
    "    - Reihenfolge wird nicht beibehalten\n",
    "    - Index - Schreibweise s[15] wird nicht unterstützt\n",
    "    - Jedes Element kommt nur 1x vor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Hallo', 'Welt']\n",
      "['Hallo', 'Welt', 'Mars']\n"
     ]
    }
   ],
   "source": [
    "s = [\"Hallo\", \"Welt\"]\n",
    "print(s)\n",
    "s.append(\"Mars\")\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mars ist im Set\n"
     ]
    }
   ],
   "source": [
    "if \"Mars\" in s:\n",
    "    print(\"Mars ist im Set\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Queue\n",
    "Ähnlich wie Liste, sind Elemente sortiert und werden in Reihenfolge der Eingabe ausgegeben"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<queue.Queue object at 0x0000025AEDBD8780>\n",
      "Hallo\n",
      "Welt\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import queue\n",
    "q = queue.Queue()     # Queue erstellen\n",
    "\n",
    "q.put(\"Hallo\")        # Elemente einfügen\n",
    "q.put(\"Welt\")\n",
    "\n",
    "print(q)\n",
    "print(q.get())        # Element ausgeben\n",
    "print(q.get())\n",
    "\n",
    "q.empty()             # überprüfen ob Queue leer ist"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## PriorityQueue\n",
    "Ähnlich wie Queue. Elemente werden mit unterschiedlicher \"Dringlichkeit\" eingegeben und nach \"Dringlichkeit\" ausgegeben. Automatische Sortierung der Elemente nach \"Dringlichkeit\".\n",
    "    - Optimierte Datenstruktur, um Elemente nach einer Priorität zu sortieren\n",
    "    - Elemente werden quasi automatisch nach ihrer Priorität sortiert\n",
    "    - Direkter Zugriff auf die Elemente nicht möglich\n",
    "    - Man kann nur auf das erste Element zugreifen, bzw. das erste Element entfernen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(5, 'Wichtig')\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(10, 'Hallo Welt')"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import queue\n",
    "q = queue.PriorityQueue()    #PriotityQueue erstellen\n",
    "\n",
    "q.put((10, \"Hallo Welt\"))    # Elemente mit Priorität einfügen\n",
    "q.put((5, \"Wichtig\"))\n",
    "q.put((15, \"Mars\"))\n",
    "\n",
    "print(q.get())                      # Element von kleinster nach größter Priorität ausgeben\n",
    "q.get()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. Daten(-strukturen umwandeln\n",
    "### Einen String in eine Ganzzahl umwandeln\n",
    "**int()**-Befehl auf einen String: **int(string)**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "a = int(\"5\")\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Einen String in eine Kommazahl umwandeln\n",
    "**float()**-Befehl auf einen String: **float(string)**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.5\n"
     ]
    }
   ],
   "source": [
    "a = float(\"5.5\")\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Eine Zahl in einen String umwandeln\n",
    "**str()**-Befehl auf eine Ganzzahl oder Kommazahl: **str(zahl)**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "21\n"
     ]
    }
   ],
   "source": [
    "age = str(21)\n",
    "print(age)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Einen String in eine Liste aufspalten\n",
    "**split()**-Befehl auf einen String: **string.split()**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Alex,', 'Bob,', 'Cedric,', 'Erika']\n",
      "['Alex', 'Bob', 'Cedric', 'Erika']\n"
     ]
    }
   ],
   "source": [
    "students = \"Alex, Bob, Cedric, Erika\"\n",
    "print(students.split()) # Kommata werden übernommen\n",
    "print(students.split(\", \")) # Kommata werden ausgelassen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4. Operatoren & Gatter\n",
    "### Vergleichoperatoren\n",
    "Verschiedene Operatoren zum Vergleichen von Variablen/Zahlen\n",
    " - **a == b** Werte sind gleich\n",
    " - **a != b** Werte sind ungleich\n",
    " - **a < b**  Wert b ist größer als Wert a\n",
    " - **a > b**  Wert a ist größer als Wert b\n",
    " - **a <= b** Wert b ist größer-gleich Wert a\n",
    " - **a >= b** Wert a ist größer-gleich Wert a\n",
    "Die Ausgabe über **print()** gibt die Booleans **True**(Wahr) oder **False**(Falsch) aus"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "True\n",
      "False\n",
      "True\n",
      "False\n",
      "False\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "a = 5\n",
    "b = 6\n",
    "print(a == b)  # Gleichheit\n",
    "print(a != b)  # Ungleichheit\n",
    "print(a < b)   # kleiner als\n",
    "print(a > b)   # größer als\n",
    "print(a <= b)  # kleiner-gleich als\n",
    "print(a >= b)  # größer-gleich als\n",
    "print( \"Hallo\" == \"World\") # auch Strings können verglichen werden\n",
    "print(True is True) # für Boolean Werte keine '='-Zeichen benutzen!\n",
    "print(True is not True) # Boolean werden mit 'is' und 'is not' abgefragt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Gatter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# Für and müssen beide Variablen den gleichen Wert annehmen\n",
    "print(True and True)\n",
    "print(True and False)\n",
    "print(False and True)\n",
    "print(False and False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# Für or muss eine der Variablen True annehmen\n",
    "print(True or True)\n",
    "print(True or False)\n",
    "print(False or True)\n",
    "print(False or False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# 'not' Gatter negieren Ihr Ergebnis\n",
    "print(not True)\n",
    "print(not False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Der in-Operator\n",
    "mit **in**-Operatoren kann man überprüfen, ob ein Element in einem anderen Element enthalten ist\n",
    "\n",
    "der **in**-Operator mit Listen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "students = [\"Alex\", \"Bob\", \"Cedric\", \"Erika\"]\n",
    "print(\"Monika\" in students) # Monika ist nicht in der Liste\n",
    "print(\"Bob\" in students) # Bob ist in der Liste"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "der **in**-Operator mit Strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "satz =\"Ja dieser Text ist ein String!\"\n",
    "print(\"Ja\" in satz) # \"Ja\" ist in dem String enthalten "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Der not-Operator\n",
    "Der **not**-Operator negiert das Ergebnis bzw. die Abfrage.\n",
    "\n",
    "Beachte, dass der **not**-Operator vor und nach der Variable kommen kann"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print( not 5 == 5) # Das Erbgenis von \"5 == 5\" ist wahr, \"not\" negiert das Ergebnis\n",
    "\n",
    "# Es können auch Listen abgefragt werden:\n",
    "names = [\"Andreas\", \"Bertold\"]\n",
    "print(\"Alex\" not in names)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mehr Operatoren"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "6\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "i = 5\n",
    "print(i)\n",
    "i += 1  # Mit += kann die Variable mit den nachstehenden Wert addiert und in i gespeichert werden\n",
    "print(i)\n",
    "i -= 1  # Mit -= kann die Variable mit den nachstehenden Wert subtrahiert und in i gespeichert werden\n",
    "print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5. Schleifen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## if-else-Struktur\n",
    "Ausführen bestimmter Abschnitte nur bei bestimmter Bedingung in **if-else-Struktur**.\n",
    "**if** fordert eine Bedingung, wird diese Bedingung erfüllt wird der eingrückte nachstehende Code ausgeführt.\n",
    "**else** wird ausgeführt, wenn die Bedingung nicht erfüllt wird\n",
    "\n",
    "Jeder Codeblock wird nur einmal ausgeführt. Beachte die Einrückung für den Codeabschnitt!\n",
    "\n",
    "if Bedingung:<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Auszuführender_Code<br>\n",
    "else:<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Sonst-Auszuführender_Code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x ist kleiner als 10\n",
      "Ich bin nicht mehr Eingerückt\n"
     ]
    }
   ],
   "source": [
    "x = 5\n",
    "if x < 10:\n",
    "    print(\"x ist kleiner als 10\")\n",
    "else:\n",
    "    print(\"x ist größer als 9\")\n",
    "print(\"Ich bin nicht mehr Eingerückt\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Müssen mehr als zwei **if-else** Fälle abgefragt werden, nutzt man **elif nächste_Bedinung:** als Kurzfassung."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x ist 5\n"
     ]
    }
   ],
   "source": [
    "x = 5\n",
    "if x == 8:\n",
    "    print(\"x ist 8\")\n",
    "elif x==7:\n",
    "    print(\"x ist 7\")\n",
    "elif x==6:\n",
    "    print(\"x ist 6\")\n",
    "elif x==5:\n",
    "    print(\"x ist 5\")\n",
    "else:\n",
    "    print(\"x ist nicht zwischen 4 und 9\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## for-Schleife\n",
    "Die **for**-Schleife durchläuft eine anzugebende Sequenz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "5\n",
      "Max\n",
      "Mustermann\n",
      "Michael\n"
     ]
    }
   ],
   "source": [
    "# Das Funktioniert sowohl mit Zahlen als auch Strings\n",
    "liste = [1, 2, 5]\n",
    "for i in liste:\n",
    "    print(i)\n",
    "    \n",
    "liste = [\"Max\", \"Mustermann\", \"Michael\"]\n",
    "for i in liste:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Das **range**-Objekt wird dazu genutzt, die Sequenzlänge vorzugeben. D.h. wie oft die Schleife durchlaufen werden soll."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "for i in range(0, 5): # von 0 bis 4 werden alle Zahlen ausgegeben\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## while-Schleife\n",
    "**while**-Schleifen führen einen Code-Block mehrmals hintereinander aus, bis eine Abbruchbedingung erfüllt ist.\n",
    "Innerhalb einer while-Schleife muss ein Zustand verändert werden, damit das Programm die Schleife auch wieder verlassen kann!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "zähler = 0\n",
    "while zähler < 3:\n",
    "    print(zähler)\n",
    "    zähler += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Continue & Break\n",
    "Während eines Schleifendurchlaufs kann der man vorzeitig abbrechen und mit dem nächsten Schleifendurchlauf fortfahren (**continue**) oder die gesamte Schleife abbrechen (**break**)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "for i in range(0, 4):\n",
    "    if i == 2:\n",
    "        continue  # anstatt print(2) auszuführen wird 2 übersprungen und mit dem nächsten Durchlauf fortgesetzt\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "for i in range(0, 4):\n",
    "    if i == 2:\n",
    "        break  # an dieser Stelle wird die Schleife abgebrochen und nicht weiter ausgeführt \n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 6. Funktionen\n",
    "Funktionen sind zusammengefasste Codeblöcke. Mittels Funktionen vermeidet man mehrmals verwendete Codeblöcke. Eine Funktion kann merhmals im Programm aufgerufen werden, nachdem sie definiert wurde.<br>\n",
    "Beachte, der Funktion oder ihren Variablen keine Namens-Dopplungen aus deinem Code zu geben!\n",
    "\n",
    "### Funktionen definieren und Aufrufen\n",
    "\n",
    "def Funktionname():<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hi\n",
      "there\n"
     ]
    }
   ],
   "source": [
    "def print_more():    # Das Definieren der Funktion\n",
    "    print(\"hi\")\n",
    "    print(\"there\")\n",
    "    \n",
    "print_more()    # Das Aufrufen der Funktion mit ihrem Funktionsnamen()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Funktionen können auch mit einem oder mehreren Argumenten arbeiten\n",
    "Argumente und Variablen können an Funktionen übergeben werden. Zu beachten ist hierbei, dass die Funktion mit einer \"Kopie\" der Variable arbeitet und nur mit einem 'return' diese Variable im restlichen Code ändert. Sonst wird die Variable nur innerhalb der Funktion geändert. Ausnahmen sind Listen (oä) die innerhalb einer Funktion erweiter/gekürtzt werden.<br>\n",
    "**def** Funktionname(Argument):<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;**Code**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hallo mein Name ist Hans.\n"
     ]
    }
   ],
   "source": [
    "def print_name(name): # hier wird in Klammern ein Argument übergeben, ein Argument kann frei definiert werden\n",
    "    print(\"Hallo mein Name ist \" + name + \".\") #das Argument wird mit Argument-Namen übernommen und kann verwendet werden\n",
    "\n",
    "print_name(\"Hans\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hallo!\n",
      "Hallo!\n",
      "Hallo!\n"
     ]
    }
   ],
   "source": [
    "def print_more(name, count):\n",
    "    for i in range(0, count):\n",
    "        print(name)\n",
    "        \n",
    "print_more(\"Hallo!\", 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variable Funktionsparameter\n",
    "Einer Funktion können auch unterschiedlich viele Parameter übergeben werden"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "12\n"
     ]
    }
   ],
   "source": [
    "def calculate_max(*parameter):\n",
    "    current_max = parameter[0]\n",
    "    for item in parameter:\n",
    "        if item > current_max:\n",
    "            current_max = item\n",
    "    return current_max\n",
    "\n",
    "print( calculate_max(1,2,3) )\n",
    "print( calculate_max(2,4,6,8,10,12) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ineinander verschachtelte Funktionen sind auch möglich"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hallo mein Name ist Hans.\n",
      "Ich bin 23 Jahre alt.\n"
     ]
    }
   ],
   "source": [
    "def print_name(name):\n",
    "    print(\"Hallo mein Name ist \" + name + \".\")\n",
    "def print_alter(alter):\n",
    "    print(\"Ich bin \" + str(alter) + \" Jahre alt.\")\n",
    "\n",
    "def NameUndAlter(name, alter):\n",
    "    print_name(name)\n",
    "    print_alter(alter)\n",
    "\n",
    "NameUndAlter(\"Hans\", 23)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Werte zurückgeben mit 'return'\n",
    "Mit dem Befehl **return** können Werte aus einer Funktion zurückgegeben werden. Funktionen mit **return** können wie Variablen behandelt werden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hi\n"
     ]
    }
   ],
   "source": [
    "def return_element(name):\n",
    "    return name\n",
    "\n",
    "print(return_element(\"Hi\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mehr Funktionen\n",
    "Neben selbst erstellten Funktionen bietet Python selbst vordefinierte Funktionen, diese findet man [hier](https://docs.python.org/3/library/functions.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 7. Dateien\n",
    "Einfaches öffnen und schließen von Dateien kann mit **open()** und **close()** realisiert werden.<br>\n",
    "Mit dem **with**-Konstruktor müssen geöffnete Dateien danach nicht mit der **close()** -Methode geschlossen werden.\n",
    "\n",
    "**open**(\"dateiname\", \"operator\")<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; **write**.CodeMitDatei<br>\n",
    "**close()**\n",
    "\n",
    "**with** open(\"dateiname.dateiendung\", \"operator\") **as** dateiname_in_funktion: <br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Code\n",
    "\n",
    "Mögliche Dateien sind .txt, .csv (comma seperated values), ...\n",
    "\n",
    "### Textdateien schreiben\n",
    "Zum schreiben einer neuen Datei nutzt man den Operator **w** (write)<br>\n",
    "Soll nichts überschrieben werden oder Text angehängt werden nutzt man den Operator **a** (append)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "file = open(\"test.txt\", \"w\")\n",
    "file.write(\"Diese Datei wurde mit Phyton geschrieben. \\n\")\n",
    "file.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Textdateien lesen und Inhalt ausgeben\n",
    "Zum lesen einer Datei nutzen wir den Operator \"r\" (read)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Diese Datei wurde mit Phyton geschrieben.\n"
     ]
    }
   ],
   "source": [
    "file = open(\"test.txt\", \"r\")\n",
    "for line in file:  # Alle Zeilen nacheinander auslesen\n",
    "    print(line.strip()) #eine Zeile ohne Zeilenumbruch ausgeben\n",
    "file.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Zeichen aus Datei entfernen\n",
    "das Entfernen bestimmter Zeichen ist mit Python einfach realisierbar. Es wurde schon im oberen Beispiel gezeigt:<br>\n",
    "**.strip** entfernt Sonderzeichen wie z.B. \\n (Zeilenumbruch)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 8. Module\n",
    "Mit Modulen können Funktionen und Rechnungen aus anderen Python-Programmen in einem anderen Wiederbenutzt werden.<br>\n",
    "Dafür erstellt man erst ein Python-Programm (Datei mit **.py**-Endung). Diese wird über den **import**-Befehl geladen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hallo Welt\n"
     ]
    }
   ],
   "source": [
    "# Das 'hallo.py' Programm:\n",
    "def welt():\n",
    "    print(\"Hallo Welt\")\n",
    "welt()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hallo Welt\n"
     ]
    }
   ],
   "source": [
    "import hallo # die Datei hallo.py wird in das aktuelle Programm eingebunden\n",
    "hallo.welt() # die Funktion welt() im hallo.py-Programm wird in unserem aktuellen Skript ausgeführt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hallo Welt\n"
     ]
    }
   ],
   "source": [
    "from hallo import welt # damit wird explizit nur die Funktion 'welt()' in das aktuelle Programm geladen, jede weitere mit ',' getrennt\n",
    "welt() # die Funktion kann damit direkt benutzt werden\n",
    "# Achte auf Dopplungen von Funktionsnamen in unterschiedlichen Programmen!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hallo Welt\n"
     ]
    }
   ],
   "source": [
    "from hallo import * # mit dem '*' werden alle Funktionen aus 'hallo.py' in das aktuelle Programm geladen\n",
    "welt() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hallo Welt\n"
     ]
    }
   ],
   "source": [
    "import hallo as h # mit der 'as'-Methode wird zum Aufrufen eines Programms im Skript ein 'Ersatzname' genutzt\n",
    "h.welt() # diese Variante kann lange Programmnamen abkürzen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Modulordner definieren und strukturieren\n",
    "Um viele Programme und Module strukturiert zu halten ist es oft praktisch diese in einem extra Ordner zu speichern. Hierbei ist es vorteilhaft eine Modul-Datei mit der Auflistung aller möglichen Programme zu führen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Modul-Datei: __init__.py\n",
    "__all__ = [\"datei\"] # all Beschreibt alle Module, \"datei\" ist ein Programm namens 'datei.py' im Modulordner"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "datei.py - Funktion f()\n"
     ]
    }
   ],
   "source": [
    "# hier wird der Vorteil der Modul-Datei gezeigt\n",
    "from ordner import * # alle Funktionen aus dem Ordner 'ordner' werden geladen\n",
    "datei.f()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Module importieren\n",
    "für zusätzliche Funktionen können externe bzw. fertige Module in Python importiert werden.<br>\n",
    "Den Python-Modul-Indes findet man hier: https://docs.python.org/3/py-modindex.html<br>\n",
    "Einige der wichtigsten Module werden folgend vorgestellt\n",
    "\n",
    "### Mathe plotten\n",
    "mit der Bibliothek für Matheplotter (**mathplotlib.pyplot**) können Funktionen und Zahlen Grafisch visualisiert werden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline \n",
    "import matplotlib.pyplot as plt # hier wird das Matplolib-Modul importiert und mit der Variable plt verknüpft\n",
    "plt.scatter([1, 2 , 3], [4, 3, 2])  # plt. kann dann für das Modul benutzt werden\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Programm Beenden/Abbrechen\n",
    "Mit **sys.exit** (muss importiert werden) kann ein laufendes Programm vorzeitig abgebrochen werden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "#sys.exit() (Bei Anwendung hier kann der weitere Verlauf nicht umgesetzt werden)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Programm pausieren\n",
    "Manchmal ist es notwenig das Programm pausieren zu lassen (Bsp Crawler auf Webseite). Dafür nutzt man das Modul **time**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time     # Time-Modul importieren\n",
    "time.sleep(1)   # '1'-Sekunde Programmpause"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Webseiten runterladen\n",
    "Mit einem **request** kann eine bestimmte Webseite heruntergeladen und der HTML-Code ausgegeben werden (http://docs.python-requests.org/en/master/)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "200\n"
     ]
    }
   ],
   "source": [
    "import requests\n",
    "r = requests.get(\"http://www.google.de\")\n",
    "\n",
    "print(r.status_code)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Elemente in HTML finden\n",
    "Aus html-Dateien kann man mit **BeautifulSoup** (https://www.crummy.com/software/BeautifulSoup/bs4/doc/) Informationen zerlegen und extrahieren."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'class': ['something']}\n",
      "Ich bin ein Absatz!\n",
      "{}\n",
      "Ich bin noch ein Absatz\n"
     ]
    }
   ],
   "source": [
    "from bs4 import BeautifulSoup      # BeautifulSoup importieren\n",
    "\n",
    "# Beispiel HTML-Datei \n",
    "htmlDatei = \"\"\" \n",
    "    <html>\n",
    "        <body>\n",
    "            <p class=\"something\">Ich bin ein Absatz!</p>\n",
    "            <p>Ich bin noch ein Absatz</p>\n",
    "        </body>\n",
    "    </html>\n",
    "\"\"\"\n",
    "\n",
    "doc = BeautifulSoup(htmlDatei, \"html.parser\") # HTML-Datei mit BeautifulSoup Parsen/Einlesen\n",
    "\n",
    "for p in doc.find_all(\"p\"):   # im Dokument alle <p>-Konstruktoren finden\n",
    "    print(p.attrs)            # für alle <p> dessen Attribute ausgeben\n",
    "    print(p.text)             # für alle <p> dessen Text ausgeben"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### relative URLs\n",
    "Einige Elemente (z.B. Bilder) sind auf Webseiten nur relativ zu Ihrer Webseite verlinkt. Beim Crawlen kann der gesamte Bildpfad mit **urljoin** hergestellt werden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "relative URL: ./img/1.jpg gesamte URL: http://python.beispiel.programmierenlernen.io/img/1.jpg\n",
      "relative URL: ./img/2.jpg gesamte URL: http://python.beispiel.programmierenlernen.io/img/2.jpg\n",
      "relative URL: ./img/3.jpg gesamte URL: http://python.beispiel.programmierenlernen.io/img/3.jpg\n",
      "relative URL: ./img/4.jpg gesamte URL: http://python.beispiel.programmierenlernen.io/img/4.jpg\n",
      "relative URL: ./img/5.jpg gesamte URL: http://python.beispiel.programmierenlernen.io/img/5.jpg\n",
      "relative URL: ./img/6.jpg gesamte URL: http://python.beispiel.programmierenlernen.io/img/6.jpg\n",
      "relative URL: ./img/7.jpg gesamte URL: http://python.beispiel.programmierenlernen.io/img/7.jpg\n"
     ]
    }
   ],
   "source": [
    "from urllib.parse import urljoin   # urljoin importieren\n",
    "from bs4 import BeautifulSoup      # BeautifulSoup importieren\n",
    "\n",
    "url = \"http://python.beispiel.programmierenlernen.io/index.php\" #Webseiten-URL die durchsucht wurde\n",
    "\n",
    "r = requests.get(url)\n",
    "doc = BeautifulSoup(r.text, \"html.parser\") # HTML-Datei mit BeautifulSoup Parsen/Einlesen\n",
    "    \n",
    "for card in doc.select(\".card\"):\n",
    "    image = card.select_one(\"img\").attrs[\"src\"]\n",
    "    imageURL = urljoin(url, image)\n",
    "    print(\"relative URL: \" + image + \" gesamte URL: \" + imageURL)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 9. Generatoren\n",
    "Generatoren erzeugen Listen (meist aus Crawlern) die viele Einträge enthält. Aus dieser Liste können eine bestimmte Anzahl an Einträgen ausgegeben werden. Die **.fetch()**-Methode erkennt dies dadurch automatisch."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "gen: 0\n",
      "for: 0\n",
      "gen: 1\n",
      "for: 1\n",
      "gen: 2\n",
      "for: 2\n",
      "####\n",
      "gen: 0\n",
      "for: 0\n",
      "gen: 1\n"
     ]
    }
   ],
   "source": [
    "def gen_generator():\n",
    "    for i in range(0, 3):\n",
    "        print(\"gen: \" + str(i))\n",
    "        yield i\n",
    "\n",
    "for element in gen_generator():      # Alle Elemente der Liste ausgeben\n",
    "    print(\"for: \" + str(element))\n",
    "\n",
    "print(\"####\")\n",
    "\n",
    "for element in gen_generator():      # die ersten 2 Elemente ausgeben\n",
    "    if element == 1:\n",
    "        break\n",
    "    print(\"for: \" + str(element))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 10. Objektorientierung\n",
    "Klassen sind Baupläne für Objekte. Die erzeugten Objekte nennt man Instanzen dieser Klasse."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Erik\n"
     ]
    }
   ],
   "source": [
    "class Student():               # Klasse Student erstellen, Klassennamen beginnen gemäß Konvention mit Großbuchstaben\n",
    "    pass                       # Leere Klasse zulassen\n",
    "\n",
    "erik = Student()               # Instanz erzeugen\n",
    "erik.firstname = \"Erik\"        # zwei Variablen für das Objekt,\n",
    "erik.lastname = \"Mustermann\"   # auf díe über das Objekt per Punktschreibweise zugegriffen werden kann\n",
    "\n",
    "print(erik.firstname)          "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mueller\n"
     ]
    }
   ],
   "source": [
    "class Student():                      \n",
    "    def __init__(self, firstname, lastname): # durch Definition der Variablen mittel einer Methode\n",
    "        self.firstname = firstname           # können Instanzen einfach hinzugefügt werden\n",
    "        self.lastname = lastname\n",
    "\n",
    "monika = Student(\"Monika\", \"Mueller\") # Kurzschreibweise für Instanz\n",
    "\n",
    "print(monika.lastname)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Methoden und Definitionen können innerhalb von Objekten gebildet werden um Namensübertretungen zu verhindern bzw. \n",
    "innerhalb eines Objekts alle Namenskonventionen festzuhalten.<br>\n",
    "**self** ist ein Schlüsselwort, es fungiert gewissermassen als Platzhalter für die jeweilige Instanz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Erik Mustermann\n"
     ]
    }
   ],
   "source": [
    "class Student():\n",
    "    def name(self): # ein Konstruktor, der eine Funktion für das Objekt definiert\n",
    "        print(self.firstname + \" \" + self.lastname)\n",
    "\n",
    "erik = Student()              \n",
    "erik.firstname = \"Erik\"       \n",
    "erik.lastname = \"Mustermann\"\n",
    "erik.name()     "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Erik Mustermann (Semester: 1)\n",
      "Erik Mustermann (Semester: 2)\n"
     ]
    }
   ],
   "source": [
    "class Student():\n",
    "    def __init__(self, firstname, lastname):\n",
    "        self.firstname = firstname\n",
    "        self.lastname = lastname\n",
    "        self.term = 1 # Hier initialisiert die neue Variable term (Eigenschaft)\n",
    "        \n",
    "    def increase_term(self): # Mit dieser Methode erhöht die Variable term um 1\n",
    "        self.term = self.term + 1\n",
    "    \n",
    "    def name(self): # name() gibt Name und Anzahl der Semester aus\n",
    "        print(self.firstname + \" \" + self.lastname + \n",
    "              \" (Semester: \" + str(self.term) + \")\")\n",
    "        \n",
    "erik = Student(\"Erik\", \"Mustermann\")\n",
    "erik.name()\n",
    "erik.increase_term() #Semester erhöhen\n",
    "erik.name()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Private Eigenschaften und Methoden\n",
    "Private Eigenschaften erlauben sauberes Kapseln von Eigenschaften und Methoden. Dadurch können Variablen und Methoden  vor außerhalb geschützt werden. Wichtig wenn diese Variablen / Methoden noch angeüasst werden.<br>\n",
    "Mit **zwei Unterstrichen** vor der Variable wird diese **privat**. Methoden könne auf dieselbe Weise eingeschränkt werden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Student():\n",
    "    def increase_term(self):\n",
    "        self.__term = self.__term + 1\n",
    "        \n",
    "    def get_term(self): # um von außen noch auf die Variable term zugreifen zu können\n",
    "        return self.__term\n",
    "    \n",
    "    def __do_something(self):\n",
    "        print(\"doSomething\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Vererbung\n",
    "Durch Vererbung können Daten aufgeteilt und besser modelliert werden.<br>\n",
    "Als Parameter wird die Klasse übergeben, von der neue Eigenschaften und Methoden vererbt werden sollen (Mutterklasse)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "class WorkingStudent(Student):\n",
    "    \n",
    "    def __init__(self, firstname, surname, company):        \n",
    "        # mit super() wird Python gezeigt, dass die init()-Methode der Mutterklasse angewendet werden soll\n",
    "        super().__init__(firstname, surname)\n",
    "        self.company = company\n",
    "    \n",
    "    def name(self):\n",
    "        return super().name() + \" (\" + self.company + \")\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Die type() und isinstance() Funktionen\n",
    "Mit der **type()**-Funktion kann der Typ eines Objektes festgestellt werden.<br>\n",
    "Die Funktion **isinstance()** erhält zwei Parameter: die **Variable** und die **Klasse** bezüglich derer auf Zugehörigkeit der Variable geprüft werden soll. **isinstance()** liefert einen Bool zurück."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'tuple'>\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(type(student))\n",
    "print(isinstance(student, Student))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Statische Variablen\n",
    "Anstatt Instanzen können auch Variablen an Klassen gebunden werden. Diese heißen statisch, weil sie nicht an einer einzelnen Instanz hängen. Werden die Variablen geändert, werden sie für alle Objekte geändert."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "expensive\n"
     ]
    }
   ],
   "source": [
    "class Car:\n",
    "    price = \"expensive\" # der Preis wird auf jedes Objekt übertragen das mit der Klasse 'Car' erstellt wurde\n",
    "\n",
    "c = Car\n",
    "print(c.price)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Styleguide für Klassen und Variablen\n",
    "In Python verwendet man dazu nach Konvention:\n",
    "\n",
    "- PascalCase (`IchBesteheAusMehrerenWoertern`)\n",
    "- sneak_case (`ich_bestehe_aus_mehreren_woertern`)\n",
    "\n",
    "Anders als in anderen Programmiersprachen benutzt man nicht:\n",
    "\n",
    "- camelCase (`ichBesteheAusMehrerenWoertern`)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Besondere Methoden\n",
    "Die str-Funktion gibt für **print(objekt)** eine Definierte Form aus.<br>\n",
    "Die repr-Methode gibt für **Objekt** eine Definierte Form aus.<br>\n",
    "Die len-Methode gibt für **print(len(Objekt))** die Länge aus.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "PhoneBook({'Mustermann': '1234', 'Mueller': '9876'})\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "class PhoneBook():\n",
    "    def __init__(self):\n",
    "        self.__entries = {}\n",
    "    def add(self, name, phone_number):\n",
    "        self.__entries[name] = phone_number\n",
    "    def get(self, name):\n",
    "        if name in self.__entries:\n",
    "            return self.__entries[name]\n",
    "        else:\n",
    "            return None\n",
    "    def __str__(self):\n",
    "        return \"PhoneBook(\" + str(self.__entries) + \")\"\n",
    "    def __repr__(self):\n",
    "        return \"PhoneBook(\" + str(self.__entries) + \")\"\n",
    "    def __len__(self):\n",
    "        return len(self.__entries)\n",
    "\n",
    "book = PhoneBook()\n",
    "book.add(\"Mustermann\", \"1234\")\n",
    "book.add(\"Mueller\", \"9876\")\n",
    "\n",
    "print(book)      #für str-Funktion\n",
    "book             #für repr-Funktion\n",
    "print(len(book)) # für len-Funktion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 11. Exceptions\n",
    "Während der Laufzeit eines Programms können Fehler auftreten. Damit das Programm dadurch nicht abgebrochen wird, kann man mit Exceptions (**try:** und **except:** Blöcke) arbeiten. Ein Code kann mehrere **except**-Blöcke enthalten. Es können auch eigene Fehlercodes programmiert werden.<br>\n",
    "Fehlercodes sollten nur in den seltensten Fällen benutzt werden!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Durch null teilen ist nicht erlaubt!\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    print(5 / 0)                       # durch Null teilen ist nicht definiert -> Fehler\n",
    "    print(4)                           # alles nach dem Fehler wird nicht ausgeführt\n",
    "except ZeroDivisionError:              # tritt ein bestimmter Fehler auf wird der except-Block asugeführt\n",
    "    print(\"Durch null teilen ist nicht erlaubt!\")\n",
    "print(5)                               # alles nach dem except Block wird wieder ausgeführt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Eigene Fehler auslösen\n",
    "Über den **raise**-Befehl können eigene Fehler ausgelöst werden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bitte gebe eine gültige E-Mail ein\n"
     ]
    }
   ],
   "source": [
    "class InvalidEmailError(Exception):\n",
    "    pass\n",
    "\n",
    "def send_mail(email, subject, content):\n",
    "    if not \"@\" in email:\n",
    "        raise InvalidEmailError(\"email does not contain an @\")\n",
    "try:     \n",
    "    send_mail(\"hallo\", \"Betreff\", \"Inhalt\")\n",
    "except InvalidEmailError:\n",
    "    print(\"Bitte gebe eine gültige E-Mail ein\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Code abschließen\n",
    "Der **finally**-Befehl wird bei jedem Programmdurchlauf ausgeführt, auch wenn zuvor Fehler aufgetreten sind."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Durch null teilen ist nicht erlaubt!\n",
      "Schluss\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    print(5 / 0)\n",
    "except ZeroDivisionError:\n",
    "    print(\"Durch null teilen ist nicht erlaubt!\")\n",
    "finally:\n",
    "    print(\"Schluss\")"
   ]
  }
 ],
 "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}