06_Objekte.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "254f30ce",
   "metadata": {},
   "source": [
    "<img src=\"img/DN.png\" style=\"float:right;width:150px\">\n",
    "\n",
    "Objekte\n",
    "\n",
    "# Übungen in dieser Lektion\n",
    "\n",
    "* [Klasse definieren](#Aufgabe1)\n",
    "\n",
    "# Objekte\n",
    "\n",
    "Objekte und damit verbunden das **Objektorientierte Programmieren** (*Object Oriented Programming*) sind ein wichtiges und vielschichtes Konzept beim Programmieren.\n",
    "\n",
    "Fast alles in Python ist ein Objekt. Zu einem Objekt gehören **Eigenschaften** (*Properties*) und **Methoden** (*Methods*). Eigenschaften sind Variablen, die an ein bestimmtes Objekt gebunden sind und Methoden sind Funktionen, die auf ein Objekt angewandt werden können.\n",
    "\n",
    "## Objekte erzeugen\n",
    "\n",
    "Wenn wir Objekte erzeugen wollen, müssen wir **Klassen** (*Class*) definieren, welche als Vorlagen für ein bestimmtes Objekt dienen. Man spricht bei Objekten auch von einer **Instanz** (*Instance*) einer bestimmten Klasse:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "35eb78bd-48bf-4a28-b1ce-7c89a4b0c26d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Casandra\n"
     ]
    }
   ],
   "source": [
    "# Definition der Klasse\n",
    "class Person:\n",
    "    name = \"Casandra\"\n",
    "\n",
    "# Erzeugen eines Objekts mit Hilfe des Konstruktors (Instanz der Klasse Person)    \n",
    "frau = Person()\n",
    "\n",
    "# Ausgabe einer Eigenschaft des Objekts\n",
    "print(frau.name)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b238aa61-d151-4904-a3a3-a5943a41fe52",
   "metadata": {},
   "source": [
    "Die Definition einer Klasse wird mit dem Schlüsselwort `class` eingeleitet. Die Konvention ist, dass Klassen mit einem Grossbuchstaben beginnen. Innerhalb der Klasse können Eigenschaften und Methoden definiert werden.\n",
    "\n",
    "Um eine Instanz einer Klasse, also ein Objekt zu erzeugen, wird der **Konstruktor** (*Constructor*) einer Klasse aufgerufen. Dies geschieht durch Nutzung des Klassennamens mit Klammern `()`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "934cd9a8-264d-431c-a6bf-9559c7e98c1a",
   "metadata": {},
   "source": [
    "## Punkt-Notation\n",
    "\n",
    "Auf Eigenschaften und Methoden des Objekts kann mit Hilfe der **Punkt-Notation** (dot notation) zugegriffen werden. Die Eigenschaft oder Methode wird mit einem Punkt `.` vom Namen der Instanz getrennt, aufgerufen. Wann immer diese Punkt-Notation auftaucht, geht es also um Objekte.\n",
    "\n",
    "Ein weiteres Beispiel für eine Punkt-Notation ist folgendes Beispiel:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "05869c59-ddfd-4435-b9f8-5bc8d79eda4d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n",
      "['Bernd', 'Solaminia', 'Hunwiu', 'Fruzsina']\n"
     ]
    }
   ],
   "source": [
    "my_list = [\"Bernd\", \"Solaminia\", \"Hunwiu\"]\n",
    "\n",
    "print(type(my_list))\n",
    "\n",
    "my_list.append(\"Fruzsina\")\n",
    "\n",
    "print(my_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "81f03d6b-33b5-42da-add7-cb532cc07c5a",
   "metadata": {},
   "source": [
    "`my_list` ist eine Instanz der Klasse Liste, welche die Methode `append()` kennt, um ein Element der Liste hinzuzufügen."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ef842eba-8aa1-48bf-b227-f28ff19ed12b",
   "metadata": {},
   "source": [
    "Um alle Methoden einer Klasse aufzulisten, kann die Funktion `dir()` verwendet werden:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "460de001-5d4c-4a6e-89a2-e62e69f25c96",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__add__',\n",
       " '__class__',\n",
       " '__class_getitem__',\n",
       " '__contains__',\n",
       " '__delattr__',\n",
       " '__delitem__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__getitem__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__iadd__',\n",
       " '__imul__',\n",
       " '__init__',\n",
       " '__init_subclass__',\n",
       " '__iter__',\n",
       " '__le__',\n",
       " '__len__',\n",
       " '__lt__',\n",
       " '__mul__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__reversed__',\n",
       " '__rmul__',\n",
       " '__setattr__',\n",
       " '__setitem__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__subclasshook__',\n",
       " 'append',\n",
       " 'clear',\n",
       " 'copy',\n",
       " 'count',\n",
       " 'extend',\n",
       " 'index',\n",
       " 'insert',\n",
       " 'pop',\n",
       " 'remove',\n",
       " 'reverse',\n",
       " 'sort']"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(my_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a2823c49-466c-4939-ab22-4e9e3317b3d0",
   "metadata": {},
   "source": [
    "Eine alternative Möglichkeit besteht darin, in der offiziellen Python Dokumentation nachzuschauen, über welche Eigenschaften und Methoden eine Klasse verfügt. Hier als Beispiel die Klasse [Liste](https://docs.python.org/3/library/stdtypes.html#list). Diese offizielle Dokumentation ist etwas umständlich, das hat vor allem damit zu tun, dass diese sehr kompakt verfasst ist. Es ist also nicht auf den ersten Blick ersichtlich, dass Objekte der Klasse Liste eine Funktion `append()` beinhalten. Das ist ersichtlich aus dem Satz: \"Lists implement all of the common and mutable sequence operations.\" Ein Blick auf diese [Mutable Sequence Types](https://docs.python.org/3/library/stdtypes.html#mutable-sequence-types) zeigt tatsächlich, dass eine Funktion `s.append(x)` implementiert ist.\n",
    "\n",
    "Etwas einfacher ist es mit einem Blick auf *W3Schools*, wo eine [Übersicht](https://www.w3schools.com/python/python_lists_methods.asp) über alle Methoden von Listen zusammengestell ist."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "13aaf3ff-5d57-4703-b28e-9484fcce06dd",
   "metadata": {},
   "source": [
    "## Eigenschaften nach Erzeugung verändern\n",
    "\n",
    "Eigenschaften von Objekten können auch nach der Erzeugung der Objekte noch geändert werden:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "98b771fb-0350-45c8-ae1f-9119f6f39165",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Casandra\n",
      "Sabine\n"
     ]
    }
   ],
   "source": [
    "frau_2 = Person()\n",
    "\n",
    "print(frau_2.name)\n",
    "\n",
    "frau_2.name = \"Sabine\"\n",
    "\n",
    "print(frau_2.name)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "454769c2-52f8-432d-8089-94e4ee2bee33",
   "metadata": {},
   "source": [
    "Jetzt ist es nicht wahnsinnig praktisch, wenn wir die Eigenschaften \"fest\" in die Klasse hineinschreiben. Schliesslich möchten wir in unserem Beispiel jeder Person einen individuellen Namen geben. Dies wird dadurch erreicht, dass der Konstruktor einer Klasse explizit definiert wird. Der Konstruktor ist eine spezielle Methode jeder Klasse, die den Namen `__init__` trägt (die beiden Linien vor und nach `init` sind je zwei aneinandergeghängte Unterstriche):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "807f9644-ce4c-4328-8bce-6b228c19aeee",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Casandra\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "        \n",
    "frau = Person(\"Casandra\")\n",
    "\n",
    "print(frau.name)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a795c5a0-51b4-4266-9a38-ecd0ac7759ee",
   "metadata": {},
   "source": [
    "## Schlüsselwort `self`\n",
    "\n",
    "Das Konzept des Schlüsselwortes `self` bereitet erfahrungsgemäss zu Beginn gewisse Schwierigkeiten beim Verständnis.\n",
    "\n",
    "Weil ja im Konstruktor Zugriff auf das in Erstellung befindliche Objekt benötigt wird (bspw. um die Eigenschaften des Objektes festzulegen), muss das Objekt an den Konstruktor übergeben werden. Dies geschieht mit dem Parameter `self`. Dass dieser Parameter `self` genannt wird, ist Konvention, er muss aber an erster Stelle stehen. Somit kann dann innerhalb des Konstruktors das zu erstellende Objekt beliebig manipuliert werden. Unter anderem können Eigenschaften festgelegt werden. Dazu kommt die Punkt-Notation zum Einsatz mit `self.eigenschaft`.\n",
    "\n",
    "Im Beispiel oben ist zusätzlich verwirrlich, dass `name` zweimal vorkommt und dass die beiden Vorkommnisse prinzipiell nichts miteinander zu tun haben: `self.name` ist die Eigenschaft `name` des zu erstellenden Objekts. `name` ist der zweite Parameter, der dem Konstruktor übergeben wird.\n",
    "\n",
    "Bei der Erstellung des Objekts wird beim Aufruf des Konstruktors dann aber nur der zweite (und allfällige weitere) Parameter übergeben, `self` muss hier nicht eingefügt werden."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ef3718a6",
   "metadata": {
    "tags": []
   },
   "source": [
    "<div id=\"Aufgabe1\" style=\"margin:0px; padding:10px; border-style:solid; border-width:2px; border-color:green\">\n",
    "\n",
    "<img src=\"img/dumbbell.png\" style=\"float:right; width:100px\">\n",
    "\n",
    "<span style=\"padding:5px; border-radius:5px; background-color:green; color:white\">Aufgabe</span>\n",
    "\n",
    "Erstelle eine Klasse `Auto`, defniere einen Konstruktor, der die Eigenschaften `marke`, `modell` und `farbe` des Objektes festlegt. Erstellen anschliessend zwei verschiedene Objekte der Klasse `Auto` mit unterschiedlichen Eigenschaften und gib diese per `print()` Befehl aus.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "4e87dda3",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tesla Modell 3 Weiss\n",
      "VW Käfer Beige\n"
     ]
    }
   ],
   "source": [
    "# Beginn eigener Code\n",
    "\n",
    "class Auto:\n",
    "    def __init__(self, marke, modell, farbe):\n",
    "        self.marke = marke\n",
    "        self.modell = modell\n",
    "        self.farbe = farbe\n",
    "        \n",
    "neue_Karre = Auto(\"Tesla\", \"Modell 3\", \"Weiss\")\n",
    "alte_Karre = Auto(\"VW\", \"Käfer\", \"Beige\")\n",
    "\n",
    "print(neue_Karre.marke, neue_Karre.modell, neue_Karre.farbe)\n",
    "print(alte_Karre.marke, alte_Karre.modell, alte_Karre.farbe)\n",
    "\n",
    "# Ende eigener Code"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b008293",
   "metadata": {},
   "source": [
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a15f493-3427-4a82-904a-e593f99da994",
   "metadata": {},
   "source": [
    "## Methoden definieren\n",
    "\n",
    "Objekte haben nicht nur Eigenschaften, sondern auch Methoden. Diese können ebenfalls in der Klassendefinition festgelegt werden:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "c6ee1b78-ef37-459a-868b-20b26eb9b486",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hallo liebe Casandra\n",
      "Hallo liebe*r Andrea\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    def __init__(self, name, geschlecht):\n",
    "        self.name = name\n",
    "        self.geschlecht = geschlecht\n",
    "        \n",
    "    def guten_tag(self):\n",
    "        if self.geschlecht == \"M\":\n",
    "            print(\"Hallo lieber\", self.name)\n",
    "        elif self.geschlecht == \"F\":\n",
    "            print(\"Hallo liebe\", self.name)\n",
    "        else:\n",
    "            print(\"Hallo liebe*r\", self.name)\n",
    "            \n",
    "frau = Person(\"Casandra\", \"F\")\n",
    "non_binaer = Person(\"Andrea\", \"nicht binär\")\n",
    "\n",
    "frau.guten_tag()\n",
    "non_binaer.guten_tag()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "decc42fd-49c7-4a71-866e-0a9ef7bb3930",
   "metadata": {},
   "source": [
    "Auch bei Methoden ist der jeweils erste Parameter das Objekt selber mit dem Name `self`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4a53a7c6-9dd3-44c7-99fb-8bfbabdc0bc6",
   "metadata": {},
   "source": [
    "# Vererbung\n",
    "\n",
    "Eine wichtige Eigenschaft des ojbektorientierten Programmierens ist die **Vererbung** (*Inheritance*). Damit ist gemeint, dass neue Klassen Eigenschaften und Methoden von bestehenden Klassen übernehmen können, weil sie ihnen vererbt wurden.\n",
    "\n",
    "Vererbung wird typischerweise gebraucht, um Objekte entlang einer Objekthierarchie von sehr generischen Objekten hin zu immer spezifischeren Objekten zu entwickeln:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "8bd16bbe-1ce6-41e9-b39d-1b8db25ef914",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hallo lieber Bastian\n",
      "Die Matrikelnummer lautet: 21-001-001\n",
      "Mutmassliche Schlussnote: 4\n"
     ]
    }
   ],
   "source": [
    "from random import randint\n",
    "\n",
    "class Studierende_Person(Person):\n",
    "    def __init__(self, name, geschlecht, matrikel_nr):\n",
    "        super().__init__(name, geschlecht)\n",
    "        self.matrikel_nr = matrikel_nr\n",
    "        \n",
    "    def mutmasse_erfolg(self):\n",
    "        print(\"Mutmassliche Schlussnote:\", randint(1,6))\n",
    "        \n",
    "studi = Studierende_Person(\"Bastian\", \"M\", \"21-001-001\")\n",
    "\n",
    "studi.guten_tag()\n",
    "print(\"Die Matrikelnummer lautet:\", studi.matrikel_nr)\n",
    "studi.mutmasse_erfolg()\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fcfe063f-1915-46e5-b137-7b8fd47c2742",
   "metadata": {},
   "source": [
    "Bei der Definition der erbenden Klasse, wird in Klammern `()` die Klasse angegeben, von der geerbt werden soll. In der Definition des Konstruktors `__init__` kann auf den Konstruktor der Superklasse (diejenige Klasse, die vererbt) zurückgegriffen werden. Dies geschieht mit der Funktion `super()`. Beim expliziten Aufruf dieses Kontruktors muss `self` nicht übergeben werden.\n",
    "\n",
    "Anschliessend können in der erbenden Klasse wiederum neue Eigenschaften und Methoden definiert werden.\n",
    "\n",
    "Wenn man sich nicht sicher ist, von welcher Klasse ein Objekt ist, kann das mit der Funktion `type()` geprüft werden:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "c00dea82-100c-4564-ae5e-06525374da34",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "__main__.Studierende_Person"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(studi)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c51ec808",
   "metadata": {},
   "source": [
    "# Credits\n",
    "\n",
    "<div>Hantel Icon von <a href=\"https://www.freepik.com\" title=\"Freepik\">Freepik</a> bei <a href=\"https://www.flaticon.com/\" title=\"Flaticon\">www.flaticon.com</a></div>\n"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "1f249ec925ce4e150f1f00585c0a724a833d5f2a7ba7da4c93b858ce16dfa983"
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11"
  },
  "toc-autonumbering": true,
  "toc-showcode": false,
  "toc-showmarkdowntxt": false,
  "toc-showtags": false
 },
 "nbformat": 4,
 "nbformat_minor": 5
}