03_functions_and_classes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions, Classes and Modules"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions\n",
    "\n",
    "Functions allow us to bundle several instructions into separate units that then can be called from other parts of the program."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def prinHello():\n",
    "    print (\"Hello from within a function\")\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Anschliessend kann die so definierte Funktion im Skript aufgerufen werden:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hallo Funktion\n"
     ]
    }
   ],
   "source": [
    "printHelle()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions are often used to make more complex computations and return a value. This is accomplished by the `return` keyword \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "def three():\n",
    "    return 3\n",
    "\n",
    "result = 3 + three()\n",
    "print (result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Arguments\n",
    "\n",
    "We can handover values to functions using so-called __arguments__ (sometimes also called function parameters) that are then availabe within the scope of the function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "input: 5\n",
      "the result is 8\n"
     ]
    }
   ],
   "source": [
    "def plusThree(number):\n",
    "    print (f\"input: {number}\")\n",
    "    return number + 3\n",
    "\n",
    "result = plusThree(5)\n",
    "print (f\"the result is {result}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Multiple arguments are separated by commas and handeled in the sequence they have been handed over to function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def subtract (first, second):\n",
    "    return first - second\n",
    "subtract(4,5)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "subtract(5,4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Default armgument values\n",
    "Function argument can be defined with default values, that are used as a fallback, when the argument is not provided. This is especially usefull, when many arguments are available to configure specific aspects only in special cases. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n",
      "11\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "def add(firstValue=3, secondValue=5):\n",
    "    return firstValue + secondValue\n",
    "\n",
    "print (add(8,4))\n",
    "print (add(6))\n",
    "print (add())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Argument with keyword names\n",
    "In the `add` function in the cell abavoe not only a default values was providied, but the arguments have gotten names too. This allows to hand over the arguments in an arbitrary order in the form  `argumnent name = value` when calling the function:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add(secondValue = 3, firstValue = 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Arbitrary number of arguments: *args\n",
    "\n",
    "\n",
    "Funktionen können eine beliebige Anzahl von Parametern übergeben werden. Dazu werden in der Definition der Funktion der Argumentvariablen der *Entpack-Operator* `*` vorangestellt. Die Argumente werden dann als Tupel behandelt, die z.B. mit einer Schleife abgehandelt werden können. \n",
    "\n",
    "Wie bei allen anderen Funktionen ist der Argumentnahme frei wählbar, als Konvention hat sich hier der Name `*args` eingebürgert."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Die Funktion wurde mit 4 Argumenten aufgerufen: (1, 3, 4, 5)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "13"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def addiereAlles(*zahlen):\n",
    "    print(f\"Die Funktion wurde mit {len(zahlen)} Argumenten aufgerufen: {zahlen}\" )\n",
    "    ergebnis = 0\n",
    "    for zahl in zahlen:\n",
    "        ergebnis = ergebnis + zahl\n",
    "    return ergebnis\n",
    "\n",
    "addiereAlles(1,3,4,5)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Die Funktion wurde mit 6 Argumenten aufgerufen: (4, 5.6, 0.44, 5, 0.11, -0.33)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "14.819999999999999"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "addiereAlles(4,5.6,0.440,5,0.11,-0.33)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Beliebige Anzahl von benannten Argumenten: **kwargs \n",
    "Ähnlich wie bei Tupeln von `*args` können mit vorangestelltem `**` benannte Argumente __k__ey __w__ord __arg__umente übergeben werden, die per Konvention oft mit `**kwargs` übergeben werden. Die Argumente sind ein Dictionary, und können einzeln oder in einer Schleife verarbeitet werden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Folgende Argumente wurden übergben {'blau': 1, 'rot': 0, 'gruen': 0.5}\n",
      "blau : 1\n",
      "Schlüssel: blau Wert: 1\n",
      "Schlüssel: rot Wert: 0\n",
      "Schlüssel: gruen Wert: 0.5\n"
     ]
    }
   ],
   "source": [
    "def druckfarben(**kwargs):\n",
    "    print (f\"Folgende Argumente wurden übergben {kwargs}\")\n",
    "    # Statt kwargs['blau'] benutzen wir die get(wert, Standardwert)-Methode,\n",
    "    # falls kein Wert \"blau\" übergeben wurde \n",
    "    print (f\"blau : {kwargs.get('blau',0)}\")\n",
    "    for schluessel, wert in kwargs.items():\n",
    "        print (f\"Schlüssel: {schluessel} Wert: {wert}\")\n",
    "\n",
    "druckfarben(blau=1, rot = 0, gruen= 0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Folgende Argumente wurden übergben {'braun': 0}\n",
      "blau : 0\n",
      "Schlüssel: braun Wert: 0\n"
     ]
    }
   ],
   "source": [
    "\n",
    "druckfarben (braun=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Klassen\n",
    "Eine Klasse ist eine Vorlage aus denen Objekte instanziert werden können. Alle Objekte, d.h. Instanzen einer Klasse haben die selben Eigenschaften. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Material:\n",
    "    name = \"ohne Namen\"\n",
    "    dichte = 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Die Instanz einer Klasse als Objekt wird mit dem sog. Konstruktor erzeugt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ohne Namen\n",
      "Buche\n"
     ]
    }
   ],
   "source": [
    "holz = Material()\n",
    "print (holz.name)\n",
    "#dem material einen Namen geben\n",
    "holz.name = \"Buche\"\n",
    "print (holz.name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__class__',\n",
       " '__delattr__',\n",
       " '__dict__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__init__',\n",
       " '__init_subclass__',\n",
       " '__le__',\n",
       " '__lt__',\n",
       " '__module__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__setattr__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__subclasshook__',\n",
       " '__weakref__',\n",
       " 'name',\n",
       " 'wichte']"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(holz)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Funktionen, die innerhalb einer Klasse definiert werden, heißen __Methoden__ und können mit dem Muster `Objektinstanz.Methode()` aufgerufen werden. \n",
    "Methoden haben immer einen ersten Parameter `self` der während des Aufrufs vom Interpreter automatisch gefüllt wird und nicht durch die Programmierenden angegeben werden müssen.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1440"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Material:\n",
    "    name = \"ohne Namen\"\n",
    "    dichte = 0    \n",
    "    def getVolumenGewicht(self, volumen_in_m3):\n",
    "        return volumen_in_m3 * self.dichte\n",
    "\n",
    "buche = Material()\n",
    "buche.name = \"buche\"\n",
    "buche.dichte = 720\n",
    "buche.getVolumenGewicht(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alle Klassen haben automatisch erstellte Standardmethoden, die bei der Klassendefinition selbst definiert werden. Zu den sehr gebräuchelichen Methoden gehört die Methode `__init__`, dem sog. Konstruktor, der bei der Erzeugung eines neuen Objektes ausgeführt wird und initiale Eigenschaften festlegt:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Vererbung "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Anonymus grüßt stumm\n"
     ]
    }
   ],
   "source": [
    "Lassie.gruessen()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Tier:\n",
    "    def gruessen(self):\n",
    "        print (f\"{self.name} grüßt stumm\")\n",
    "    \n",
    "    def __init__(self, name=\"Anonymus\"):\n",
    "        self.name = name\n",
    "   \n",
    "Waldi = Tier(\"Waldi\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Waldi grüßt stumm\n"
     ]
    }
   ],
   "source": [
    "Waldi.gruessen()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [],
   "source": [
    "Hasso = Tier()\n",
    "Lassie = Tier()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [],
   "source": [
    "Lassie.name = \"Lassie\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lassie ist stumm\n"
     ]
    }
   ],
   "source": [
    "Lassie.gruessen()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Hund(Tier):\n",
    "    def gruessen(self):\n",
    "        print(f\"{self.name} bellt!\")\n",
    "\n",
    "class Katze(Tier):\n",
    "    def gruessen(self):\n",
    "        print(f\"{self.name} miaut!\")\n",
    "\n",
    "Bello = Hund()\n",
    "Mietz = Katze()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Anonymus miaut!\n"
     ]
    }
   ],
   "source": [
    "Mietz.gruessen()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "__main__.Katze"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(Mietz)"
   ]
  },
  {
   "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.7.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}