c11b-python-programowanie-obiektowe-method-rozwiazania.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python: Programowanie obiektowe: metody - zadania"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## OOP Method Sequence\n",
    "\n",
    "1. Stwórz klasę ``Iris`` z atrybutami ``features: List[float]`` i ``label: str``\n",
    "1. Dla każdego wiersza w ``DATA`` twórz instancję ``Iris`` z danymi z wiersza\n",
    "1. Ustaw atrybuty klasy przy inicjalizacji z argumentów pozycyjnych\n",
    "1. Stwórz metodę sumującą wartości wszystkich ``features``\n",
    "1. Wypisz nazwę gatunku i wynik metody sumującej\n",
    "1. Porównaj wyniki z sekcją \"Output\" (patrz poniżej)\n",
    "\n",
    "Output:\n",
    "```text\n",
    "setosa 9.4\n",
    "versicolor 16.299999999999997\n",
    "virginica 19.3\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "DATA = [\n",
    "    (4.7, 3.2, 1.3, 0.2, 'setosa'),\n",
    "    (7.0, 3.2, 4.7, 1.4, 'versicolor'),\n",
    "    (7.6, 3.0, 6.6, 2.1, 'virginica'),\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "setosa 9.4\n",
      "versicolor 16.299999999999997\n",
      "virginica 19.3\n"
     ]
    }
   ],
   "source": [
    "class Iris:\n",
    "    def __init__(self, features, label):\n",
    "        self.features = features\n",
    "        self.label = label\n",
    "        \n",
    "    def sum(self):\n",
    "        return sum(self.features)\n",
    "   \n",
    "\n",
    "for *features, label in DATA:\n",
    "    iris = Iris(features, label)\n",
    "    \n",
    "    print(f'{iris.label} {iris.sum()}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## OOP Method Nested\n",
    "\n",
    "1. Użyj danych z sekcji \"Input\" (patrz poniżej)\n",
    "1. Zdefiniuj klasę ``Iris``\n",
    "1. ``Iris`` ma:\n",
    "\n",
    "    * \"Sepal length\" typu ``float``\n",
    "    * \"Sepal width\" typu ``float``\n",
    "    * \"Petal length\" typu ``float``\n",
    "    * \"Petal width\" typu ``float``\n",
    "    * \"Species\" typu ``str``\n",
    "\n",
    "1. ``Iris`` może:\n",
    "\n",
    "    * Zwrócić liczbę pól typu ``float``\n",
    "    * Zwrócić listę wartości wszystkich pól typu ``float``\n",
    "    * Zwrócić sumę wartości pól typu ``float``\n",
    "    * Zwrócić średnią arytmetyczną wartość pól typu ``float``\n",
    "\n",
    "1. Użyj iterowania po ``self.__dict__`` do zwrócenia wartości pól numerycznych\n",
    "1. Stwórz obiekt ``setosa`` z atrybutami ustawionymi przy inicjalizacji\n",
    "1. Stwórz obiekt ``virginica`` z atrybutami ustawionymi przy inicjalizacji\n",
    "1. Wypisz sumę, średnią oraz nazwę gatunku każdego z obiektów\n",
    "1. Nie używaj ``@dataclass``\n",
    "1. Porównaj wyniki z sekcją \"Output\" (patrz poniżej)\n",
    "\n",
    "Output:\n",
    "```\n",
    "total=10.20 mean=2.55 setosa\n",
    "total=15.50 mean=3.88 virginica\n",
    "```\n",
    "\n",
    "Podpowiedź:\n",
    "* ``isinstance(value, float)``"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total=10.2 mean=2.55 setosa\n",
      "total=15.5 mean=3.88 virginica\n"
     ]
    }
   ],
   "source": [
    "class Iris:\n",
    "    def __init__(self, sepal_length, sepal_width,\n",
    "                petal_length, petal_width, species):\n",
    "\n",
    "        self.sepal_length = sepal_length\n",
    "        self.sepal_width = sepal_width\n",
    "        self.petal_length = petal_length\n",
    "        self.petal_width = petal_width\n",
    "        self.species = species\n",
    "\n",
    "    def values(self):\n",
    "        return [x for x in self.__dict__.values() if isinstance(x, float)]\n",
    "    \n",
    "    def len(self):\n",
    "        return len(self.values())\n",
    "\n",
    "    def sum(self):\n",
    "        return sum(self.values())\n",
    "        \n",
    "    def mean(self):\n",
    "        return self.sum() / self.len()\n",
    "    \n",
    "    def show(self):\n",
    "        return f'total={self.sum()} mean={self.mean():.2f} {self.species}'\n",
    "    \n",
    "setosa = Iris(5.1, 3.5, 1.4, 0.2, 'setosa')\n",
    "virginica = Iris(5.8, 2.7, 5.1, 1.9, 'virginica')\n",
    "\n",
    "print(f'{setosa.show()}')\n",
    "print(f'{virginica.show()}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## OOP Stringify Str\n",
    "\n",
    "1. Użyj kodu z sekcji \"Input\" (patrz poniżej)\n",
    "1. Przy wypisywaniu obiektu pokaż: nazwę gatunku i wynik metody sumującej\n",
    "1. Wynik sumowania zaokrąglij do jednego miejsca po przecinku\n",
    "1. Porównaj wyniki z sekcją \"Output\" (patrz poniżej)\n",
    "\n",
    "Output:\n",
    "```\n",
    "setosa 9.4\n",
    "versicolor 16.3\n",
    "virginica 19.3\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "setosa 9.4\n",
      "versicolor 16.3\n",
      "virginica 19.3\n"
     ]
    }
   ],
   "source": [
    "DATA = [\n",
    "    (4.7, 3.2, 1.3, 0.2, 'setosa'),\n",
    "    (7.0, 3.2, 4.7, 1.4, 'versicolor'),\n",
    "    (7.6, 3.0, 6.6, 2.1, 'virginica'),\n",
    "]\n",
    "\n",
    "\n",
    "class Iris:\n",
    "    def __init__(self, features, label):\n",
    "        self.features = features\n",
    "        self.label = label\n",
    "        \n",
    "    def sum(self):\n",
    "        return sum(self.features)\n",
    "        \n",
    "    def __str__(self):\n",
    "        return f'{self.label} {self.sum():.1f}'\n",
    "        \n",
    "\n",
    "for *features, label in DATA:\n",
    "    iris = Iris(features, label)\n",
    "    print(iris)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## OOP Stringify Repr\n",
    "\n",
    "1. Użyj kodu z sekcji \"Input\" (patrz poniżej)\n",
    "1. Wypisz reprezentację każdej z instancji z wartościami (użyj ``repr()``)\n",
    "1. Wynik sumowania zaokrąglij do dwóch miejsc po przecinku\n",
    "1. Porównaj wyniki z sekcją \"Output\" (patrz poniżej)\n",
    "\n",
    "Output:\n",
    "```python\n",
    "result: List[Iris]\n",
    "# [Iris(features=[7.6, 3.0, 6.6, 2.1], label='virginica'),\n",
    "#  Iris(features=[7.6, 3.0, 6.6, 2.1], label='virginica'),\n",
    "#  Iris(features=[7.6, 3.0, 6.6, 2.1], label='virginica')]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Iris(features=[4.7, 3.2, 1.3, 0.2], label='virginica'),\n",
       " Iris(features=[7.0, 3.2, 4.7, 1.4], label='virginica'),\n",
       " Iris(features=[7.6, 3.0, 6.6, 2.1], label='virginica')]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "DATA = [\n",
    "    (4.7, 3.2, 1.3, 0.2, 'setosa'),\n",
    "    (7.0, 3.2, 4.7, 1.4, 'versicolor'),\n",
    "    (7.6, 3.0, 6.6, 2.1, 'virginica'),\n",
    "]\n",
    "\n",
    "\n",
    "class Iris:\n",
    "    def __init__(self, features, label):\n",
    "        self.features = features\n",
    "        self.label = label\n",
    "\n",
    "    def __repr__(self):\n",
    "        return f'Iris(features={self.features}, label=\\'{label}\\')'\n",
    "\n",
    "result = [Iris(X,y) for *X,y in DATA]\n",
    "result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## OOP Stringify Nested\n",
    "\n",
    "1. Użyj kodu z sekcji \"Input\" (patrz poniżej)\n",
    "1. Przeciąż ``str`` i ``repr`` aby osiągnąć oczekiwany rezultat wypisywania\n",
    "1. Porównaj wyniki z sekcją \"Output\" (patrz poniżej)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Crew:\n",
    "    def __init__(self, members=()):\n",
    "        self.members = list(members)\n",
    "        \n",
    "    def __str__(self):\n",
    "        return '\\n'.join(str(x) for x in self.members)\n",
    "        \n",
    "\n",
    "class Astronaut:\n",
    "    def __init__(self, name, experience=()):\n",
    "        self.name = name\n",
    "        self.experience = list(experience)\n",
    "        \n",
    "    def __str__(self):\n",
    "        if self.experience:\n",
    "            return f'{self.name} veteran of {self.experience}'\n",
    "        else:\n",
    "            return f'{self.name}'\n",
    "\n",
    "        \n",
    "    def __repr__(self):\n",
    "        return self.__str__()\n",
    "        \n",
    "\n",
    "class Mission:\n",
    "    def __init__(self, year, name):\n",
    "        self.year = year\n",
    "        self.name = name\n",
    "        \n",
    "    def __repr__(self):\n",
    "        return f'\\n\\t{self.year}: {self.name}'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Commander: \n",
      "Melissa Lewis\n",
      "\n"
     ]
    }
   ],
   "source": [
    "melissa = Astronaut('Melissa Lewis')\n",
    "\n",
    "print(f'Commander: \\n{melissa}\\n')\n",
    "# Commander:\n",
    "# Melissa Lewis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Space Pirate: \n",
      "Mark Watney veteran of [\n",
      "\t2035: Ares 3]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "mark = Astronaut('Mark Watney', experience=[\n",
    "    Mission(2035, 'Ares 3'),\n",
    "])\n",
    "\n",
    "print(f'Space Pirate: \\n{mark}\\n')\n",
    "# Space Pirate:\n",
    "# Mark Watney veteran of [\n",
    "# \t2035: Ares 3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Crew: \n",
      "Jan Twardowski veteran of [\n",
      "\t1969: Apollo 11, \n",
      "\t2024: Artemis 3]\n",
      "José Jiménez\n",
      "Mark Watney veteran of [\n",
      "\t2035: Ares 3]\n"
     ]
    }
   ],
   "source": [
    "crew = Crew([\n",
    "    Astronaut('Jan Twardowski', experience=[\n",
    "        Mission(1969, 'Apollo 11'),\n",
    "        Mission(2024, 'Artemis 3'),\n",
    "    ]),\n",
    "    Astronaut('José Jiménez'),\n",
    "    Astronaut('Mark Watney', experience=[\n",
    "        Mission(2035, 'Ares 3'),\n",
    "    ]),\n",
    "])\n",
    "\n",
    "print(f'Crew: \\n{crew}')\n",
    "# Crew:\n",
    "# Jan Twardowski veteran of [\n",
    "# \t1969: Apollo 11,\n",
    "# \t2024: Artemis 3]\n",
    "# José Jiménez\n",
    "# Mark Watney veteran of [\n",
    "# \t2035: Ares 3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## OOP Inheritance Simple\n",
    "\n",
    "1. Stwórz klasę ``Mars``\n",
    "1. Stwórz klasę ``Venus``\n",
    "1. Stwórz klasę ``Woman``, która dziedziczy po ``Venus``\n",
    "1. Stwórz klasę ``Man``, która dziedziczy po ``Mars``"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Venus:\n",
    "    pass\n",
    "\n",
    "class Mars:\n",
    "    pass\n",
    "\n",
    "class Woman(Venus):\n",
    "    pass\n",
    "\n",
    "class Man(Mars):\n",
    "    pass\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## OOP Inheritance Multiple\n",
    "\n",
    "1. Stwórz klasy ``Engineer``, ``Scientist``, ``Pilot``, ``MedicalDoctor``\n",
    "1. Stwórz klasę ``Astronaut``, która dziedziczy po tych wszystkich klasach"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Engineer:\n",
    "    pass\n",
    "\n",
    "class Scientist:\n",
    "    pass\n",
    "\n",
    "class Pilot:\n",
    "    pass\n",
    "\n",
    "class MedicalDoctor:\n",
    "    pass\n",
    "\n",
    "class Astronaut(Engineer, Scientist, Pilot, MedicalDoctor):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## OOP Inheritance Super\n",
    "\n",
    "1. Użyj danych z sekcji \"Input\" (patrz poniżej)\n",
    "1. Stwórz klasę ``Crew``\n",
    "1. W ``__init__()`` ustaw ``mission`` na ``Ares 3``\n",
    "1. Stwórz klasę ``Astronaut`` dziedziczącą po ``Crew``\n",
    "1. Używając parametrów pozycyjnych podanych przy inicjalizacji ustaw imię i nazwisko astronauty\n",
    "1. Każdy astronauta musi mieć przydzieloną misję (odziedziczoną z ``Crew``)\n",
    "1. Zwróć imię, nazwisko i nazwę misji from ``__str__()``\n",
    "1. Porównaj wyniki z sekcją \"Output\" (patrz poniżej)\n",
    "\n",
    "\n",
    "Output:\n",
    "```\n",
    "Astronaut crew:\n",
    "- Mark Watney (Ares 3)\n",
    "- Melissa Lewis (Ares 3)\n",
    "- Alex Vogel (Ares 3)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Astronaut crew:\n",
      "- Mark Watney (Ares 3)\n",
      "- Melissa Lewis (Ares 3)\n",
      "- Alex Vogel (Ares 3)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "class Crew:\n",
    "    def __init__(self):\n",
    "        self.mission = 'Ares 3'\n",
    "\n",
    "        \n",
    "class Astronaut(Crew):\n",
    "    def __init__(self, name):\n",
    "        self.firstname, self.lastname = name.split()\n",
    "        super().__init__()\n",
    "    \n",
    "    def __str__(self):\n",
    "        return f'{self.firstname} {self.lastname} ({self.mission})'\n",
    "\n",
    "    \n",
    "mark = Astronaut('Mark Watney')\n",
    "melissa = Astronaut('Melissa Lewis')\n",
    "alex = Astronaut('Alex Vogel')\n",
    "\n",
    "result = f\"\"\"\n",
    "Astronaut crew:\n",
    "- {mark}\n",
    "- {melissa}\n",
    "- {alex}\n",
    "\"\"\"\n",
    "\n",
    "print(result)"
   ]
  },
  {
   "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.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}