Add files via upload

Expertenwissen.ipynb

@@ -0,0 +1,777 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Funktionsparameter benennen\n",
+    "Funktionen enthalten Parameter mit denen Sie arbeiten können/müssen. Diese Parameter können vorgegeben werden oder jedes mal übergeben. Mit Standardparametern kann man vorgegebene Parameter übergeben, diese aber auch einfach durch andere Parameter abändern."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Hallo\n",
+      "Hallo\n",
+      "Welt\n",
+      "Welt\n",
+      "Welt\n"
+     ]
+    }
+   ],
+   "source": [
+    "def multi_print(nummer = 1, word = \"Hallo\"):\n",
+    "    for i in range(0, nummer):\n",
+    "        print(word)\n",
+    "        \n",
+    "multi_print(2) # Parameter 'Nummer' wird auf 5 gesetzt. 'Hallo' wird beibehalten\n",
+    "multi_print(word = \"Welt\", nummer = 3) # Parameter 'Welt' und '5' werden übergeben"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Daten Sortieren\n",
+    "Daten können über Python-integrierte Funktionen sortiert werden. Nützlich ist die **sort**-Methode.<br>\n",
+    ".sort() sortiert nach dem Alphabet"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['Erik', 'Franziska', 'Max', 'Monika']\n"
+     ]
+    }
+   ],
+   "source": [
+    "l = [\"Max\", \"Monika\", \"Erik\", \"Franziska\"]\n",
+    "l.sort()\n",
+    "print(l)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    ".sort können auch einige Paramter zum sortieren übergeben werden: reverse (umgekehrt), Schlüssel (wonach sortieren), ..."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['Monika', 'Max', 'Franziska', 'Erik']\n"
+     ]
+    }
+   ],
+   "source": [
+    "l = [\"Max\", \"Monika\", \"Erik\", \"Franziska\"]\n",
+    "l.sort(reverse=True)\n",
+    "print(l)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['Max', 'Erik', 'Monika', 'Franziska']\n"
+     ]
+    }
+   ],
+   "source": [
+    "l = [\"Max\", \"Monika\", \"Erik\", \"Franziska\"]\n",
+    "l.sort(key=len)\n",
+    "print(l)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Achtung! .sorted() gibt eine Liste zurück; auch wenn ein Dictionarie sortiert werden soll."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['Saigon', 'Köln', 'Budapest']\n"
+     ]
+    }
+   ],
+   "source": [
+    "d = {\"Köln\": \"CGN\", \"Budapest\": \"BUD\", \"Saigon\": \"SGN\"}\n",
+    "\n",
+    "print(sorted(d, reverse = True))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "mit sorted() wird eine neue Liste mit den Parameter erstellt, ohne die bestehende Liste zu überschreiben"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['Erik', 'Franziska', 'Max', 'Monika']\n",
+      "['Max', 'Monika', 'Erik', 'Franziska']\n",
+      "['Erik', 'Franziska', 'Max', 'Monika']\n"
+     ]
+    }
+   ],
+   "source": [
+    "l = [\"Max\", \"Monika\", \"Erik\", \"Franziska\"]\n",
+    "print( sorted(l) )\n",
+    "print(l)\n",
+    "l.sort()\n",
+    "print(l)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Lambda Funktion\n",
+    "kurze Schreibweise um eine Funktion als Parameter übergeben"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[('Franziska', 1), ('Monika', 2), ('Max', 3), ('Erik', 3)]\n"
+     ]
+    }
+   ],
+   "source": [
+    "students = [\n",
+    "    (\"Max\", 3),\n",
+    "    (\"Monika\", 2),\n",
+    "    (\"Erik\", 3),\n",
+    "    (\"Franziska\", 1)\n",
+    "]\n",
+    "\n",
+    "students.sort(key=lambda student: student[1])\n",
+    "print(students)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "1"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "f = lambda student: student[1]\n",
+    "f((\"Max\", 1))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Durchsuchen mit Regulären Ausdrücken \n",
+    "Reguläre Ausdrücke erlauben, Strings flexibel durchsuchen zu können. Mehr infos unter [RegExr](https://regexr.com/)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['13', '24', '8']"
+      ]
+     },
+     "execution_count": 29,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import re\n",
+    "sentence = \"Meine 13 Katzen benötigen 24 Kilo Katzenfutterutter und 8 Liter Wasser undsoweiter.\"\n",
+    "re.findall(\"[0-9]+\", sentence) "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<_sre.SRE_Match object; span=(6, 8), match='13'>"
+      ]
+     },
+     "execution_count": 30,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "re.search(\"[0-9]+\", sentence)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "<_sre.SRE_Match object; span=(6, 8), match='13'>\n",
+      "<_sre.SRE_Match object; span=(6, 8), match='13'>\n",
+      "<_sre.SRE_Match object; span=(9, 15), match='Katzen'>\n",
+      "<_sre.SRE_Match object; span=(9, 14), match='Katze'>\n",
+      "<_sre.SRE_Match object; span=(52, 55), match='und'>\n"
+     ]
+    }
+   ],
+   "source": [
+    "print( re.search(\"[0123456789]+\", sentence)) # lange Form\n",
+    "print( re.search(\"[0-9]+\", sentence))       # kurze Form aller Zahlen\n",
+    "print( re.search(\"Katzen+\", sentence))\n",
+    "print( re.search(\"Katze?\", sentence))\n",
+    "print( re.search(\"und*\", sentence))\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Datum\n",
+    "Zur Darstellung von Datumswerten gibt es in Python das datetime-Modul (https://docs.python.org/3/library/datetime.html). Damit können Datumswerte repräsentiert und damit gerechnen werden."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2019-03-16 10:58:09.805770\n"
+     ]
+    }
+   ],
+   "source": [
+    "from datetime import datetime\n",
+    "now = datetime.now()    # Über datetime.now() ein Datumsobjekt zum aktuellen Datum erstellen\n",
+    "print(now)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2019-12-11 10:09:08\n"
+     ]
+    }
+   ],
+   "source": [
+    "#über ein spezifisches Datum (hier: 20.8.2017, 20:00:00):\n",
+    "day = datetime(2019, 12, 11, 10, 9, 8)\n",
+    "print(day)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Aud die Datumsobjekte kann über Selektoren auf einzelne Angaben direkt Zugegriffen werden."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Jahr = 2019\n",
+      "Monat = 12\n",
+      "Tag = 11\n",
+      "Stunde = 10\n",
+      "Minute = 9\n",
+      "Sekunde = 8\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"Jahr = \" + str(day.year))\n",
+    "print(\"Monat = \" + str(day.month))\n",
+    "print(\"Tag = \" + str(day.day))\n",
+    "print(\"Stunde = \" + str(day.hour))\n",
+    "print(\"Minute = \" + str(day.minute))\n",
+    "print(\"Sekunde = \" + str(day.second))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Die `.timestamp()`-Methode gibt den entsprechenden Unix-Timestamp zu einem bestimmten Datumswert zurück. Unix-Timestamp ist eine Zahl, die die Sekunden seit dem 01.01.1970 hochzählt.\n",
+    "\n",
+    "Vorteil bei einem Unix-Timestamp ist, dass dieser kompakt gespeichert werden kann. Intern muss der Computer dadurch nur eine Zahl speichern, um einen Datumswert zu repräsentieren."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "23325058.19423008\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(day.timestamp() - now.timestamp()) # Zeitunterschied in Sekunden"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### `date`- und `time`- Angaben\n",
+    "Das `datetime`-Paket stellt weitere Klassen zur Verfügung, die für Datumsangaben verwendet werden können.\n",
+    "- `datetime`: Datumsangabe + Zeitangabe\n",
+    "- `date`: Nur Datumsangabe\n",
+    "- `time`: Nur Zeitangabe"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from datetime import date, time"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2017-08-20\n"
+     ]
+    }
+   ],
+   "source": [
+    "d = date(2017, 8, 20)\n",
+    "print(d)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "20:01:04\n"
+     ]
+    }
+   ],
+   "source": [
+    "t = time(20, 1, 4)\n",
+    "print(t)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Datumswerte können auch vergleicht werden.\n",
+    "Beachte, wie bei den Ojekten die Datumsangabe als auch die Zeitangabe übereinstimmen müssen\n",
+    "\n",
+    "- `datetime`: Datumsangabe + Zeitangabe müssen übereinstimmen\n",
+    "- `date`: Datumsangabe muss übereinstimmen\n",
+    "- `time`: Zeitangabe muss übereinstimmen"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "True\n",
+      "False\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(date(2018, 7, 6) == date(2018, 7, 6))\n",
+    "print(datetime(2018, 12, 11, 10, 9, 8) == datetime(2018, 12, 11, 10, 9, 0))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### `datetime` in `date` und `time` umwandeln\n",
+    "`datetime`-Objekt können in ein `date` und ein `time`-Objekt zerlegt werden."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "20:00:00\n",
+      "2017-08-20\n"
+     ]
+    }
+   ],
+   "source": [
+    "dt = datetime(2017, 8, 20, 20, 0, 0)\n",
+    "print(dt.time())\n",
+    "print(dt.date())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### `date` und `time` in `datetime` umwandeln\n",
+    "`datetime`-Objekt können aus einem `date` und einem `time`-Objekt zusammengesetzt werden."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2017-08-20 20:30:00\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(datetime.combine(date(2017, 8, 20), time(20, 30, 0)))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Datumswerte ausgeben\n",
+    "Dokumentation: https://docs.python.org/3/library/datetime.html#strftime-strptime-behavior\n",
+    "Es ist wichtig, Datumswerte auch richtig auszugeben."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2019-03-16 11:08:41.295840\n"
+     ]
+    }
+   ],
+   "source": [
+    "from datetime import datetime\n",
+    "now = datetime.now()\n",
+    "print(now)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "16.03.2019\n",
+      "2019-03-16\n",
+      "20190316\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(now.strftime(\"%d.%m.%Y\"))\n",
+    "print(now.strftime(\"%Y-%m-%d\"))\n",
+    "print(now.strftime(\"%Y%m%d\"))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Datumswerte einlesen\n",
+    "Datumswerte können auch aus einem String extrahiert werden."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2017-07-18 00:00:00\n"
+     ]
+    }
+   ],
+   "source": [
+    "d = \"18.07.2017\"\n",
+    "print(datetime.strptime(d, \"%d.%m.%Y\"))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Zeitdifferenzen: Rechnen mit Datumswerten"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2019-03-16 11:09:45.018845\n",
+      "2019-04-05 15:12:46.018845\n"
+     ]
+    }
+   ],
+   "source": [
+    "from datetime import datetime, timedelta\n",
+    "now = datetime.now()\n",
+    "print(now)\n",
+    "print(now + timedelta(days = 20, hours = 4, minutes = 3, seconds = 1))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "-1 day, 12:50:14.981155\n"
+     ]
+    }
+   ],
+   "source": [
+    "day = datetime(2019, 2, 16)\n",
+    "td = day - now\n",
+    "print(td)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2018-12-31 12:50:14.981155\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(datetime(2019, 1, 1) + td)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Das DefaultDict-Modul\n",
+    "\n",
+    "Das DefaultDict-Modul stellt eine ganz besondere Funktionalität zur Verfügung: Du kannst damit ein Dictionary erstellen, welches sich mehr oder weniger automatisch mit initialen Werten befüllt!\n",
+    "\n",
+    "Das möchten wir uns natürlich mal anschauen:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from collections import defaultdict"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "generate() wurde aufgerufen!\n",
+      "defaultdict(<function generate at 0x000001757CEF7EA0>, {'existiertNicht': 5})\n"
+     ]
+    }
+   ],
+   "source": [
+    "def generate():\n",
+    "    print(\"generate() wurde aufgerufen!\")\n",
+    "    return 0\n",
+    "\n",
+    "d = defaultdict(generate)\n",
+    "\n",
+    "d[\"existiertNicht\"] = d[\"existiertNicht\"] + 5\n",
+    "print(d)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "defaultdict(<class 'int'>, {'Hallo': 2, 'Welt': 1})\n"
+     ]
+    }
+   ],
+   "source": [
+    "p = defaultdict(int)\n",
+    "words = [\"Hallo\", \"Hallo\", \"Welt\"]\n",
+    "\n",
+    "for word in words:               # für jedes neue Wort wird defaultdict aufgerufen und ein eintrag erstellt\n",
+    "    p[word] = p[word] + 1        # für jedes wiederholte Wort wird der Wert um 1 erhöht\n",
+    "\n",
+    "print(p)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "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
+}

