tutorials/GitHub_MD_rendering/Composition vs. inheritance.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "toc": true
   },
   "source": [
    "<h1>Table of Contents<span class=\"tocSkip\"></span></h1>\n",
""   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction\n",
    "<hr style = \"border:2px solid black\" ></hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "**What?** Composition vs. inheritance\n",
    "\n",
""   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Composition vs. inheritance\n",
    "<hr style = \"border:2px solid black\" ></hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "- Inheritance must be used when you need to **specialise** the behavior of a class, this means that you should not use inheritance **just to reuse** your code. In this paradign, any subclass is a special case of its superclass. Its paradigm follows the **is-an** pattern.\n",
    "- Composition is pretty much everythig else! Here, instead of having an **is-an** relationship we have an **has-a** one.\n",
    "    \n",
""   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# When to use inheritance\n",
    "<hr style = \"border:2px solid black\" ></hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    \n",
    "- The key point here is that a Bird (hence a special case) is an Animal and that is the relationship your classes must have in order to use inheritance. Another example could be Person and Employee, Vehicle and Car, etc.\n",
    "\n",
    "- To generalize: when a class B inherits from a class A, we often say B **is-an** A. This means that instances of B are in fact instances of A.\n",
    "\n",
""   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-11-19T13:10:21.869712Z",
     "start_time": "2022-11-19T13:10:21.866337Z"
    }
   },
   "outputs": [],
   "source": [
    "class Animal:\n",
    "    \"\"\"This is the class describing an abstraction of \n",
    "    what an animal is and does.\n",
    "\n",
    "    The rationale is that, every that goes is is shared\n",
    "    by the all the animal.\n",
    "    \"\"\"\n",
    "\n",
    "    def eat(self):\n",
    "        print(\"This animal eats!\")\n",
    "\n",
    "    def sleep(self):\n",
    "        print(\"This animal eats\")\n",
    "\n",
    "\n",
    "class Bird(Animal):\n",
    "    \"\"\"This is the class describing a special type of animal.\n",
    "\n",
    "    What is common to animal is inhertated from the Animal class.\n",
    "    Wgat is special to birds is defined here by a method.\n",
    "    \"\"\"\n",
    "\n",
    "    def fly(self):\n",
    "        print(\"This animal is a bird and it can fly!\")\n",
    "\n",
    "    def sing(self):\n",
    "        print(\"This animal is a bid and it can sing!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-11-19T13:11:27.284976Z",
     "start_time": "2022-11-19T13:11:27.282532Z"
    }
   },
   "outputs": [],
   "source": [
    "bird_one = Bird()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-11-19T13:11:30.347831Z",
     "start_time": "2022-11-19T13:11:30.343641Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__class__',\n",
       " '__delattr__',\n",
       " '__dict__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__init__',\n",
       " '__init_subclass__',\n",
       " '__le__',\n",
       " '__lt__',\n",
       " '__module__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__setattr__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__subclasshook__',\n",
       " '__weakref__',\n",
       " 'eat',\n",
       " 'fly',\n",
       " 'sing',\n",
       " 'sleep']"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(bird_one)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-11-19T13:11:54.047379Z",
     "start_time": "2022-11-19T13:11:54.044563Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This animal eats!\n"
     ]
    }
   ],
   "source": [
    "bird_one.eat()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-11-19T13:12:04.944237Z",
     "start_time": "2022-11-19T13:12:04.941494Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This animal eats\n"
     ]
    }
   ],
   "source": [
    "bird_one.sleep()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-11-19T13:12:15.142934Z",
     "start_time": "2022-11-19T13:12:15.140356Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This animal is a bird and it can fly!\n"
     ]
    }
   ],
   "source": [
    "bird_one.fly()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-11-19T13:12:20.884560Z",
     "start_time": "2022-11-19T13:12:20.881660Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This animal is a bid and it can sing!\n"
     ]
    }
   ],
   "source": [
    "bird_one.sing()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "- While using multiple inheritance (not shown here) keep in mind of what is called method resolution order (MRO).\n",
    "-vMRO is based on **C3**, which was the MRO of the Dylan programming language, and it consists of a linearization process. MRO is based on a recursive call over the base classes, looking up each parent class to create a sequence of lists, removing duplicates and conserving the order. Once this sequence of lists is created it computes a left-to-right rule to merge them all.\n",
    "\n",
""   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-11-19T13:41:59.992129Z",
     "start_time": "2022-11-19T13:41:59.988672Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(__main__.Bird, __main__.Animal, object)"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Bird.__mro__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Composition\n",
    "<hr style = \"border:2px solid black\" ></hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "- Let’s suppose that we have two classes: Car and Tire.\n",
    "- We can quickly check which one is best btw composition or inheritance by asking the following two questions:\n",
    "    - [x] A car has a tyre -> there is **has-a** relationship, hence use composition.\n",
    "    - [ ] A car is a tyre -> there isn’t any **is-an** relationship, hence do use inheritance\n",
    "\n",
""   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-11-19T13:55:50.894830Z",
     "start_time": "2022-11-19T13:55:50.891777Z"
    }
   },
   "outputs": [],
   "source": [
    "class Car:\n",
    "    def __init__(self, tyre_type):\n",
    "        self.wheels_no = 4\n",
    "        self.tyre = Tyre(tyre_type)\n",
    "\n",
    "\n",
    "class Tyre():\n",
    "    def __init__(self, tyre_type):\n",
    "        self.tyre_type = tyre_type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-11-19T13:55:58.717978Z",
     "start_time": "2022-11-19T13:55:58.715470Z"
    }
   },
   "outputs": [],
   "source": [
    "car_1 = Car(\"goodyear\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-11-19T13:56:08.329844Z",
     "start_time": "2022-11-19T13:56:08.326424Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'goodyear'"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "car_1.tyre.tyre_type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-11-19T13:56:15.797232Z",
     "start_time": "2022-11-19T13:56:15.793788Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "car_1.wheels_no"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Composition and investion of control\n",
    "<hr style = \"border:2px solid black\" ></hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "- Let’s suppose that we have two classes: Salary and Employee.\n",
    "- We can quickly check which one is best btw composition or inheritance by asking the following two questions:\n",
    "    - [x] An employee has a salary -> there is **has-a** relationship, hence use composition.\n",
    "    - [ ] An employee is a tyre -> there isn’t any **is-an** relationship, hence do use inheritance\n",
    "\n",
""   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![image.png](attachment:image.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-11-19T14:07:57.895321Z",
     "start_time": "2022-11-19T14:07:57.892142Z"
    }
   },
   "outputs": [],
   "source": [
    "class Salary:\n",
    "    def __init__(self):\n",
    "        self.amount = 100\n",
    "class Employee:\n",
    "    def __init__(self):\n",
    "        self.name = \"Mark\" \n",
    "        self.salary = Salary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-11-19T14:08:48.172801Z",
     "start_time": "2022-11-19T14:08:48.169282Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mark\n",
      "100\n"
     ]
    }
   ],
   "source": [
    "employee_1 = Employee()\n",
    "print(employee_1.name)\n",
    "print(employee_1.salary.amount)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "- If we pay attention to this implementation we will see some coupling between classes.\n",
    "- In fact, if we would like to replace Salary with another class we will also need to change the Employee class, so a good advice is to combine composition with **inversion of control**.\n",
    "\n",
""   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-11-19T14:12:01.671234Z",
     "start_time": "2022-11-19T14:12:01.668142Z"
    }
   },
   "outputs": [],
   "source": [
    "class Salary:\n",
    "    def __init__(self):\n",
    "        self.amount = 100\n",
    "\n",
    "\n",
    "class Employee:\n",
    "    def __init__(self, salary):\n",
    "        self.name = \"Mark\"\n",
    "        self.salary = salary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-11-19T14:12:15.453289Z",
     "start_time": "2022-11-19T14:12:15.449947Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mark\n",
      "100\n"
     ]
    }
   ],
   "source": [
    "employee_1 = Employee(salary=Salary())\n",
    "print(employee_1.name)\n",
    "print(employee_1.salary.amount)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Conclusions\n",
    "<hr style = \"border:2px solid black\" ></hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "- Inheritance and composition are quite different concepts and they respond to different relationship between classes.\n",
    "- If classes have a **is-a relationship** then inheritance is the right choice, if they have a **has-a relationship** then it’s a composition.\n",
    "- Even if inheritance is the right choice you will still be coupling classes together, for that reason composition often produces more flexible designs, and it’s even better when combined with other patterns like inversion of control to decouple the classes.\n",
    "\n",
""   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# References\n",
    "<hr style = \"border:2px solid black\" ></hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "- https://python-patterns.guide/gang-of-four/composition-over-inheritance/\n",
    "- https://medium.com/@carbone.nicolas.ariel/inheritance-and-composition-in-python-f84dfeffefb7\n",
    "\n",
""   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.9.7"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {
    "height": "169px",
    "width": "252px"
   },
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": true,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "253px"
   },
   "toc_section_display": "block",
   "toc_window_display": true
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}