Python-Intro/Python-Syntax.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Syntax\n",
    "Hinweise zum Lesen:\n",
    "    - Nach dem Code-Block ist jeweils die Konsolen-Ausgabe sichtbar"
   ]
  },
  {
   "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": [
    "## Daten Typen\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": [
    "### 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": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wie ist dein Name?\n",
      "Alex\n",
      "Hallo Alex\n"
     ]
    }
   ],
   "source": [
    "print('Wie ist dein Name?')   # ask for their name\n",
    "myName = input() # eine Zeile mit Eingabe wird geöffnet\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. Listen\n",
    "Listen können mehrere Elemente enthalten und sind veränderliche Datenstruktur.<br>\n",
    "**Listenname = [\"Element1\", Element2\", ... ]**"
   ]
  },
  {
   "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": [
    "# 3. Daten umwandeln\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Einen String in eine Ganzzahl umwandeln\n",
    "**int()**-Befehl auf einen String: **int(string)**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "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": 29,
   "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": 30,
   "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": 31,
   "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\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": 32,
   "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": 33,
   "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": 34,
   "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": 35,
   "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": 36,
   "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": 37,
   "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": 38,
   "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": 39,
   "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": 40,
   "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": 41,
   "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": 42,
   "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": 43,
   "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": 44,
   "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": 45,
   "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": 46,
   "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 t´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 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": 47,
   "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",
    "def Funktionname(Argument):<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "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": 49,
   "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": [
    "### Ineinander verschachtelte Funktionen sind auch möglich"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "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": 51,
   "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": 52,
   "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": 53,
   "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. Dictionaries\n",
    "Die Verknüpfung verschiedener Strings und Listen wird mit Dictionaries erfolgen. Dictionaries werden mit **{\"Schlüssel:Zuweisung}** aufgebaut"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "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": 55,
   "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",
    "    print(key + \" : \" + wert)    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Listen in Dictionaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['BER', 'Berlin']\n"
     ]
    }
   ],
   "source": [
    "staedte = {\n",
    "    \"München\": [\"MUC\", \"Bayern\"],\n",
    "    \"Berlin\": [\"BER\", \"Berlin\"]\n",
    "}\n",
    "print(staedte[\"Berlin\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 9. Tupel\n",
    "Ähnlich zu Listen, jedoch unveränderliche Datenstruktur."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "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",
    "print(t)      # abrufen des gesamten Tupel\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": 58,
   "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": 59,
   "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": [
    "# 10. 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": 3,
   "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": 4,
   "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": 5,
   "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": 6,
   "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": 7,
   "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": null,
   "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": null,
   "metadata": {},
   "outputs": [],
   "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": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "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": 61,
   "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": 19,
   "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": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "200\n",
      "{'Date': 'Sun, 10 Mar 2019 10:06:34 GMT', 'Expires': '-1', 'Cache-Control': 'private, max-age=0', 'Content-Type': 'text/html; charset=ISO-8859-1', 'P3P': 'CP=\"This is not a P3P policy! See g.co/p3phelp for more info.\"', 'Content-Encoding': 'gzip', 'Server': 'gws', 'Content-Length': '5434', 'X-XSS-Protection': '1; mode=block', 'X-Frame-Options': 'SAMEORIGIN', 'Set-Cookie': '1P_JAR=2019-03-10-10; expires=Tue, 09-Apr-2019 10:06:34 GMT; path=/; domain=.google.de, NID=162=hj9rxv-Nn8TIZUhSheNrRj0Jdo-Z_UkDlz9QadH8cnTTxQo-doOCClFPhDQfJe2phQCuVLI2qgDasKfuuXwxZ1COXvS8iE7moTbTI2AHnKVJrrfyhsuz9_hKOkoiZ1bkG1-15qe1lt_Vi3vktyz8R4dpVdOUGTOlsy43lpLvuhY; expires=Mon, 09-Sep-2019 10:06:34 GMT; path=/; domain=.google.de; HttpOnly'}\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": 12,
   "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": 18,
   "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": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 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": 8,
   "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": 62,
   "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": 63,
   "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": 64,
   "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": 65,
   "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": 66,
   "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": 67,
   "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": 68,
   "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": 69,
   "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": 70,
   "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": []
  }
 ],
 "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
}