Python-Syntax.ipynb

@@ -4,9 +4,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# Python Syntax\n",
+    "# Python Syntax"
-    "Hinweise zum Lesen:\n",
-    "    - Nach dem Code-Block ist jeweils die Konsolen-Ausgabe sichtbar"
    ]
   },
   {
@@ -214,6 +212,311 @@
     "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": {},
@@ -343,22 +646,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Wie ist dein Name?\n",
+      "Wie ist dein Name? Alex\n",
-      "Alex\n",
       "Hallo Alex\n"
      ]
     }
    ],
    "source": [
-    "print('Wie ist dein Name?')   # ask for their name\n",
+    "myName = input(\"Wie ist dein Name? \") # eine Zeile mit Eingabe wird geöffnet, der String wird davor ausgegeben\n",
-    "myName = input() # eine Zeile mit Eingabe wird geöffnet\n",
     "print('Hallo {}'.format(myName))"
    ]
   },
@@ -1689,8 +1990,8 @@
    "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",
+    "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 Dopplungen aus deinem Code zu geben!\n",
+    "Beachte, der Funktion oder ihren Variablen keine Namens-Dopplungen aus deinem Code zu geben!\n",
     "\n",
     "### Funktionen definieren und Aufrufen\n",
     "\n",
@@ -1725,8 +2026,9 @@
    "metadata": {},
    "source": [
     "### Funktionen können auch mit einem oder mehreren Argumenten arbeiten\n",
-    "def Funktionname(Argument):<br>\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",
-    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Code"
+    "**def** Funktionname(Argument):<br>\n",
+    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;**Code**"
    ]
   },
   {
@@ -1772,6 +2074,40 @@
     "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": {},
@@ -2685,12 +3021,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# 12. Datenstrukturen\n",
+    "# 12. Expertenwissen\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",
-    "- Set: Ungeordnete Sammlung von Elementen, deren Elemente innerhalb nur einmal vorkommen dürfen\n",
-    "- PriorityQueue (Prioritätswarteschlange): Automatische Sortierung der Elemente"
    ]
   },
   {

bmi.py

@@ -0,0 +1,12 @@
+# Calculate your Body-Mass-Index with Python
+print("BMI - Calculator!")
+
+weight_str = input("Please insert your weight (in kg): ")
+height_str = input("Please insert your bodys height(in m): ")
+
+weight = float(weight_str.replace(",", "."))
+height = float(height_str.replace(",", "."))
+
+bmi = weight / height ** 2
+
+print("Your BMI is: " + str(round(bmi, 1)))