wbs-python/python/aufgaben_tag2.ipynb

{
 "cells": [
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "# Aufgabe 1\n",
    "## Aufgabenstellung\n",
    "Erstellen Sie die Klasse \"Song\" mit den Attributen string \"titel\", int \"dauer_sekunden\", string \"interpret\" und der Methode \"Spielen\", die auf der Konsole alle Informationen über den Song ausgibt (die Dauer dabei in Minuten:Sekunden -> 03:35)\n",
    "\n",
    "- Die Attribute sollen private sein mit öffentlichen Gettern als Eingeschaft\n",
    "- Über einen Konstruktor sollen die Attribute initialisiert werden."
   ],
   "id": "906e4e84eba33aab"
  },
  {
   "cell_type": "code",
   "id": "initial_id",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "class Song:\n",
    "    def __init__(self, titel:str, dauer_sekunden:int, interpret:str, *args):\n",
    "        self.__titel = titel\n",
    "        self.__dauer_sekunden = dauer_sekunden\n",
    "        self.__interpret = interpret\n",
    "        super().__init__(*args)\n",
    "\n",
    "    @property\n",
    "    def titel(self) -> str:\n",
    "        return self.__titel\n",
    "\n",
    "    @property\n",
    "    def dauer_sekunden(self) -> int:\n",
    "        return self.__dauer_sekunden\n",
    "\n",
    "    @property\n",
    "    def interpret(self) -> str:\n",
    "        return self.__interpret\n",
    "\n",
    "    def spielen(self) -> None:\n",
    "        minuten = self.__dauer_sekunden // 60\n",
    "        restsekunden = self.__dauer_sekunden % 60\n",
    "\n",
    "        print(f\"{self.__titel} von {self.__interpret}, Dauer: {minuten:02d}:{restsekunden:02d} Minuten\")"
   ],
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "Erstellen Sie in der Main einen Song und rufen Sie die Methode auf.",
   "id": "91a0f43537a3d9b4"
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "song = Song(\"Hallo\", 125, \"Welt\")\n",
    "song.spielen()"
   ],
   "id": "648e48c76d987a94",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "# Aufgabe 2\n",
    "## Aufgabenstellung\n",
    "Sie bauen einen Robot. Erstellen Sie die Klasse Robot mit folgenden Membern:\n",
    "\n",
    "- Integer \"battery_time\"\n",
    "- String \"task\"\n",
    "- Methode \"is_battery_time_low\":\n",
    "    - gibt true zurück, wenn die Laufzeit kleiner 2 ist, sonst false.\n",
    "- Methode \"execute_task\":\n",
    "    - gibt auf dem Bildschirm den Text des Attributs \"aufgabe\" aus, wenn \"is_battery_time_low\" false liefert und reduziert dann die battery_time um 1, sonst soll \"Ich muss aufgeladen werden.\" in der Konsole erscheinen."
   ],
   "id": "236fa9f5181f518d"
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "class Robot:\n",
    "    def __init__(self, battery_time:int, task:str, *args):\n",
    "        self.__battery_time = battery_time\n",
    "        self.__task = task\n",
    "        super().__init__(*args)\n",
    "\n",
    "    def is_battery_time_low(self) -> bool:\n",
    "        return self.__battery_time < 2\n",
    "\n",
    "    def execute_task(self) -> None:\n",
    "        if self.is_battery_time_low():\n",
    "            print(\"Ich muss aufgeladen werden\")\n",
    "            return\n",
    "\n",
    "        print(self.__task)\n",
    "        self.__battery_time -= 1"
   ],
   "id": "64c12bd54e52cf60",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "Erstellen Sie in der Main einen Roboter mit der Aufgabe \"Ich reiche Butter.\" und einer Batterielaufzeit von 5.\n",
    "\n",
    "Lassen Sie ihn fünfmal in einer Schleife Butter reichen."
   ],
   "id": "3f89c8f76710d139"
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "robot = Robot(5, \"Ich reiche Butter.\")\n",
    "for i in range(5):\n",
    "    robot.execute_task()"
   ],
   "id": "c2217f3770898f37",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "# Aufgabe 3\n",
    "## Aufgabenstellung\n",
    "Zwei Klassen:\n",
    "- \"Buch\" mit dem Attribut \"titel\" (public get)\n",
    "- \"Autor\" mit dem Attribut \"name\" (public get)\n",
    "\n",
    "jeweils einen Konstruktor, der die Eigenschaften initialisiert.\n",
    "\n",
    "Implementieren Sie die Assoziation der beiden Klassen und stellen Sie eine bidirektionale Navigierbarkeit her. Dazu\n",
    "müssen Sie den Klassen weitere Member hinzufügen. (Gehen Sie davon aus, dass ein Buch mehrere Autoren haben und ein\n",
    "Autor mehrere Bücher verfassen kann)"
   ],
   "id": "4c09b6fb40b8d1f9"
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "class Author:\n",
    "    def __init__(self, name, *args):\n",
    "        self.__name = name\n",
    "        self.__books = []\n",
    "        super().__init__(*args)\n",
    "\n",
    "    @property\n",
    "    def name(self):\n",
    "        return self.__name\n",
    "\n",
    "    @property\n",
    "    def books(self):\n",
    "        return self.__books\n",
    "\n",
    "    @books.setter\n",
    "    def books(self, books) -> None:\n",
    "        self.__books = books\n",
    "\n",
    "\n",
    "    def __str__(self):\n",
    "        return \"Name: \" + self.__name"
   ],
   "id": "9dee92e77e3508c9",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "class Book:\n",
    "    def __init__(self, title: str, authors: list):\n",
    "        self.__title = title\n",
    "        self.__authors = authors\n",
    "\n",
    "        a: Author  # Typ-Hinweis\n",
    "        for a in authors:\n",
    "            a.books.append(self)  # Füge allen übergebenen Authors das Book hinzu.\n",
    "\n",
    "    @property\n",
    "    def title(self):\n",
    "        return self.__title\n",
    "\n",
    "    @property\n",
    "    def authors(self):\n",
    "        return self.__authors\n",
    "\n",
    "    @authors.setter\n",
    "    def authors(self, authors):\n",
    "        self.__authors = authors\n",
    "\n",
    "    def __str__(self):\n",
    "        string = \"Title: \" + self.__title + \"\\n\" + \"Authors: \\n\"\n",
    "        for a in self.__authors:\n",
    "            string += str(a) + \"\\n\"\n",
    "        return string"
   ],
   "id": "4b7aee3b3776c94f",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "Testen Sie das Programm im Main.",
   "id": "1100bf56fd8decd0"
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "a1 = Author(\"Carl Sagan\")\n",
    "a2 = Author(\"Jerome Agel\")\n",
    "a3 = Author(\"Jonathan Norton Leonard\")\n",
    "\n",
    "b1 = Book(\"Nachbarn im Kosmos\", [a1, a2])\n",
    "b2 = Book(\"Die Planeten\", [a1, a3])\n",
    "\n",
    "# Ausgabe aller Books der jeweiligen Authors\n",
    "for b in a1.books:\n",
    "    print(b)\n",
    "\n",
    "for b in a2.books:\n",
    "    print(b)\n",
    "\n",
    "for b in a3.books:\n",
    "    print(b)"
   ],
   "id": "a9a21cf8add5b47a",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "# Aufgabe 4\n",
    "## Aufgabenstellung\n",
    "Erstellen Sie bitte die Klassen Spellcaster, Sorcerer, Wizard, WildMagicSorcerer und IllusionWizard:\n",
    "- Sorcerer und Wizard sind Spellcaster.\n",
    "- WildMagicSorcerer ist ein Sorcerer und IllusionWizard ist ein Wizard.\n",
    "\n",
    "- Alle Spellcaster verfügen über die Methode \"castSpell()\"\n",
    "- In Spellcaster gibt die Methode \"Ich kann zaubern.\" aus.\n",
    "\n",
    "Sorcerer und Wizard überschreiben diese Methode.\n",
    "- Sorcerer gibt \"Ich kann zaubern.\" und \"Meine Zauberkraft ist mir angeboren.\" aus.\n",
    "- Wizard gibt \"Ich kann zaubern.\" und \"Für meine Zauberkraft musste ich hart arbeiten.\" aus.\n",
    "WildMagicSorcerer und IllusionWizard überschreiben und versiegeln(finalize) die Methode.\n",
    "- WildMagicSorcerer gibt \"Ich kann zaubern.\", \"Meine Zauberkraft ist mir angeboren.\" und \"Meine Zauber sind unberechenbar.\" aus.\n",
    "- IllusionWizard gibt \"Ich kann zaubern.\", \"Für meine Zauberkraft musste ich hart arbeiten.\"  und \"Ich habe mich auf\n",
    "Illusionszauber spezialisiert.\" aus.\n",
    "\n",
    "Vermeiden Sie beim Überschreiben der Methode doppelten Code!"
   ],
   "id": "2108e544f058d539"
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "class Spellcaster(object):\n",
    "    def cast_spell(self):\n",
    "        print(\"Ich kann zaubern.\")\n",
    "\n",
    "\n",
    "class Sorcerer(Spellcaster):\n",
    "    def cast_spell(self):\n",
    "        super().cast_spell()\n",
    "        print(\"Meine Zauberkraft ist mir angeboren.\")\n",
    "\n",
    "\n",
    "class Wizard(Spellcaster):\n",
    "    def cast_spell(self):\n",
    "        super().cast_spell()\n",
    "        print(\"Für meine Zauberkraft musste ich hart arbeiten.\")\n",
    "\n",
    "\n",
    "class WildMagicSorcerer(Sorcerer):\n",
    "    def cast_spell(self):\n",
    "        super().cast_spell()\n",
    "        print(\"Meine Zauber sind unberechenbar.\")\n",
    "\n",
    "\n",
    "class IllusionWizard(Wizard):\n",
    "    def cast_spell(self):\n",
    "        super().cast_spell()\n",
    "        print(\"Ich habe mich auf Illusionszauber spezialisiert.\")"
   ],
   "id": "9f4ca8d209e3898c",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "In der Main erzeugen Sie einen wildMagicSorcerer und einen illusionWizard und rufen für beide die castSpell()-Methode auf.",
   "id": "88c78295e6ff733b"
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "sorcerer = WildMagicSorcerer()\n",
    "wizard = IllusionWizard()\n",
    "sorcerer.cast_spell()\n",
    "wizard.cast_spell()"
   ],
   "id": "28ce197ac73ed492",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "# Aufgabe 5\n",
    "## Aufgabenstellung\n",
    "Sie sollen eine Anwendung für einen Shop schreiben. Im Shop gibt es viele Artikel, die mit Id, Bezeichnung, Einkaufspreis, Gewinnsatz und Verkaufspreis gespeichert werden. Der Verkaufspreis wird dabei immer aus Einkaufspreis + Gewinn errechnet.\n",
    "\n",
    "Artikel, die gekauft werden, werden mit Mengenangabe in einen Warenkorb gelegt. Es sollen Artikel in den Warenkorb gelegt und wieder entfernt werden können. Ebenfalls soll es möglich sein, die Anzahl eines Artikels ändern zu können. Über den Warenkorb wird der Gesamtpreis aller sich dort befindenden Artikel ermittelt.\n",
    "\n",
    "Artikel im Warenkorb werden dort als Warenkorb-Items eingetragen. Ein Warenkorb-Item besteht aus dem Artikel selbst und der Anzahl. Ebenfalls soll der Gesamtpreis für diesen Artikel abgefragt werden können.\n",
    "\n",
    "Es ist nicht erforderlich, ein Eingabe-Menü zu basteln. Es reicht, die einzelnen Fälle über Code in der Main zu testen.\n",
    "\n",
    "Wichtig für diese Übung: Beachten Sie die Prinzipien der OOP. Insbesondere die Klassenbildung und Datenkapselung / Geheimnisprinzip.\n",
    "\n",
    "Ebenso sollen Sie die strikte Trennung von Funktionalität / Datenhaltung und Darstellung beachten. Heißt: Dort, wo die Daten gespeichert sind und Funktionalitäten liegen, wird KEINE Konsolenausgabe getätigt. Konsolenausgaben nur in dafür vorgesehenen eigenen Klassen oder zum Beispiel in der Main."
   ],
   "id": "dabe541b90e049b1"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "## Bearbeitung\n",
    "Sie sollen eine Anwendung für einen Shop schreiben. Im Shop gibt es viele Artikel, die mit Id, Bezeichnung, Einkaufspreis, Gewinnsatz und Verkaufspreis gespeichert werden. Der Verkaufspreis wird dabei immer aus Einkaufspreis + Gewinn errechnet."
   ],
   "id": "152f0dfd54408937"
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "class Artikel:\n",
    "    def __init__(self, id, bezeichnung: str, einkaufspreis: float, gewinnsatz: float):  # Angabe von konkreten Datentypen\n",
    "        self.id = id\n",
    "        self.bezeichnung = bezeichnung\n",
    "        self.einkaufspreis = einkaufspreis\n",
    "        self.gewinnsatz = gewinnsatz\n",
    "\n",
    "\n",
    "    @property\n",
    "    def verkaufspreis(self) -> float:  # Angabe von Rückgabetyp\n",
    "        return self.einkaufspreis * (1 + self.gewinnsatz / 100)"
   ],
   "id": "f876b667a5783072",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "Artikel im Warenkorb werden dort als Warenkorb-Items eingetragen. Ein Warenkorb-Item besteht aus dem Artikel selbst und der Anzahl. Ebenfalls soll der Gesamtpreis für diesen Artikel abgefragt werden können.",
   "id": "9b3dba2c6071ca86"
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "class WarenkorbItem:\n",
    "    def __init__(self, artikel: Artikel, anzahl: int):\n",
    "        self.artikel = artikel\n",
    "        self.anzahl = anzahl\n",
    "\n",
    "    @property\n",
    "    def gesamtpreis(self) -> float:\n",
    "        return self.artikel.verkaufspreis * self.anzahl"
   ],
   "id": "1590b144e6e119a2",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "Artikel, die gekauft werden, werden mit Mengenangabe in einen Warenkorb gelegt. Es sollen Artikel in den Warenkorb gelegt und wieder entfernt werden können. Ebenfalls soll es möglich sein, die Anzahl eines Artikels ändern zu können. Über den Warenkorb wird der Gesamtpreis aller sich dort befindenden Artikel ermittelt.",
   "id": "26737f39f9902970"
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "class Warenkorb:\n",
    "    def __init__(self):\n",
    "        self.liste = []\n",
    "\n",
    "    def add_artikel(self, artikel, anzahl: int):\n",
    "        item = self.find_item(artikel)\n",
    "        if item is None:\n",
    "            self.liste.append(WarenkorbItem(artikel, anzahl))\n",
    "        else:\n",
    "            item.anzahl = item.anzahl + anzahl\n",
    "\n",
    "    def remove_artikel(self, artikel: Artikel, anzahl: int) -> bool:\n",
    "        item = self.find_item(artikel)\n",
    "        if item is None:\n",
    "            return False\n",
    "        if item.anzahl - anzahl > 0:\n",
    "            item.anzahl = item.anzahl - anzahl\n",
    "        else:\n",
    "            self.liste.remove(item)\n",
    "        return True\n",
    "\n",
    "    def find_item(self, artikel: Artikel) -> WarenkorbItem | None:\n",
    "        for item in self.liste:\n",
    "            if item.artikel == artikel:\n",
    "                return item\n",
    "        return None\n",
    "\n",
    "    @property\n",
    "    def gesamtpreis(self) -> float:\n",
    "        summe = 0\n",
    "        item: WarenkorbItem\n",
    "        for item in self.liste:\n",
    "            summe = summe + item.gesamtpreis\n",
    "\n",
    "        return summe"
   ],
   "id": "edcaca28fe6a6cb0",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "apfel = Artikel(1, \"Apfel\", 1.00, 10)\n",
    "birne = Artikel(2, \"Birne\", 1.10, 10)\n",
    "warenkorb = Warenkorb()\n",
    "warenkorb.add_artikel(apfel, 10)\n",
    "print(warenkorb.gesamtpreis)\n",
    "print(warenkorb.remove_artikel(apfel, 5))\n",
    "warenkorb.add_artikel(apfel, 10)\n",
    "print(warenkorb.gesamtpreis)\n",
    "print(warenkorb.remove_artikel(birne, 5))\n",
    "print(warenkorb.remove_artikel(apfel, 15))\n",
    "print(warenkorb.gesamtpreis)"
   ],
   "id": "769c973f4a9ec4a5",
   "outputs": [],
   "execution_count": null
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}