01_Python_Grundlagen.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Wie Python3 installieren?\n",
    "\n",
    "Am einfachsten zu installieren ist die Anaconda-Distribution, welche nahezu alle relevanten Module und Pakete mitbringt\n",
    "\n",
    "- [Download (macOS)](https://repo.anaconda.com/archive/Anaconda3-2019.10-MacOSX-x86_64.pkg)\n",
    "- [Download (Windows)](https://repo.anaconda.com/archive/Anaconda3-2019.10-Windows-x86_64.exe)\n",
    "- [Download (Linux)](https://repo.anaconda.com/archive/Anaconda3-2019.10-Linux-x86_64.sh)\n",
    "\n",
    "Die Dokumentation ist unter [Getting started with Anaconda](https://docs.anaconda.com/anaconda/user-guide/getting-started/) zu finden."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Wie Python3 verwenden?\n",
    "\n",
    "Mehrere Möglichkeiten:\n",
    "\n",
    "- Direkt innerhalb des Python3-Intepreters\n",
    "- Innerhalb der IPythonshell (ein spezieller Python3-Interpreter)\n",
    "- Programme in .py-Dateien speichern und ausführen\n",
    "- Jupyter Notebooks\n",
    "- Mit einer IDE, z.B. Spyder (kombiniert alle obigen Möglichkeiten)\n",
    "\n",
    "Verwendet man die IDE *Spyder* (in der Anaconda-Distribution enthalten), fällt der Umstieg von MATLAB wohl am einfachsten."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Warum Python?\n",
    "\n",
    "- Vollwertige *high-level* Programmiersprache mit sehr einfacher Syntax\n",
    "\n",
    "- Open Source und umsonst.\n",
    "\n",
    "- Umfangreiche Libraries für nahezu jeden Anwendungszweck.\n",
    "\n",
    "- Leichte Einbindung von C/C++/Fortran für performancekritischen Code, der nicht bereits in Libraries existiert."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Grundlegendes\n",
    "\n",
    "- *Interpretierte Programmiesprache*, d.h. das Programm wird von einem Interpreter ausgeführt.\n",
    "\n",
    "- Indizierung beginnt bei 0 statt bei 1 (Matlab, R, Fortran).\n",
    "\n",
    "- *Dynamisches Typsystem*: Der Typ einer Variable wird erst bei Verwendung überprüft\n",
    "\n",
    "- *Objektorientiert*: **Alles** ist eine Klasse (Datentypen, Funktionen, ...), die verschiedene\n",
    "  Methoden und Attribute enthalten"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "- Jede Zeile enthält genau eine Anweisung\n",
    "\n",
    "- Wird eine Zeile mit einem Backslash `\\` beendet, wird die Anweisung über die nächste Zeile fortgesetzt\n",
    "\n",
    "- **Der Code wird durch eingerückte Blöcke strukturiert (Tabs oder Leerzeichen, aber nicht beides!)**\n",
    "\n",
    "- Anweisungen, welche einen Block einleiten, enden mit einem Doppelpunkt (siehe Funktionen, Schleifen, if-Blöcke)\n",
    "\n",
    "- *Persönliche Empfehlung: Max. 80 Zeichen pro Zeile, Tabs zur Einrückung verwenden.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Regeln für die Namen von Variablen, Funktionen und Klassen\n",
    "\n",
    "- erstes Zeichen muss ein Buchstabe sein\n",
    "- Groß- und Kleinbuchstaben werden unterschieden\n",
    "- Alle Unicodezeichen in UTF-8 Kodierung sind erlaubt\n",
    "- darf nicht einem der Schlüsselwörter entsprechen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Schlüsselwörter:\n",
    "\n",
    "`False`, `None`, `True`, `and`, `as`, `assert`, `break`, `class`, `continue`, `def`, `del`, `elif`, `else`, `except`, `finally`, `for`, `from`, `global`, `if`, `import`, `in`, `is`, `lambda`, `nonlocal`, `not`, `or`, `pass`, `raise`, `return`, `try`, `while`, `with`, `yield`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Nützliche Funktionen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "``` python\n",
    "print(x)   # Zeigt Objekt x\n",
    "type(x)    # Zeige Typ (Klasse) von x\n",
    "help(x)    # Zeige Docstrings bzw. Hilfe zu x\n",
    "dir(x)     # Zeige u.A. Methoden und Attribute von x\n",
    "id(x)      # zeigt die Adresse von x\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Einfache Datentypen\n",
    "\n",
    "- boolsche: `True`, `False`\n",
    "- Ganze Zahlen: `int`\n",
    "- Gleitkommazahlen: `float`\n",
    "- Komplexe Zahlen: `complex`\n",
    "- Zeichenketten / Strings: `str`\n",
    "\n",
    "**Besonderheit: `int` ist nicht limitiert und kann beliebig groß werden.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "a = True          # bool\n",
    "a = 1024          # int\n",
    "a = 0.1           # float\n",
    "a = 2e-1          # float\n",
    "a = 2+4j          # complex\n",
    "a = \"hallo\"       # str\n",
    "b, c, d = 1, 2, 1e-9 # mehrere Zuweisungen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Konsolenausgabe:\n",
    "\n",
    "Dafür wird die `print()` Funktion verwendet. Bezüglich der Formatierung gibt es mehrere Möglichkeiten:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Möglichkeit 1: hallo 1 2 1e-09\nMöglichkeit 2: hallo 1 2 1e-09\nMöglichkeit 3: hallo 1 2 0.00000000100000000000\n"
     ]
    }
   ],
   "source": [
    "print(\"Möglichkeit 1:\", a,b,c,d)\n",
    "print(\"Möglichkeit 2: {} {} {} {}\".format(a,b,c,d))\n",
    "print(f\"Möglichkeit 3: {a} {b} {c} {d:.20f}\") # f-Strings (empfohlen!)"
   ]
  },
  {
   "source": [
    "Mehr Details zu den f-Strings [hier](https://realpython.com/python-f-strings/)."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Datencontainer\n",
    "\n",
    "- Liste: `list` (veränderbar)\n",
    "- Tuple: `tuple` (ähnlich zu Listen, aber nicht veränderbar)\n",
    "- dictionary: `dict`\n",
    "- Menge: `set`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "[1, 2, 3, 'hi', -2]\n2\n[1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "# Liste\n",
    "L = [1, 2, 3, \"hi\"]\n",
    "L.append(-2)\n",
    "print(L)\n",
    "print(L[1])\n",
    "print(L[0:3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "(1, 2, 3, 'hi')\n"
     ]
    }
   ],
   "source": [
    "# Tuple\n",
    "t = (1,2, 3, \"hi\")\n",
    "print(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Module\n",
    "\n",
    "Module stellen Klassen, Funktionen, Objekte, Konstanten usw. zur Verfügung und müssen vor ihrer Verwendung importiert werden. Mögliche Formen:\n",
    "\n",
    "``` python\n",
    "import modulname                       # Möglichkeit 1\n",
    "import modulname as alias              # Möglichkeit 2\n",
    "from modulname import bsp              # Möglichkeit 3\n",
    "from modulname import bsp as bsp_alias # Möglichkeit 4\n",
    "```\n",
    "\n",
    "Für uns wichtige Module: [numpy](https://docs.scipy.org/doc/numpy/reference/), [scipy](https://docs.scipy.org/doc/scipy/reference/), [matplotlib](https://matplotlib.org/)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Arithmetische Operationen\n",
    "\n",
    "Für Zahlen (ganzzahlig oder gleitkomma) $a$ und $b$ sind u.A. die folgenden arithmetischen Operatoren definiert:\n",
    "\n",
    "``` python\n",
    "c1 = a + b   # Addition\n",
    "c2 = a - b   # Subtraktion\n",
    "c3 = a * b   # Multiplikation\n",
    "c4 = a / b   # Division\n",
    "c5 = a // b  # Ganzzahlige Division\n",
    "c6 = a % b   # Modulo b\n",
    "c7 = a**b    # Potenz\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Zudem gibt es die arithmetischen Zuweisungsoperatoren\n",
    "    \n",
    "``` python\n",
    "a += b     # äquivalent zu a = a + b\n",
    "a -= b     # äquivalent zu a = a - b\n",
    "a *= b     # äquivalent zu a = a * b\n",
    "a /= b     # äquivalent zu a = a / b\n",
    "a %= b     # äquivalent zu a = a % b\n",
    "a //= b    # äquivalent zu a = a // b\n",
    "a **= b    # äquivalent zu a = a ** b\n",
    "```\n",
    "\n",
    "Diese verändern das Variablenobjekt in der Regel *inplace*, also ohne eine Kopie zu erstellen. (Wichtig für numpy.arrays)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Logische Operationen\n",
    "\n",
    "Jede logische Operation hat einen der beiden *boolschen* Rückgabewerte\n",
    "`True` oder `False`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Wertevergleiche\n",
    "\n",
    "``` python\n",
    "== # ist gleich\n",
    "!= # ungleich\n",
    "<  # kleiner als\n",
    "<= # kleiner als oder gleich\n",
    ">  # groesser als\n",
    ">= # groesser als oder gleich\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Logische Operatoren\n",
    "\n",
    "``` python\n",
    "and # logisches und\n",
    "or  # logisches oder\n",
    "not # logisch nicht\n",
    "```\n",
    "\n",
    "#### Identitätsvergleich\n",
    "\n",
    "``` python\n",
    "is\n",
    "is not\n",
    "```\n",
    "\n",
    "#### Mengenzugehörigkeit\n",
    "\n",
    "``` python\n",
    "in\n",
    "not in\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "# Können natürlich miteinander verknüpft werden:\n",
    "print(2 <= 10 and 2 in [1, 2] and type(2) is int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "metadata": {},
     "execution_count": 7
    }
   ],
   "source": [
    "# Chained comparison möglich\n",
    "1 <= 2 <= 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Kontrollanweisungen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### if-else\n",
    "\n",
    "``` python\n",
    "if <bedingung>:\n",
    "    <anweisung1> # falls <bedingung> wahr\n",
    "    <anweisung2> # falls <bedingung> wahr\n",
    "else:\n",
    "    <anweisung3> # falls <bedingung> nicht wahr\n",
    "```\n",
    "\n",
    "Das `else` ist optional. Zusätzliche sind mehrere `elif` möglich:\n",
    "\n",
    "``` python\n",
    "if <bedingung1>:\n",
    "    <anweisung1> # falls <bedingung1> wahr\n",
    "elif <bedingung2>:\n",
    "    <anweisung2> # falls <bedingung2> wahr\n",
    "else:\n",
    "    <anweisung3> # falls keine der Bedingungen wahr\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Schleifen\n",
    "\n",
    "### for-Schleife\n",
    "\n",
    "``` python\n",
    "for <var> in <iterator>:\n",
    "    <anweisung>\n",
    "```\n",
    "\n",
    "Ein Iterator ist z.B. eine Liste oder ein String."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Moin!\n2\n[20.3, 3]\n"
     ]
    }
   ],
   "source": [
    "for el in [\"Moin!\", 2, [20.3, 3]]:\n",
    "    print(el)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "H\na\nl\nl\no\n"
     ]
    }
   ],
   "source": [
    "for c in \"Hallo\":\n",
    "    print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Wir verwenden hauptsächlich den Iterator `range(a,b,k)`, dieser liefert uns die Zahlen $a$ bis $b-1$ mit der optionalen Schrittweite $k$. Eine negative Schrittweite bedeutet stets rückwärts."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "0\n1\n2\n"
     ]
    }
   ],
   "source": [
    "for i in range(3):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "2\n3\n4\n5\n"
     ]
    }
   ],
   "source": [
    "for i in range(2, 6):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "1\n3\n5\n"
     ]
    }
   ],
   "source": [
    "for i in range(1, 6, 2):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "6\n4\n2\n"
     ]
    }
   ],
   "source": [
    "for i in range(6, 1, -2):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wird die Iterationsvariable innerhalb der Schleife nicht verwendet, kann man auch darauf verzichten:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Moin!\nMoin!\nMoin!\n"
     ]
    }
   ],
   "source": [
    "for _ in range(3):\n",
    "    print(\"Moin!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### while-Schleife\n",
    "\n",
    "Jede for-Schleife lässt sich auch als while-Schleife schreiben:\n",
    "\n",
    "``` python\n",
    "while <bedingung>:\n",
    "    <anweisung>\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "10\n8\n4\n"
     ]
    }
   ],
   "source": [
    "i = 10\n",
    "while i > 0:\n",
    "    if i % 2 == 0 and i not in [2, 6]:\n",
    "        print(i)\n",
    "    i -= 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Sowohl for- als auch while-Schleifen lassen sich mit `continue` und `break` entsprechend steuern:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "for i in range(3):\n",
    "    if i <= 1:\n",
    "        continue # weiter mit nächstem Schleifendurchlauf\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "0\n1\n"
     ]
    }
   ],
   "source": [
    "for i in range(3):\n",
    "    if i == 2:\n",
    "        break  # Abbruch der Schleife\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Eine sehr nützliche Funktion bezüglich Schleifen ist `enumerate`, welche die Elemente unseres Iterators zählt und selbst einen Iterator zurückgibt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Element 0: Moin!\nElement 1: 2\nElement 2: [20.3, 3]\n"
     ]
    }
   ],
   "source": [
    "L = [\"Moin!\", 2, [20.3, 3]]\n",
    "for i, value in enumerate(L):\n",
    "    print(f\"Element {i}: {value}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "0: (0,0)\n1: (1,0)\n2: (0,1)\n3: (4,3)\n"
     ]
    }
   ],
   "source": [
    "Punkte = [(0, 0), (1, 0), (0, 1), (4, 3)]\n",
    "for i, (x, y) in enumerate(Punkte):\n",
    "    print(f\"{i}: ({x},{y})\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Comprehensions\n",
    "\n",
    "Durch eine *List comprehension* lassen sich sehr elegant Listen (durch einen Einzeiler) erstellen. Die Syntax ist ziemlich nahe an die mathematischen Notation einer Menge angelehnt."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Beispiel: Wir wollen $M = \\{ x^2 \\mid x \\in \\mathbb{N},\\, x < 20,\\, x \\mod 3 = 0 \\}$ bestimmen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "[0, 9, 36, 81, 144, 225, 324]\n"
     ]
    }
   ],
   "source": [
    "# for-Schleife :/\n",
    "M1 = []\n",
    "for x in range(20):\n",
    "    if x % 3 == 0:\n",
    "        M1.append(x**2)\n",
    "print(M1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "[0, 9, 36, 81, 144, 225, 324]\n"
     ]
    }
   ],
   "source": [
    "# List comprehension :)\n",
    "M2 = [x**2 for x in range(20) if x % 3 == 0]\n",
    "print(M2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Nicht nur Schleifen, sondern auch List comprehensions lassen sich ineinander verschachteln.\n",
    "Beispiel: $M = \\{ (x, x^2,x^3) \\mid x \\in \\mathbb{N},\\, x < 20,\\, x \\mod 3 = 0 \\}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "[[0, 0, 0], [3, 9, 27], [6, 36, 216], [9, 81, 729], [12, 144, 1728], [15, 225, 3375], [18, 324, 5832]]\n"
     ]
    }
   ],
   "source": [
    "# List comprehension :)\n",
    "M3 = [[x**i for i in range(1, 4)] for x in range(20) if x % 3 == 0]\n",
    "print(M3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "[[0, 0, 0], [3, 9, 27], [6, 36, 216], [9, 81, 729], [12, 144, 1728], [15, 225, 3375], [18, 324, 5832]]\n"
     ]
    }
   ],
   "source": [
    "# Nun mit einer Schleife :/\n",
    "M4 = []\n",
    "for x in range(20):\n",
    "    if x % 3 == 0:\n",
    "        tmp = []\n",
    "        for i in range(1,4):\n",
    "            tmp.append(x**i)\n",
    "        M4.append(tmp)\n",
    "print(M4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "{'key 0': 0, 'key 1': 1, 'key 2': 2, 'key 3': 3, 'key 4': 4}\n"
     ]
    }
   ],
   "source": [
    "# Funktioniert auch für andere Container:\n",
    "# dict comprehension:\n",
    "d = {f'key {i}': i for i in range(5)}\n",
    "print(d)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Funktionen\n",
    "\n",
    "Definition via `def`:\n",
    "\n",
    "``` python\n",
    "def funktionsname(arg1, arg2, ..., argN):\n",
    "    <anweisungen>\n",
    "    return <returnobjekt>\n",
    "```\n",
    "\n",
    "- Das Rückgabeobjekt ist optional. \n",
    "- Eine Funktion ohne `return` gibt das Objekt `None` zurück. \n",
    "- Eine Funktion kann jedes beliebige Objekt (auch Funktionen) zurückgeben.\n",
    "- Funktionen können innerhalb von Funktionen definiert werden"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "moin\nmoin\n<class 'NoneType'>\n"
     ]
    }
   ],
   "source": [
    "# Funktionsdefinition\n",
    "def bsp1(a):\n",
    "    for i in range(a):\n",
    "        print(\"moin\")\n",
    "\n",
    "# Eine Funktion ohne return gibt das Objekt None zurück.\n",
    "r = bsp1(2)\n",
    "print(type(r))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# Funktionsdefinition\n",
    "def bsp2(a, b):\n",
    "    return a+b, a-b # Rückgabe eines Tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "(15, 5)\n15 5\n"
     ]
    }
   ],
   "source": [
    "print(bsp2(10, 5))\n",
    "erg1, erg2 = bsp2(10, 5)\n",
    "print(erg1, erg2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Die Funktionsargumente können auch *default*-Werte haben, welche allerdings nach jenen ohne *default*-Wert stehen müssen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "# t = 0 ist Defaultwert\n",
    "def f(x, t=0):\n",
    "    return x**2+t*x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "1\n6\n6\n"
     ]
    }
   ],
   "source": [
    "print(f(1))\n",
    "print(f(2, t=1))\n",
    "print(f(2, 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Funktionen können auch als Argumente an andere Funktionen übergeben werden:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "2.0000009999243673\n"
     ]
    }
   ],
   "source": [
    "def diff(func, x0, h=1e-6):\n",
    "    return (func(x0+h)-func(x0))/h\n",
    "\n",
    "# Ableitung der Funktion f(x) = x**2 an der Stelle x = 1\n",
    "print(diff(f, 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# `lambda`s\n",
    "\n",
    "Es gibt auch *anonyme Funktionen* ohne eigenen Namen (vergleichbar mit *function handles* in MATLAB oder *lambda expressions* in C++), welche durch das Schlüsselwort `lambda` definiert werden:\n",
    "\n",
    "``` python\n",
    "func_name = lambda arg1, arg2, ..., argN: <funktionsausdruck>\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Diese sind ziemlich nützlich, wenn man Funktionen direkt übergeben möchte ohne sie zu definieren:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "-0.9999989999398551\n"
     ]
    }
   ],
   "source": [
    "# Übergebe direkt die Funktion, die wir Ableiten möchten\n",
    "print(diff(lambda x: 1.0/x, 1.0))"
   ]
  },
  {
   "source": [
    "Oder man Funktionen direkt beim Aufruf wrappen möchte:"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "4.000000999759834\n"
     ]
    }
   ],
   "source": [
    "# Ableitung der Funktion f(x) = x**2+2*x an der Stelle x=1\n",
    "# mit hilfe einer anonymen Funktion\n",
    "print(diff(lambda x: f(x, t=2), 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# `*args`\n",
    "\n",
    "``` python\n",
    "def funktionsname(arg1, *args):\n",
    "    <anweisungen>\n",
    "    return <returnobjekt>\n",
    "```\n",
    "\n",
    "lassen sich (optional) auch beliebig viele Argumente übergeben:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "def h(x, *koeff):\n",
    "    res = 0.0\n",
    "    for i, a in enumerate(koeff):\n",
    "        res += a*x**i\n",
    "    return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "6.0\n"
     ]
    }
   ],
   "source": [
    "# Auswerten des Polynoms 1+2x+3x^2 in x=1\n",
    "print(h(1, 1, 2, 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Man kann dann auch elegant eine Liste oder ein Array von Funktionsargumenten *entpacken*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]\n190.0\n"
     ]
    }
   ],
   "source": [
    "koeffs = list(range(20))\n",
    "print(koeffs)\n",
    "# Auswerten des Polynoms x+2x^2+3x^3+...+19x^19 in x = 1\n",
    "print(h(1, *koeffs))"
   ]
  },
  {
   "source": [
    "Man kann auch in Variablen *entpacken*"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "a0, a1, a2, *_ = koeffs # entpacke a0 = 1, a1 = 1, a2 = 2 und ignoriere Rest\n"
   ]
  }
 ],
 "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.9.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}