praesentation_2020_01_08.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>\n",
       "td {\n",
       "    font-size: 20px;\n",
       "}\n",
       "thead th {\n",
       "    font-size: 20px;\n",
       "}\n",
       "img {\n",
       "    width: 30%;\n",
       "}\n",
       "</style>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%html\n",
    "<style>\n",
    "td {\n",
    "    font-size: 20px;\n",
    "}\n",
    "thead th {\n",
    "    font-size: 20px;\n",
    "}\n",
    "img {\n",
    "    width: 30%;\n",
    "}\n",
    "</style>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Noch einmal kurz zur Übung..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## I. format()\n",
    "\n",
    "Wenn Sie eine Zeichenkette erzeugen wollen, die auch Ergebnisse aus einer Berechnung beinhalten soll, verwenden Sie am besten die Funktion *format()*. Damit lassen sich viele Fehler vermeiden, welche sich bei der Verkettung (*concatenation*) mit *+* einschleichen können. Außerdem bietet die Funktion auch viele Formatierungsmöglichkeiten. Wenn Sie die Werte vorher berechnen, bleibt die *format()*-Funktion übersichtlicher."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Der Durchschnittswert von Werte ist 32.9\n"
     ]
    }
   ],
   "source": [
    "from statistics import mean\n",
    "werte = [20, 42.7, 61, 7.8]\n",
    "durchschnitt = mean(werte)\n",
    "print(\"Der Durchschnittswert von Werte ist {0:.1f}\".format(durchschnitt))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## II. Lassen Sie Python für sich arbeiten!\n",
    "\n",
    "Wenn Sie Code für eine Datenanalyse schreiben, dann sollte der Code Sie bis zum Endergebnis führen. Sie sollten dann nicht noch manuell etwa durch eine Liste gehen müssen, um einen gesuchten Wert zu finden. In dieser Beziehung können Sie ruhig einmal etwas faul sein!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Objektorientierte Programmierung (OOP)\n",
    "\n",
    "Objektorientierte Programmierung ist ein sogenanntes Programmierparadigma, was Wikipedia<sup>1</sup> als einen \"fundamentale[n] Programmierstil\" definiert. Ein solches Paradigma legt bestimmte Prizipien fest, welche die Softwareentwicklung leiten. Es gibt mehrere verschiedene Paradigmen, wie etwa die imperative oder die deklarative Programmierung. Programmiersprachen können ein oder mehrere Paradigmen unterstützen.\n",
    "\n",
    "1 [https://de.wikipedia.org/wiki/Programmierparadigma](https://de.wikipedia.org/wiki/Programmierparadigma)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Python und OOP\n",
    "\n",
    "Python ist eine objektorientierte Programmiersprache. Ohne es wahrscheinlich zu wissen, haben Sie in Python schon mit Objekten gearbeitet, denn alles, was Sie in Python erzeugen, ist ein Objekt.\n",
    "\n",
    "Ein Objekt enthält eine Beschreibung von dessen Charakteristiken, oder **Attributen** (*attributes*), und der  **Methoden** (*methods*), die darauf angewandt werden können. All das wird in einer **Klasse** (*class*) festgelegt. Methoden sind das gleiche wie Funktionen, nur dass sie eben innerhalb einer Klasse definiert werden."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Klassen / Instanzen\n",
    "\n",
    "Eine Klasse selbst ist noch kein Objekt, sondern lediglich eine Anleitung oder ein Rezept für dessen Erstellung. So wäre etwa eine Klasse \"Kuchen\" mit einem Kuchenrezept vergleichbar. Erst durch das **Instanziieren** (*instantiation*) wird ein Objekt erzeugt, oder, um bei dem Vergleich zu bleiben, ein Kuchen gebacken. Das Objekt (den Kuchen) bezeichnet man dann als eine **Instanz** der Klasse \"Kuchen.\"\n",
    "\n",
    "Wie bei einem Kuchenrezept auch kann man beliebig viele Instanzen erzeugen (Kuchen backen), die sich auch durch unterschiedliche Zutaten und/oder Dosierungen unterscheiden können, aber von ihrer Grundstruktur her immer noch zu der gleichen Klasse gehören."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Beispiel: Konto\n",
    "\n",
    "Am Beispiel eines Bankkontos lässt sich gut erklären, wie man ein Konzept in der realen Welt mit Python modellieren kann. Es wird daher oft in Tutorien und auch im folgenden Beispiel verwendet."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Eine Bank bietet meist mehrere Kontotypen an. Jeder Typ ist normalerweise nicht auf einen Kunden maßgeschneidert, sondern wird von mehreren Kunden genutzt. Jeder Kontotyp kann dann in einer eigenen Klasse definiert werden.\n",
    "\n",
    "Ein einzelnes Konto ist eine Instanz der jeweiligen Kontoklasse. Alle Konten haben bestimmte Attribute (wie etwa Kontonummer, Inhaber) gemein, aber deren Werte unterscheiden sich, da die Konten verschiedene Kontonummern und Inhaber haben."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Vererbung\n",
    "\n",
    "Es wird aber auch Gemeinsamkeiten zwischen den verschiedenen Kontoklassen geben. Das heißt, dass es Attribute und Methoden gibt, die bei allen Kontotypen vorkommen. Es bietet sich daher an, eine **Basisklasse** (*superclass*) zu definieren, welche die geteilten Attribute und Methoden enthält. Dadurch kann man viel Codeduplikation vermeiden und Programme lassen sich übersichtlicher gestalten."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Dies wird durch die sog. **Vererbung** (*inheritance*) ermöglicht. Wenn eine Tochterklasse (subclass) von einer Basisklasse erbt, dann bedeutet das, dass sie zuerst die gleichen Attribute und Methoden wie die Basisklasse hat. Indem man dann in der Tochterklasse weitere Attribute und/oder Methoden hinzufügt, kann man sie an die jeweiligen Bedürfnisse anpassen und so etwa aus einem allgemeinen Konto ein Giro- oder ein Sparkonto machen, während die Basisklasse unverändert bleibt."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<img src=\"emoji.png\" style=\"width: 30%;\"/>\n",
    "\n",
    "***\n",
    "\n",
    "Quelle: https://pixabay.com/vectors/shocked-exploding-head-emoji-4625235/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Wie sieht das in Python aus?\n",
    "\n",
    "Die Definition einer Klasse beginnt mit dem Schlüsselwort **class** und dem Namen der Klasse:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class Konto:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Wie Sie schon wissen, macht *pass* hier nichts und ist nur ein Lückenfüller, bis wir unsere Klasse weiter ausbauen; ohne *pass* würden wir hier eine Fehlermeldung bekommen."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Wir können jetzt auch schon damit beginnen, Instanzen unserer Klasse *konto* zu erzeugen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<__main__.Konto object at 0x000002B2F0CC8C50>\n",
      "<__main__.Konto object at 0x000002B2F0CA3160>\n"
     ]
    }
   ],
   "source": [
    "a = Konto()\n",
    "b = Konto()\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Wie Sie sehen, können wir aber noch nicht viel damit anfangen. Deshalb fügen wir ein paar Methoden hinzu."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class Konto:\n",
    "    def name_zeigen(self):\n",
    "        print(\"Name: {}\".format(self.Inhaber))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Hier haben wir der Klasse eine erste Methode hinzugefügt, welche den mit dem Konto verbundenen Personennamen und die Kontonummer anzeigt. *self* bezieht sich auf die Instanz, von der aus die Methode aufgerufen wurde und muss nur in der Methodendefinition erwähnt werden."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Fügen wir noch eine Methode hinzu, welche die Kontonummer anzeigt (wir könnten diese Funktionalität natürlich auch in unsere erste Funktion integrieren):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class Konto:\n",
    "    def name_zeigen(self):\n",
    "        print(\"Name: {}\".format(self.Inhaber))\n",
    "    def kontonummer_zeigen(self):\n",
    "        print(\"Kontonummer: {}\".format(self.Kontonummer))\n",
    "    def maximaler_tagesumsatz_zeigen(self):\n",
    "        print(\"Maximaler Tagesumsatz: {}\".format(self.MaximalerTagesumsatz))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Konstruktor\n",
    "\n",
    "In Bezug auf die Nutzung der Klasse sind wir aber noch nicht viel weiter gekommen. Wir müssen unter anderem die verschiedenen Attribute der Klasse definieren. Dies können wir mit einem **Konstruktor** (*constructor*) erreichen. Der Konstruktor wird als eine Methode mit dem Namen **\\_\\_init\\_\\_** (zwei Unterstriche vor und nach dem Wort *init*) implementiert."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class Konto:\n",
    "    MaximalerTagesumsatz = 2000 # Klassenattribut\n",
    "    def __init__(self, inhaber, kontonummer):\n",
    "        self.Inhaber = inhaber # Instanzattribut\n",
    "        self.Kontonummer = kontonummer # Instanzattribut\n",
    "    def name_zeigen(self):\n",
    "        print(\"Name: {}\".format(self.Inhaber))\n",
    "    def kontonummer_zeigen(self):\n",
    "        print(\"Kontonummer: {}\".format(self.Kontonummer))\n",
    "    def maximaler_tagesumsatz_zeigen(self):\n",
    "        print(\"Maximaler Tagesumsatz: {}\".format(self.MaximalerTagesumsatz))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Jetzt können wir auch eine Instanz erzeugen und Attributwerte an diese übergeben. Wenn wir dann die bereits für diese Klasse definierten Methoden aufrufen, bekommen wir die richtigen Werte angezeigt.\n",
    "\n",
    "Beachten Sie hier den Unterschied zwischen \"Inhaber\"/\"Kontonummer\" und \"MaximalerTagesumsatz\". Erstere sind sog. Instanzattribute, d.h. sie sind für jede Instanz dieser Klasse unterschiedlich. Letzteres ist ein Klassenattribut, d.h., es ist für alle Instanzen dieser Klasse gleich, und kann auch unabhängig von einer Instanz abgerufen werden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: Hans\n",
      "Kontonummer: 12345\n",
      "Maximaler Tagesumsatz: 2000\n"
     ]
    }
   ],
   "source": [
    "c = Konto(\"Hans\", 12345)\n",
    "c.name_zeigen()\n",
    "c.kontonummer_zeigen()\n",
    "c.maximaler_tagesumsatz_zeigen()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Wir haben jetzt die Grundstruktur einer möglichen Basisklasse für unser allgemeines Konto. Wie wir schon gesehen haben, können wir davon Tochterklassen für verschiedene spezialisierte Kontotypen ableiten, welche Funktionen und Attribute von der Basisklasse erben. Das folgende Beispiel zeigt eine Tochterklasse für ein Girokonto, welches einen niedrigeren maximalen Tagesumsatz hat:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class Girokonto(Konto):\n",
    "    maximaler_tagesumsatz = 1000\n",
    "    def __init__(self, inhaber, kontonummer):\n",
    "        pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Was passiert jetzt, wenn wir versuchen, eine Instanz dieser Klasse zu erzeugen?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'Girokonto' object has no attribute 'Inhaber'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-10-d5b8cf6d0184>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0md\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mGirokonto\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"Martina\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m54321\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0md\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mname_zeigen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      3\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m<ipython-input-7-a2f8b2fb009b>\u001b[0m in \u001b[0;36mname_zeigen\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m      5\u001b[0m         \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mKontonummer\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mkontonummer\u001b[0m \u001b[1;31m# Instanzattribut\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      6\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0mname_zeigen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 7\u001b[1;33m         \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"Name: {}\"\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mInhaber\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      8\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0mkontonummer_zeigen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      9\u001b[0m         \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"Kontonummer: {}\"\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mKontonummer\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mAttributeError\u001b[0m: 'Girokonto' object has no attribute 'Inhaber'"
     ]
    }
   ],
   "source": [
    "d = Girokonto(\"Martina\", 54321)\n",
    "d.name_zeigen()\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Der Grund für die Fehlermeldung ist, dass die Tochterklasse nicht mehr auf den Konstruktur der Basisklasse zugreifen kann, da wir ihn mit dem Konstruktor der Tochterklasse überschrieben haben. Um den Konstruktor der \"Konto\"-Klasse weiterhin nutzen zu können, fügen wir dem \"Girokonto\"-Konstruktor eine Zeile hinzu:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class Girokonto(Konto):\n",
    "    maximaler_tagesumsatz = 1000\n",
    "    def __init__(self, inhaber, kontonummer):\n",
    "        super().__init__(inhaber, kontonummer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Damit zeigen wir Python, dass wir die beiden Attribute \"inhaber\" und \"kontonummer\" aus dem Konstruktor der **super**class übernehmen wollen.\n",
    "\n",
    "Auch die Methoden werden von der Basisklasse übernommen; wir können sie jedoch durch gleichnamige Versionen überschreiben, welche an den neuen Kontotyp angepasst sind:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class Girokonto(Konto):\n",
    "    maximaler_tagesumsatz = 1000\n",
    "    def __init__(self, inhaber, kontonummer):\n",
    "        super().__init__(inhaber, kontonummer)\n",
    "    def kontonummer_zeigen(self):\n",
    "        print(\"Nummer des Girokontos: {}\".format(self.Kontonummer))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: Martina\n",
      "Maximaler Tagesumsatz: 2000\n",
      "Nummer des Girokontos: 54321\n"
     ]
    }
   ],
   "source": [
    "d = Girokonto(\"Martina\", 54321)\n",
    "d.name_zeigen()\n",
    "d.maximaler_tagesumsatz_zeigen()\n",
    "d.kontonummer_zeigen()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Statische Methoden\n",
    "\n",
    "Statische Methoden (*static methods*) beziehen sich nicht auf eine spezielle Instanz und können direkt aufgerufen werden, ohne zuvor eine Instanz aufzurufen. Sie werden erst normal definiert und danach mit der Funktion *staticmethod()* in eine statische Methode umgewandelt:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Das ist eine statische Methode!\n"
     ]
    }
   ],
   "source": [
    "class X:\n",
    "    def anzeigen():\n",
    "        print(\"Das ist eine statische Methode!\")\n",
    "    anzeigen = staticmethod(anzeigen)\n",
    "    \n",
    "X.anzeigen()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Klassenmethoden\n",
    "\n",
    "Klassenmethoden können sowohl über die Instanz als über den Klassennamen aufgerufen werden:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Das ist Klasse <class '__main__.A'>\n",
      "Das ist Klasse <class '__main__.A'>\n"
     ]
    }
   ],
   "source": [
    "class A:\n",
    "    def anzeigen(cls): # Der Name \"cls\" ist kein Schlüsselwort, sondern eine Python-Konvention\n",
    "        print(\"Das ist Klasse {}\".format(cls))\n",
    "    anzeigen = classmethod(anzeigen)\n",
    "    \n",
    "A.anzeigen()\n",
    "\n",
    "X = A()\n",
    "X.anzeigen()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Decorators\n",
    "\n",
    "Die eben gezeigte Methode, Klassen- und statische Methoden zu erzeugen, funktioniert zwar. In der Praxis hat sich aber der Gebrauch von **Decorators** durchgesetzt, um den Code etwas überschaubarer zu gestalten. Hier noch einmal die gleichen Methoden, welche nun aber einen Decorator mit einem vorangestellten \"@\" nutzen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Das ist eine statische Methode!\n"
     ]
    }
   ],
   "source": [
    "class X:\n",
    "    @staticmethod\n",
    "    def anzeigen():\n",
    "        print(\"Das ist eine statische Methode!\")\n",
    "    \n",
    "X.anzeigen()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Das ist Klasse <class '__main__.A'>\n",
      "Das ist Klasse <class '__main__.A'>\n"
     ]
    }
   ],
   "source": [
    "class A:\n",
    "    @classmethod\n",
    "    def anzeigen(cls): # Der Name \"cls\" ist kein Schlüsselwort, sondern eine Python-Konvention\n",
    "        print(\"Das ist Klasse {}\".format(cls))\n",
    "    \n",
    "A.anzeigen()\n",
    "\n",
    "X = A()\n",
    "X.anzeigen()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Magic Methods / Magic Attributes\n",
    "\n",
    "Bei *Magic Methods* und *Magic Attributes* handelt es sich nicht um Harry Potters erste Programmierversuche. Es sind vielmehr Methoden und Attribute, die Sie normalerweise nicht durch ihren Namen aufrufen müssen, sondern die bei Bedarf im Hintergrund ausgeführt werden.\n",
    "\n",
    "Sie haben schon eine *Magic Method* kennengelernt, \\_\\_init\\_\\_. Sie wird automatisch bei der Instantiierung ausgeführt.\n",
    "\n",
    "Die Namen aller *Magic Methods* und *Magic Attributes* beginnen und enden mit einem doppelten Unterstrich."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Ein anderes Beispiel ist \\_\\_call\\_\\_. Damit kann man Klassen erstellen, deren Instanzen man wie eine Funktion nutzen kann:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "243"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Potenz:\n",
    "    def __init__(self, exponent):\n",
    "        self.Exponent = exponent\n",
    "    def __call__(self, basis):\n",
    "        return basis ** self.Exponent\n",
    "    \n",
    "hoch5 = Potenz(5)\n",
    "hoch5(3) \n",
    "# Beispiel nach Ernesti und Kaiser, S. 372"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Aufgabe:\n",
    "\n",
    "Sie haben den Auftrag erhalten, ein Kursregistrierungssystem zu programmieren. Wie würden Sie es planen:\n",
    "\n",
    "- Welche Basisklassen und Tochterklassen wären nützlich?\n",
    "- Welche Attribute würden Sie wählen?\n",
    "- Welche Methoden bräuchte man?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Weiterführende Lektüre zu Objektorientierter Programmierung\n",
    "\n",
    "Bernhard Lahres und Gregor Ra&#253;man. *Objektorientierte Programmierung. Das umfassende Handbuch.* 2. aktualisierte und erweiterte Auflage. Bonn: Galileo Press, 2009. UB Signatur: 49 A 8584. [Enthält Beispiele in mehreren Sprachen, u.a. auch Python.]\n",
    "\n",
    "Johannes Ernesti und Peter Kaiser. *Python 3. Das umfassende Handbuch.* 5., aktualisierte Auflage. Bonn: Rheinwerk, 2017. Kapitel 21. UB Signatur: 59 A 7577 (Morgenstelle) [Ausführliche, aktuelle und gut verständliche Darstellung der objektorientierten Programmierung in Python.]"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "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.3"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "165px"
   },
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}