kap_oo.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Vector:\n",
    "    def __init__(self, *args):\n",
    "        self.values = args"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin vec_new`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<__main__.Vector at 0x5796610>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = Vector(1, 5)  # Anlegen der Instanz\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 5)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.values  # Lesen der Instanz-Variable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Vector:\n",
    "    def __init__(self, *args):\n",
    "        self.values = args\n",
    "        \n",
    "    def __str__(self):\n",
    "        return \"Vector\" + str(self.values)\n",
    "    \n",
    "    def __repr__(self):\n",
    "        return str(self)\n",
    "    \n",
    "    def add(self, other):\n",
    "        # Beide Vektoren müssen die gleiche Dimension haben\n",
    "        assert len(self.values) == len(other.values)\n",
    "        result = []\n",
    "        # zip(a, b) gibt pro Iteration immer ein zusammengehöriges Paar\n",
    "        # von Werten aus beiden Listen zurück\n",
    "        for val1, val2 in zip(self.values, other.values):\n",
    "            result.append(val1 + val2)\n",
    "        return Vector(*result)\n",
    "    \n",
    "    def scale(self, scalar):\n",
    "        result = []\n",
    "        for val in self.values:\n",
    "            result.append(scalar * val)\n",
    "        return Vector(*result)\n",
    "    \n",
    "    def dot(self, other):\n",
    "        assert len(self.values) == len(other.values)\n",
    "        result = 0\n",
    "        for val1, val2 in zip(self.values, other.values):\n",
    "            result += val1 * val2\n",
    "        return result\n",
    "    \n",
    "    def __add__(self, other):\n",
    "        return self.add(other)\n",
    "    \n",
    "    def __mul__(self, other):\n",
    "        if isinstance(other, Vector):\n",
    "            return self.dot(other)\n",
    "        else:\n",
    "            return self.scale(other)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin vec_def --input_prefix \"\"`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#!class Vector:\n",
    "#!    def __init__(self, *args):\n",
    "#!        self.values = args"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin vec_str --input_prefix \"\"`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#!class Vector:\n",
    "#!    ...\n",
    "#!    def __str__(self):\n",
    "#!        return \"Vector\" + str(self.values)\n",
    "    \n",
    "#!    def __repr__(self):\n",
    "#!        return str(self)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin vec_methods --input_prefix \"\"`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#!class Vector:\n",
    "#!    ...\n",
    "#!    def add(self, other):\n",
    "#!        # Beide Vektoren müssen die gleiche Dimension haben\n",
    "#!        assert len(self.values) == len(other.values)\n",
    "#!        result = []\n",
    "#!        # zip(a, b) gibt pro Iteration immer ein zusammengehöriges Paar\n",
    "#!        # von Werten aus beiden Listen zurück\n",
    "#!        for val1, val2 in zip(self.values, other.values):\n",
    "#!            result.append(val1 + val2)\n",
    "#!        return Vector(*result)\n",
    "#!    \n",
    "#!    def scale(self, scalar):\n",
    "#!        result = []\n",
    "#!        for val in self.values:\n",
    "#!            result.append(scalar * val)\n",
    "#!        return Vector(*result)\n",
    "#!    \n",
    "#!    def dot(self, other):\n",
    "#!        assert len(self.values) == len(other.values)\n",
    "#!        result = 0\n",
    "#!        for val1, val2 in zip(self.values, other.values):\n",
    "#!            result += val1 * val2\n",
    "#!        return result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin vec_overloading --input_prefix \"\"`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "#!class Vector:\n",
    "#!    ...\n",
    "#!    def __add__(self, other):\n",
    "#!        return self.add(other)\n",
    "#!    \n",
    "#!    def __mul__(self, other):\n",
    "#!        if isinstance(other, Vector):\n",
    "#!            return self.dot(other)\n",
    "#!        else:\n",
    "#!            return self.scale(other)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin vec_test`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Vector(4, 6)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Vector(1, 2).add(Vector(3, 4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Vector(5.5, 11.0)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Vector(1, 2).scale(5.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Vector(1, 2).dot(Vector(3, 4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin omnivore --input_prefix \"\"`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def omnivore(*args, **kwargs):\n",
    "    print(\"args=\", args)\n",
    "    print(\"kwargs=\", kwargs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin omnivore_call`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "args= ('one', 2)\n",
      "kwargs= {'three': 'four', 'five': 6}\n"
     ]
    }
   ],
   "source": [
    "omnivore(\"one\", 2, three=\"four\", five=6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin add_user --input_prefix \"\"`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_user(name, country, address=None, birthday=None, phone=None):\n",
    "    for string, val in zip([\"Name\", \"Country\", \"Address\", \"Birthday\", \"Phone\"],\n",
    "                           [name, country, address, birthday, phone]):\n",
    "        print(string + \": \" + str(val))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin add_user_call`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: Peter Pan\n",
      "Country: Nimmerland\n",
      "Address: None\n",
      "Birthday: 1902-11-01\n",
      "Phone: None\n"
     ]
    }
   ],
   "source": [
    "required = [\"Peter Pan\", \"Nimmerland\"]\n",
    "optional = {\"birthday\": \"1902-11-01\"}\n",
    "add_user(*required, **optional)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin vec_overloading_test`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Vector(9, 13)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Vector(1, 1) + Vector(2, 3) * 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin vec3d_def --input_prefix \"\"`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Vector3D(Vector):    \n",
    "    # 3D Vektor akzeptiert nur drei Komponenten\n",
    "    def __init__(self, x, y, z):\n",
    "        # Konstruktor der Elternklasse aufrufen\n",
    "        super().__init__(x, y, z)\n",
    "        \n",
    "    def x(self):\n",
    "        # Zugriff auf Attribute in Elternklasse\n",
    "        return self.values[0]\n",
    "    def y(self):\n",
    "        return self.values[1]\n",
    "    def z(self):\n",
    "        return self.values[2]\n",
    "    \n",
    "    def cross(self, other):\n",
    "        assert isinstance(other, Vector3D)\n",
    "        return Vector3D(self.y() * other.z() - self.z() * other.y(),\n",
    "                        self.z() * other.x() - self.x() * other.z(),\n",
    "                        self.x() * other.y() - self.y() * other.x())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin vec3d_test`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Vector(0, 0, 1)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Kreuzprodukt von Einheitsvektoren in x- und y-Richtung\n",
    "# ergibt Einheitsvektor in z-Richtung\n",
    "Vector3D(1, 0, 0).cross(Vector3D(0, 1, 0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exceptions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin try_dice --input_prefix \"\" --output_prefix \">> \"`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wie viele Würfel möchten Sie werfen?\n",
      " rosinenbrötchen\n",
      "Ungültige Eingabe. Versuchen Sie es erneut.\n",
      "Wie viele Würfel möchten Sie werfen?\n",
      " 12\n",
      "Ergebnisse: 6, 2, 1, 3, 4, 3, 1, 1, 2, 4, 6, 5\n",
      "Summe: 38\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "#!nr_dice = None\n",
    "# Frage Nutzer so lange, bis eine gültige Eingabe kommt\n",
    "#!while nr_dice is None:\n",
    "#!    print(\"Wie viele Würfel möchten Sie werfen?\")\n",
    "#!    try:\n",
    "        # int(...) kann schiefgehen, deswegen sicher in try...except einpacken\n",
    "#!        nr_dice = int(input())\n",
    "#!    except ValueError:\n",
    "#!        print(\"Ungültige Eingabe. Versuchen Sie es erneut.\")\n",
    "\n",
    "# Berechne Würfelergebnisse\n",
    "#!dice_results = [random.randint(1, 6) for i in range(nr_dice)]\n",
    "#!dice_sum = sum(dice_results)\n",
    "#!print(\"Ergebnisse:\", \", \".join(str(result) for result in dice_results))\n",
    "#!print(\"Summe:\", dice_sum)\n",
    "print(\"Wie viele Würfel möchten Sie werfen?\\n rosinenbrötchen\\nUngültige Eingabe. Versuchen Sie es erneut.\\nWie viele Würfel möchten Sie werfen?\\n 12\\nErgebnisse: 6, 2, 1, 3, 4, 3, 1, 1, 2, 4, 6, 5\\nSumme: 38\") #!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin raise_dice --input_prefix \"\"`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "class NotAnIntError(Exception):\n",
    "    def __init__(self, value):\n",
    "        self.value = value\n",
    "class InvalidAmountError(Exception):\n",
    "    pass  # Keine Anpassungen nötig\n",
    "\n",
    "def str_to_amount(amount_str):\n",
    "    try:\n",
    "        amount = int(amount_str)\n",
    "    except ValueError:\n",
    "        raise NotAnIntError(amount_str)\n",
    "    if amount < 1:\n",
    "        raise InvalidAmountError(Exception)\n",
    "    return amount"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin dice_new_loop --input_prefix \"\" --output_prefix \">> \"`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wie viele Würfel möchten Sie werfen?\n",
      " sauerbraten\n",
      "Ungültige Eingabe 'sauerbraten'. Bitte geben Sie eine ganze Zahl ein!\n",
      "Wie viele Würfel möchten Sie werfen?\n",
      " -8\n",
      "Anzahl der Würfe muss mindestens eins sein.\n",
      "Wie viele Würfel möchten Sie werfen?\n",
      " 6\n",
      "Ergebnisse: 6, 1, 5, 5, 6, 3\n",
      "Summe: 26\n"
     ]
    }
   ],
   "source": [
    "#!import random\n",
    "\n",
    "#!nr_dice = None\n",
    "#!while nr_dice is None:\n",
    "#!    print(\"Wie viele Würfel möchten Sie werfen?\")\n",
    "#!    try:\n",
    "#!        nr_dice = str_to_amount(input())\n",
    "#!    except NotAnIntError as e:  # Exception-Objekt in Variable e speichern\n",
    "#!        print(f\"Ungültige Eingabe '{e.value}'. Bitte geben Sie eine ganze Zahl ein!\")\n",
    "#!    except InvalidAmountError:\n",
    "#!        print(\"Anzahl der Würfe muss mindestens eins sein.\")\n",
    "\n",
    "#!dice_results = [random.randint(1, 6) for i in range(nr_dice)]\n",
    "#!dice_sum = sum(dice_results)\n",
    "#!print(\"Ergebnisse: \" + \", \".join(str(result) for result in dice_results))\n",
    "#!print(\"Summe: \" + str(dice_sum))\n",
    "print(\"Wie viele Würfel möchten Sie werfen?\\n sauerbraten\\nUngültige Eingabe 'sauerbraten'. Bitte geben Sie eine ganze Zahl ein!\\nWie viele Würfel möchten Sie werfen?\\n -8\\nAnzahl der Würfe muss mindestens eins sein.\\nWie viele Würfel möchten Sie werfen?\\n 6\\nErgebnisse: 6, 1, 5, 5, 6, 3\\nSumme: 26\")  #!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# List Comprehensions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin lc_1_classic`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['0', '0', '1', '4', '11', '24', '50', '80', '154', '220']\n"
     ]
    }
   ],
   "source": [
    "numbers = [0, 0, 1, 4, 11, 24, 50, 80, 154, 220]\n",
    "numbers_str = []\n",
    "for n in numbers:\n",
    "    numbers_str.append(str(n))\n",
    "print(numbers_str)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin lc_1`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['0', '0', '1', '4', '11', '24', '50', '80', '154', '220']\n"
     ]
    }
   ],
   "source": [
    "# Für jede Zahl n aus numbers werte die Funktion str(n) aus\n",
    "numbers_str = [str(n) for n in numbers]\n",
    "print(numbers_str) #!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0 | 0 | 1 | 4 | 11 | 24 | 50 | 80 | 154 | 220'"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Strings in Liste mit Trennzeichen verbinden\n",
    "\" | \".join(numbers_str)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin lc_2`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 15, 16, 17, 18, 19]\n"
     ]
    }
   ],
   "source": [
    "#![n for n in range(1, 100) if \"4\" not in str(n)]\n",
    "allowed_room_numbers = [n for n in range(1, 20) if \"4\" not in str(n)] #!\n",
    "print(allowed_room_numbers)  #!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin lc_3`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "movies = [(\"Citizen Kane\", \"1941-09-04\"), (\"The Godfather\", \"1972-03-11\"), (\"Rear Window\", \"1954-09-01\"),\n",
    " (\"Casablanca\", \"1943-01-23\"), (\"Boyhood\", \"2014-07-11\"), (\"Three Colors: Red\", \"1994-11-23\"),\n",
    " (\"Vertigo\", \"1958-05-28\"), (\"Notorious\", \"1946-09-06\"), (\"Singin' in the Rain\", \"1952-04-11\"),\n",
    " (\"City Lights\", \"1931-03-07\")]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['THE GODFATHER', 'CASABLANCA', 'CITY LIGHTS']"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import datetime\n",
    "# Name (in Großbuchstaben) aller Filme, die an einem Samstag Premiere hatten\n",
    "[title.upper() for title, date_str in movies if datetime.date.fromisoformat(date_str).weekday() == 5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin lc_3_alt`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Supervolt All-In-One: 8 Geräte', 'eSPACE IOX: 3 Geräte']"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from datetime import date\n",
    "#!current_date = date.today()   # 12.02.2021\n",
    "current_date = date(2021, 2, 12) #!\n",
    "devices = [(\"Supervolt All-In-One\", 8, \"2019-05-21\"),\n",
    " (\"Technotron 84b\", 2, \"2020-04-25\"),\n",
    " (\"eSPACE IOX\", 3, \"2018-12-10\"),\n",
    " (\"annoScope Series S\", 1, \"2020-04-16\")]\n",
    "[f\"{name}: {amount} Geräte\"\n",
    " for name, amount, last_inspection in devices\n",
    " if (current_date - date.fromisoformat(last_inspection)).days > 365]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Funktionen-Tricks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin fun_type`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "function"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def empty_function():\n",
    "    pass\n",
    "#_\n",
    "type(empty_function)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin def_sys_rhs`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-1.38380744, -0.29095011])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from scipy.integrate import solve_ivp\n",
    "import numpy as np\n",
    "#_\n",
    "def sys_rhs(t, x):\n",
    "    return np.array([x[1], -x[0]])\n",
    "#_\n",
    "# Übergebe sys_rhs als Objekt an Funktion solve_ivp\n",
    "# Argumente: DGL-Funktion, Start-/Endzeit, Startwert\n",
    "res = solve_ivp(sys_rhs, (0, 10), np.array([1, 1]))\n",
    "res.y[:,-1]  # x nach 10 s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin fun_vs_call`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function __main__.matrix_to_fun.<locals>._sys_rhs(t, x)>"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sys_rhs  # Funktionsobjekt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1, -1])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sys_rhs(0, [1, 1])  # Funktionswert"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin rhs_lambda`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "res = solve_ivp(lambda t, x: np.array([x[1], -x[0]]), (0, 10), np.array([1, 1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`begin matrix_to_fun`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-1.38380744, -0.29095011])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Funktion, die aus Systemmatrix eine Funktion mit\n",
    "# Argumenten (t, x) generiert\n",
    "def matrix_to_fun(A):\n",
    "    # Definiere Systemfunktion auf Basis der Matrix\n",
    "    def _sys_rhs(t, x):\n",
    "        return A @ x\n",
    "    \n",
    "    return _sys_rhs # Gib Funktionsobjekt zurück\n",
    "#_\n",
    "# DGL-System als Matrix\n",
    "A = np.array([[0, 1], [-1, 0]])\n",
    "# Konvertiere Matrix in aufrufbare Funktion\n",
    "sys_rhs = matrix_to_fun(A)\n",
    "# Integration der DGL genau wie vorher\n",
    "res = solve_ivp(sys_rhs, (0, 10), np.array([1, 1]))\n",
    "res.y[:,-1]  # x nach 10 s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`"
   ]
  },
  {
   "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}