24 - Python 10min a day - Parents children and inheritance.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"assets/jeremy-lapak-CVvFVQ_-oUg-unsplash.png\" alt=\"Python Envs\" style=\"display: block; margin: 0 auto\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Learning Python 10 minutes a day #24\n",
    "## Parents, children, and inheritance\n",
    "[Medium article link](https://towardsdatascience.com/learning-python-10-minutes-a-day-24-71adee92cb2d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is a [series](https://python-10-minutes-a-day.rocks) of short 10 minute Python articles helping you to get started with Python. I try to post an article each day (no promises), starting from the very basics, going up to more complex idioms. Feel free to contact me on [LinkedIn](https://www.linkedin.com/in/dennisbakhuis/) for questions or requests on particular subjects of Python, you want to know about."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Yesterday, we talked about classes and how to use the object oriented programming (OOP) paradigm to address problems. The objects that we create can mimic real-life objects and the data and methods are all bundled inside the class. We also discussed some of the inner workings of Python: it uses dunder-methods to define interactions between objects. The thing we did not yet mention is seen as a major benefit of OOP: inheritance. Inheritance is the ability to create a new so called child-class that inherits properties from its parent class. Lets first have a look if we would not use inheritance:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Rectangle:\n",
    "    def __init__(self, length, width):\n",
    "        self.length = length\n",
    "        self.width = width\n",
    "        \n",
    "    def __repr__(self):\n",
    "        return f'I have a length of {self.length} and a width of {self.width}'\n",
    "    \n",
    "    def perimeter(self):\n",
    "        return 2 * self.length + 2 * self.width\n",
    "    \n",
    "    def area(self):\n",
    "        return self.length * self.width\n",
    "    \n",
    "class Square:\n",
    "    def __init__(self, length):\n",
    "        self.length = length\n",
    "        \n",
    "    def __repr__(self):\n",
    "        return f'I have a length and width of {self.length}'\n",
    "    \n",
    "    def perimeter(self):\n",
    "        return 4 * self.length\n",
    "    \n",
    "    def area(self):\n",
    "        return self.length ** 2\n",
    "\n",
    "rectangle = Rectangle(2, 4)\n",
    "square = Square(2)\n",
    "print('rectangle perimeter is', rectangle.perimeter())\n",
    "print('square area is', square.area())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While this is fine, we all know that a Square is a special type of Rectangle with both the length and width the same size. Writing two individual classes seems very [WET](https://towardsdatascience.com/learning-python-10-minutes-a-day-9-60ecdf101cb5) and as the objects are very related, we can make use of inheritance:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Rectangle:\n",
    "    def __init__(self, length, width):\n",
    "        self.length = length\n",
    "        self.width = width\n",
    "        \n",
    "    def __repr__(self):\n",
    "        return f'I have a length of {self.length} and a width of {self.width}'\n",
    "    \n",
    "    def perimeter(self):\n",
    "        return 2 * self.length + 2 * self.width\n",
    "    \n",
    "    def area(self):\n",
    "        return self.length * self.width\n",
    "    \n",
    "class Square(Rectangle):\n",
    "    def __init__(self, length):\n",
    "        super().__init__(length, length)\n",
    "        \n",
    "    def __repr__(self):\n",
    "        return f'I have a length and width of {self.length}'\n",
    "    \n",
    "rectangle = Rectangle(2, 4)\n",
    "square = Square(2)\n",
    "print('rectangle perimeter is', rectangle.perimeter())\n",
    "print('square area is', square.area())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Code-wise, we have a small benefit as we did not have to repeat the methods for perimeter and area. The biggest benefit is however that we have the definition for those methods in one place instead of two. Would we make a mistake in one of these two methods, we only need to correct one definition."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets now analyze what is actually happening here. The Rectangle class was not changed so there is nothing to discuss. The Square class however has the Rectangle class added between parenthesis in the main definition. Using this syntax we define that the Square class is built with  the Rectangle as a basis and thereby, inherits all of its properties. Next, we define a constructor but as we inherit all the properties from the Rectangle class, we are actually overwriting the inherited constructor. The new constructor only takes the length, as all sides of a square are equally sized. Now comes something special: we call the constructor or the parent class. To access the parent class, Python has the super() function. It returns the definition of the parent class and by directly calling the dunder init method, we can call the original constructor. The original constructor expects a length and width which we supply by entering the length twice. The original constructor adds these values to the self object, the object that holds the instance its data. The new definition also overwrites the repr dunder method. If we would not have overwritten the method, it would use the method from the Rectangle class. Here is another example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Animal:\n",
    "    def __init__(self, animal_name, number_of_legs):\n",
    "        self.animal_name = animal_name\n",
    "        self.number_of_legs = number_of_legs\n",
    "    \n",
    "    def __repr__(self):\n",
    "        return f'Hi, my name is {self.animal_name} and I have {self.number_of_legs} legs'\n",
    "    \n",
    "    def walk(self):\n",
    "        print(f'I walk on my {self.number_of_legs} legs!')\n",
    "\n",
    "class Bird(Animal):\n",
    "    def __init__(self, bird_name):\n",
    "        super().__init__(bird_name, 2)\n",
    "    \n",
    "    def fly(self):\n",
    "        print(f'I am a {self.animal_name} so I can fly!')\n",
    "\n",
    "bird = Bird('Swallow')\n",
    "print(bird)\n",
    "bird.walk()\n",
    "bird.fly()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, we have again a more general class called Animal and another class that is a subgroup of the Animal class. Due to inheritance, the Bird class gets all the properties from the Animal class. Because it is a bird, it gets another method called Fly() and we overwrite the constructor such that it is a bit simpler."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"assets/day24-parents.jpg\" alt=\"Python Envs\" style=\"display: block; margin: 0 auto\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can make it even more interesting. A child class can have more than one parent and thereby inherit properties from multiple other classes. While this sounds amazing, it can quickly be very messy. Lets have a look at a child class with three different parents, that are actually stand-alone classes, i.e. not designed specifically for multi-class inheritance:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Geometry:\n",
    "    def __init__(self, shape_name):\n",
    "        print('Geometry constructor')\n",
    "        self.shape_name = shape_name\n",
    "    \n",
    "    def shape(self):\n",
    "        print(f'My shape is {self.shape_name}.')\n",
    "\n",
    "class Color:\n",
    "    def __init__(self, color_name):\n",
    "        print('Color constructor')\n",
    "        self.color_name = color_name\n",
    "    \n",
    "    def color(self):\n",
    "        print(f'My color is {self.color_name}.')\n",
    "        \n",
    "class Weight:\n",
    "    def __init__(self, total_weight):\n",
    "        print('Weight constructor')\n",
    "        self.total_weight = total_weight\n",
    "    \n",
    "    def weight(self):\n",
    "        print(f'My weight is {self.total_weight} kg.')\n",
    "        \n",
    "class HeavyRedSquare(Geometry, Color, Weight):\n",
    "    def __init__(self):\n",
    "        super().__init__('square')\n",
    "        super(Geometry, self).__init__('red')\n",
    "        super(Color, self).__init__(100)\n",
    "\n",
    "hrs = HeavyRedSquare()\n",
    "\n",
    "hrs.shape()\n",
    "hrs.color()\n",
    "hrs.weight()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we have three classes that would work individually. Using multiple-inheritance, we combine the three classes to a single definition: the HeavyRedSquare class. The new class has to call all other other constructors to initialize the values. We can do this using the super() function, however this looks pretty confusing. The first super() call, without any parameters, calls the first parent class constructor (the most left one in the parenthesis). In the second super() call we pass along two parameters. The first parameter is the Geometry class and the second is the instance object of the class. What is happening here is that we are in the Geometry class which has itself the Color class as a parent. Calling the super(), now accesses the constructor of the Color(). The same happens in the third super() call. In this definition, the Weight class is the parent of the Color class. Calling the super in this way, gives access to the constructor of the Weight class. For the higher level constructors, we need to pass along the self object. In the first level, i.e. the plain super(), it is passed along automatically. This way of writing is pretty confusing to me. Therefore, there is also another way that I prefer and in my opinion looks much cleaner:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class HeavyRedSquare(Geometry, Color, Weight):\n",
    "    def __init__(self):\n",
    "        Geometry.__init__(self, 'square')\n",
    "        Color.__init__(self, 'red')\n",
    "        Weight.__init__(self, 100)\n",
    "\n",
    "hrs = HeavyRedSquare()\n",
    "\n",
    "hrs.shape()\n",
    "hrs.color()\n",
    "hrs.weight()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This way calls the class constructor directly. Therefore, we need to pass along the self object, i.e. the data that belongs to this instance. This is a way in which we can combine objects, that also work stand-alone. Most of the time when using inheritance, classes are designed to work together. As seen from this simple example, it can become quite complex in no time."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Something that is much more common is that objects are chain-inherited. What this means that a class has a parent, that on its term has a parent itself, and so on. In Python everything is an Object, we have mentioned it already many times. But we mean this actually literally. All types in Python are based on the Object type. There is a special dunder attribute (it is not a method) that keeps track of all parents, in order:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Food:\n",
    "    def __init__(self):\n",
    "        pass\n",
    "\n",
    "class Lunch(Food):\n",
    "    def __init__(self):\n",
    "        pass\n",
    "    \n",
    "class Sandwich(Lunch):\n",
    "    def __init__(self):\n",
    "        pass\n",
    "    \n",
    "Sandwich.__mro__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Something that is annoying about all of this inheritance is to find the source code of a method in an object. When looking for the source of a particular method manually, I regularly had to look from class to class upward in the hierarchy. When using a higher-level IDE, this probably is a bit simpler."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is one last special type of inheritance which is important to know about: mixins. A mixin is a type of class that is designed to be combined with other classes and do not make sense instantiating alone. They do however look like regular classes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Description:\n",
    "    def description(self):\n",
    "        print(f'I am a {self.shape_type}')\n",
    "\n",
    "class Rectangle(Description):\n",
    "    def __init__(self):\n",
    "        self.shape_type = 'rectangle'\n",
    "\n",
    "class Circle(Description):\n",
    "    def __init__(self):\n",
    "        self.shape_type = 'circle'\n",
    "        \n",
    "rectangle = Rectangle()\n",
    "circle = Circle()\n",
    "rectangle.description()\n",
    "circle.description()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mixins are great to add a general save-to-disk function to a function, again to help centralize your code. There is a lot to take in from this lesson. If you did not get all, don't worry about it too much. It is most important to have a grasp of what is happening. Inheritance is used frequently, multiple inheritance not so much. See the latter mostly as a nice to know."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Practice for today:\n",
    "Inheritance and Mix-in's are great concepts. Lets play around with those. Here are two classes of shapes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Polygon:\n",
    "    def __init__(self, points, color):\n",
    "        \"\"\"\n",
    "        parameters:\n",
    "          points : list of tuples (x, y)\n",
    "                    each tuple is a coordinate with x,y as int\n",
    "          color   : str\n",
    "                    color as string\n",
    "        \"\"\"\n",
    "        self.points = points\n",
    "        self.color = color\n",
    "    \n",
    "    def describe(self):\n",
    "        print(f'I am a polygon and my color is {self.color}.')\n",
    "\n",
    "class Rectangle:\n",
    "    def __init__(self, x1, y1, x2, y2, color):\n",
    "        self.points = [(x1, y1), (x2, y1), (x2, y2), (x1, y2)]\n",
    "        self.color = color\n",
    "        \n",
    "    def describe(self):\n",
    "        print(f'I am a rectangle and my color is {self.color}.')\n",
    "   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Assignment:\n",
    "Write a Mixin to count the corners of each shapes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A solution is [posted](https://gist.github.com/dennisbakhuis/1238a441ce9df9b3aceb1290d32a4aac) on my Github."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you have any questions, feel free to contact me through [LinkedIn](https://www.linkedin.com/in/dennisbakhuis/)."
   ]
  }
 ],
 "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}