eLegal Codingeinheit 6.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Klassen und Module\n",
    "===\n",
    "\n",
    "# Module\n",
    "\n",
    "In der Programmierung gibt es oft Probleme, die man in jedem Projekt hat (Erstellen von Dateien, Kommunikation ueber Internet). Um den Code wiederzuverwenden, kann man diese in sogenannte Module (Libraries) zusammenfassen. In Python sind diese Module einfach nur eine Textdatei oder ein Ordner an Textdateien\n",
    "\n",
    "Wir erstellen um dieses Beispiel zu veranschaulichen ein Modul, welches zwei Funktionen enthalten, welche etwas ausgeben."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "from elegal_assert import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def elegal():\n",
    "    print(\"Elegal ist super!\")\n",
    "\n",
    "def kmpg():\n",
    "    print(\"KPMG ist krass!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wir speichern diesen Codeabschnitt in `mein_modul.py`.\n",
    "\n",
    "Jetzt koennen wir diesen Code aus einer anderen Datei im gleichen Verzeichnis einfach importieren.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import mein_modul \n",
    "\n",
    "mein_modul.elegal() \n",
    "mein_modul.kpmg() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Beachte: Hierbei steht `mein_modul.elegal()` fuer \"Die Funktion namens `elegal`, welche du unter `mein_modul` gefunden hast\".\n",
    "\n",
    "#### Anmerkung\n",
    "Module muessen stets im Pfad verfuegbar sein!\n",
    "\n",
    "## Import unter anderen Namen\n",
    "Nehmen wir folgendes an, wir wollen die Funktion aus der Datei `liste_aller_praezedenzfaelle_der_letzten_zwanzig_jahre.py`.\n",
    "\n",
    "Um hier nicht immer den Namen auszuschreiben, gibt es zwei Moeglichkeiten:\n",
    "\n",
    "## Unter anderen Namen importieren\n",
    "Hierfuer gibt es `as`-Schluesselwort in Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import liste_aller_praezedenzfaelle_der_letzten_zwanzig_jahre as liste\n",
    "\n",
    "# ...\n",
    "liste.funktion()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ohne Namen importieren\n",
    "Hierfuer gibt es das `from`-Schluesselwort in Python, womit man einzelne Methoden importiert. Danach kann man diese wie die Standardmethoden ohne Modulnamen aufrufen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from mein_modul import elegal\n",
    "\n",
    "elegal() # Elegal ist super!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hierbei haben wir einfach die Funktion `elegal` importiert, nicht `kpmg`. Wenn man alles importieren will, schreibt man einfach"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from mein_modul import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "wobei der `*` fuer \"alles\" steht.\n",
    "\n",
    "# Klassen\n",
    "\n",
    "## Herleitung\n",
    "Betrachten wir folgendes Problem: Wir wollen eine Funktion schreiben, welche den Wert eines beliebigen Autos anhand dessen Attribute berechnet. \n",
    "Hier sei der Preis abhaengig von\n",
    "\n",
    "- Baujahr des Autos\n",
    "- Kaufpreis im Jahre des Baujahrs\n",
    "- Marke\n",
    "- Modell\n",
    "- Extraausstattungen\n",
    "- Unfallfrei\n",
    "\n",
    "Dies wuerde im Code wiefolgt aussehen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def wert_rechner(baujahr, kaufpreis, marke, modell, ausstattung, unfallfrei):\n",
    "    letzter = letzter_verkaufswert(baujahr, kaufpreis, marke, modell, ausstattung, unfallfrei)\n",
    "    \n",
    "    maximal = hoechster_verkaufswert(baujahr, kaufpreis, marke, modell, ausstattung, unfallfrei)\n",
    "    \n",
    "    minimal = niederigster_verkaufswert(baujahr, kaufpreis, marke, modell, ausstattung, unfallfrei)\n",
    "    \n",
    "    liste = listenpreis(baujahr, kaufpreis, marke, modell, ausstattung, unfallfrei)\n",
    "    \n",
    "    if (minimal < listenpreis):\n",
    "        return (liste*maximal*letzter)/3\n",
    "    else:\n",
    "        return (minimal*maximal*lezter)/3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hier fallen direkt 3 Probleme auf:\n",
    "1. Es ist nur sehr schwierig lesbar\n",
    "2. Man wiederholt sich sehr oft\n",
    "3. Es ist einfach aus Versehen eine Eigenschaft zu vergessen\n",
    "\n",
    "Um diese Probleme zu loesen, gab es viele Ansaetze, wovon das meist genutzte die \"Objektorientierte Programmierung\" ist.\n",
    "\n",
    "## Klassen und Objekte\n",
    "Um Probleme der reellen Welt in Code zu abstrahieren, bietet es sich an, hier auch mit einem Auto, statt mit einer Liste an Werten, zu arbeiten.\n",
    "\n",
    "Und genau dies sind Klassen und Objekte. Hier ist eine Klasse \"Auto\" quasi der \"Bauplan\" fuer Autos, welcher definiert, was genau ein Auto hat.\n",
    "\n",
    "Nach obigen Ueberlegungen muessen wir nur noch definieren, wie genau der Bauplan ein Auto erstellen soll:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Bauplan Auto:\n",
    "    Erstellung des Autos: \n",
    "    (Hierfuer benoetige ich Baujahr, Kaufpreis, Marke, Modell,\n",
    "      Extraausstattungen und ob es unfallfrei ist.)\n",
    "      \n",
    "    Setze fest, dass bei diesem Auto das Baujahr das Uebergebene Baujahr ist.\n",
    "    Dann setze fest, dass bei diesem Auto der Kaufpreis dem Uebergebenen gleicht.\n",
    "    Dann setze fest, dass bei diesem Auto die Marke und das Modell uebereinstimmt.\n",
    "    Dann setze fest, dass die Ausstattung uebereinstimmt.\n",
    "    Dann halte fest, ob das Auto unfallfrei ist.\n",
    "Bauplan Ende."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hierfuer sieht der Pythoncode sehr aehnlich aus:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Auto:\n",
    "    def __init__(self,baujahr, kaufpreis,marke,modell,ausstattung,unfallfrei):\n",
    "        self.baujahr = baujahr\n",
    "        self.kaufpreis = kaufpreis\n",
    "        self.marke = marke\n",
    "        self.modell = modell\n",
    "        self.ausstattung = ausstattung\n",
    "        self.unfallfrei = unfallfrei"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Auch wenn das meiste selbsterklaerend sein sollte, hier doch noch 1-2 Dinge:\n",
    "\n",
    "- `class` beschreibt, dass eine Klasse beginnt, genau so wie `def` eine Funktion.\n",
    "- `self` bedeutet, dass es auf die das Objekt des Bauplans (hier das einzelne Auto) bezogen ist. Mehr hierzu spaeter.\n",
    "- `__init__` ist ein von Python festgelegter Name. Dieser kommt von \"initialisation\" und wird bei der Erstellung aufgerufen. Allgemein als Richtlinie gilt: `__funktionsname__` ist eine interne Funktion.\n",
    "\n",
    "Nun koennen wir unser erstes Auto erstellen! und dann einfach mit `autoobjekt.information` diese Aufrufen!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "auto_zum_verkauf = Auto(2019, 50000, \"Audi\", \"A4\", \"\", True)\n",
    "\n",
    "print(\"Das Auto ist ein \" + auto_zum_verkauf.marke \n",
    "      + \" \" + auto_zum_verkauf.modell\n",
    "      + \" aus dem Jahr \" + str(auto_zum_verkauf.baujahr))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hierbei ist `auto_zum_verkauf` unser Autoobjekt.\n",
    "\n",
    "Nun koennen wir **ENDLICH** unsere Methode schoener schreiben!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def wert_rechner(auto):\n",
    "    letzter = letzter_verkaufswert(auto)\n",
    "    \n",
    "    maximal = hoechster_verkaufswert(auto)\n",
    "    \n",
    "    minimal = niederigster_verkaufswert(auto)\n",
    "    \n",
    "    liste = listenpreis(auto)\n",
    "    \n",
    "    if (minimal < listenpreis):\n",
    "        return (liste*maximal*letzter)/3\n",
    "    else:\n",
    "        return (minimal*maximal*lezter)/3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Objektmethoden\n",
    "Wenn man weiter an Objekte in der reellen Welt denkt, kann man Funktionen in 2 Kategorien aufteilen:\n",
    "\n",
    "- Dinge die an dem Auto selbst passieren (fahren, bremsen) (Objektmethode)\n",
    "- Dinge wofuer ein Auto gebraucht wird (Belegen eines Parkplatzes) (Normale Funktion)\n",
    "\n",
    "Objektmethoden zeichnen sich dadurch aus, dass sie kein Sinn hat, diese ohne das Objekt aufzurufen. Es ist halt nicht moeglich, ein Auto zu fahren, welches nicht existiert.\n",
    "\n",
    "In Python schreibt man Objektmethoden in Klassen selbst, wofuer das oben benannte `self` dafuer steht, dass es sich auf das eigene Objekt bezieht.\n",
    "\n",
    "Als Beispiel nun mit der Methode `unfall_bauen`, welche als Folge unfallfrei auf falsch setzt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Auto:\n",
    "    def __init__(self,baujahr, kaufpreis,marke,modell,ausstattung,unfallfrei):\n",
    "        self.baujahr = baujahr\n",
    "        self.kaufpreis = kaufpreis\n",
    "        self.marke = marke\n",
    "        self.modell = modell\n",
    "        self.ausstattung = ausstattung\n",
    "        self.unfallfrei = unfallfrei\n",
    "    \n",
    "    def unfall_bauen(self):\n",
    "        self.unfallfrei = False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Klassen printen\n",
    "Zuletzt ist es noch sinnvoll, dass das printen wie erwartet klappt.\n",
    "\n",
    "Wie wir bereits gelernt haben, sind Funktionen wie `__init__` von Python selbst gestellte Funktionen.\n",
    "Zum printen von Funktionen gibt es nun die von Python gestellte `__str__`, welche man einfach definieren muss. Beispiel:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Person:\n",
    "    def __init__(self, vorname, nachname, alter):\n",
    "        self.vorname = vorname\n",
    "        self.nachname = nachname\n",
    "        self.alter = alter\n",
    "    \n",
    "    # Coole weitere Funktionen\n",
    "    # ...\n",
    "    \n",
    "    def __str__(self):\n",
    "        string_zur_ausgabe = self.vorname + \" \" + self.nachname + \": \" + str(self.alter) + \" Jahre alt.\"\n",
    "        return string_zur_ausgabe\n",
    "    \n",
    "john = Person(\"John\", \"Doe\", 36)\n",
    "print(john)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Beispiele\n",
    "\n",
    "So wuerde man z.B. ein Verein definieren"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Verein:\n",
    "    name = None\n",
    "    mitglieder = []\n",
    "    vorsitzender = None\n",
    "    \n",
    "    # Konstruktor\n",
    "    def __init__(self, name, vorsitzender):\n",
    "        self.name = name\n",
    "        self.vorsitzender = vorsitzender\n",
    "    \n",
    "    # Hier wird eine Person als neues_mitglied erwartet\n",
    "    # Dies ist eine Objektmethode, da es am Verein selbst passiert.\n",
    "    # Beachte: Der Print von neues Mitglied klappt nur, \n",
    "    # da __str__ hierfuer definiert ist.\n",
    "    def mitglied_beitritt(self, neues_mitglied):\n",
    "        self.mitglieder.append(neues_mitglied)\n",
    "        print(\"Neues Mitglied!\")\n",
    "        print(neues_mitglied)\n",
    "    \n",
    "    def mitgleid_austritt(self, altes_mitglied):\n",
    "        if altes_mitglied not in self.mitglieder:\n",
    "            print(\"Diese Person war nie im Verein!\")\n",
    "            return\n",
    "        else:\n",
    "            print(\"Folgende Person verliess den Verein:\")\n",
    "            print(altes_mitglied)\n",
    "            print(\":(\")"
   ]
  }
 ],
 "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.4"
  },
  "pycharm": {
   "stem_cell": {
    "cell_type": "raw",
    "metadata": {
     "collapsed": false
    },
    "source": []
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}