LessonM52_OOPII.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[![Google Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/PyGIS222/Fall2019/blob/master/LessonM52_OOPII.ipynb)\n",
    "\n",
    "[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/PyGIS222/Fall2019/master?filepath=LessonM52_OOPII.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Notebook Lesson 5.2\n",
    "\n",
    "# Object-Oriented Programming - Advanced Topics (II)\n",
    "\n",
    "<img src=\"./img/M51_shark.png\" width=\"500\" />\n",
    "\n",
    "This Jupyter Notebook is part of module 5 of the course GIS222 (Fall2019). This lesson enters a bit deeper into the thematic of classes creation in Python. Carefully study the content of this Notebook and use the chance to reflect the material through the interactive examples.\n",
    "\n",
    "### Sources\n",
    "\n",
    "This notebook implements parts of the lessons [Object-Oriented Programming in Python 3](https://www.digitalocean.com/community/tutorial_series/object-oriented-programming-in-python-3) of the [Digital Ocean Community](https://www.digitalocean.com/community), which is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License.\n",
    "\n",
    "---\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# A. More on handling of class attributes and methods\n",
    "\n",
    "Now let's continue to look into some details on how to work with class attributes (variables) and methods. Below a few options that highlight the flexibility of classes and their instances.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A.1 You can set default values for arguments\n",
    "\n",
    "When you create an instance with the constructor method (or work with another method) that requests an argument, you can pre-define default values for those arguments (parameter). This works congruent to setting default arguments in functions. See the example below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Fish:\n",
    "    \n",
    "    # constructor method with first_name and last_name :\n",
    "    # ... the argument last_name is set to \"Fish\" by default\n",
    "    def __init__(self, first_name, last_name=\"Fish\"):  \n",
    "        self.first_name = first_name # defines argument last_name as instance variable\n",
    "        self.last_name = last_name   # defines argument first_name as instance variable\n",
    "        print(\"The name of your fish is: \" + first_name + \" \" + last_name)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The constructor method of the class `Fish` above, accepts two parameter, however, only one has to be defined. The parameter `first_name` has to be defined when creating the instance. The second parameter `last_name` will be set to the default value `'Fish'`, except if a second argument is provided during instance creation. \n",
    "\n",
    "Let's first create an instance, passing only one parameter:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The name of your fish is: Bass Fish\n"
     ]
    }
   ],
   "source": [
    "bass = Fish('Bass')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the example, the instance `bass` automatically aquired the `last_name` `'Fish'`.\n",
    "\n",
    "Now let's create a second instance, with two parameter:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The name of your fish is: Bluefin Tuna\n"
     ]
    }
   ],
   "source": [
    "bluef = Fish('Bluefin', 'Tuna')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This time, the `last_name` received the value that was passed during instance creation, it is now `'Tuna'`, instead of `'Fish'`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-success\">\n",
    "\n",
    "When passing arguments to a class methods, default values can be defined by using the syntax:\n",
    "\n",
    "``` python\n",
    "class ClassName:\n",
    "    def method(self, variableName = content):\n",
    "        ...\n",
    "```\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A.2 A class method can reference other class or instance attibutes\n",
    "\n",
    "This was already covered in the previous notebook, but we like to empphasize on it further. Class variables as well as instance variables can be addressed from any method in the class.\n",
    "\n",
    "In the example below, we have moved the `print(...)` statement printing the fish names from the constructor method to a new function called `printName()`. This function does not receive any arguments (parameter), however, it does make use of the instance attributes `first_name` and `last_name`. For that, the attributes have to be referenced with `self`, otherwise a `NameError` (for not defined variables) will be raised."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Fish:\n",
    "        \n",
    "    def __init__(self, first_name, last_name=\"Fish\"):\n",
    "        self.first_name = first_name  # defines argument last_name as instance variable\n",
    "        self.last_name = last_name    # defines argument last_name as instance var\n",
    "\n",
    "    def printName(self):\n",
    "        # print statement references instance variables\n",
    "        print(\"The name of your fish is: \" + self.first_name + \" \" + self.last_name)\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, when creating an instance of this new version of class `Fish`, it will not result in any print out. This constructor method only receives the arguments and defines them as instance variables `self.first_name` and `self.last_name`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [],
   "source": [
    "bluef = Fish('Bluefin', 'Tuna')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For getting the name printed to screen, we have to call the function `printName()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The name of your fish is: Bluefin Tuna\n"
     ]
    }
   ],
   "source": [
    "bluef.printName()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This function is now successfully printing out the instance attributes `first_name` and `last_name`, that were defined by another method (the constructor method). To achieve that, the instance variables have to be defined as such in the method they are created:\n",
    "```python\n",
    "self.first_name = first_name\n",
    "```\n",
    "\n",
    "Then they can be addressed in any other function by the syntax.\n",
    "```python\n",
    "self.first_name\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A.3 A class method can call other methods of the class\n",
    "\n",
    "Similar to attributes, a method can also call another method defined in the class. For illustrating that, we have again slightly redefined the previous `Fish` class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Fish:\n",
    "        \n",
    "    def __init__(self, first_name, last_name=\"Fish\"):\n",
    "        self.first_name = first_name\n",
    "        self.last_name = last_name\n",
    "        self.printName()     # calls the method printName() from the method doPrint\n",
    "\n",
    "    def printName(self):\n",
    "        print(\"The name of your fish is: \" + self.first_name + \" \" + self.last_name)  \n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function `printName()` is now called from the constructor method. To call the method from inside class, it has to be referenced with the `self` keyword functioning as placeholder for the name of later created class instances (objects).\n",
    "\n",
    "Now, let's see what happens when we create an instance of the updated class `Fish`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The name of your fish is: Bluefin Tuna\n"
     ]
    }
   ],
   "source": [
    "bluef = Fish('Bluefin', 'Tuna')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since the function `printName()` is now called by the constructor method, the print statement is again given at instance creation!\n",
    "\n",
    "By the way, you can create an infinite \"self-call loop\" within a method by calling a method in itself: Add the method call `self.printName()` to the block of the method `printName()` and execute the updated class definition. Then, see what happens, once you call the method with `bluef.printName()`. (After that hit the stop button at the top to interrupt the kernel and stop your infinite \"self-call loop\").\n",
    "\n",
    "Let's summariz the syntax: to be able to reference methods from outside and inside the class, the methods are written in a way that they always receive the instance of a class as first argument. Since the code for the method is written before creating any instances of the class, a placeholder keyword `self` is used instead:\n",
    "\n",
    "```python\n",
    "class className:\n",
    "    def method(self, ...):\n",
    "        ...\n",
    "```\n",
    "\n",
    "To call the method from inside class, it has to be referenced with the placeholder keyword `self`:\n",
    "```python\n",
    "self.method()\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A.4 Private attributes & methods\n",
    "\n",
    "In a class, you can also create special methods and attributes that are **private**. Private means these class contents are only available for the members of the class not for the outside of the class. Attributes and methods can be made private by naming them with **two leading underscores** and **no trailing underscores**. \n",
    "\n",
    "Let's again adjust the previous `Fish` class. This time, we are replacing the print method by a private method `__printSize()` that prints a privat attribute `__size`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Fish:\n",
    "        \n",
    "    def __init__(self, first_name, last_name=\"Fish\"):\n",
    "        self.first_name = first_name\n",
    "        self.last_name = last_name\n",
    "        self.__size = 'large'      # added private attribute\n",
    "\n",
    "    def __printSize(self):         # added private method\n",
    "        print(\"Your fish's size is: \" + self.__size)  \n",
    "\n",
    "    def askSize(self):\n",
    "        self.__printSize()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In our example, the privat attribute is simpy set to the value `'large'` (in more realistic scenarios, for example, it could be derived from instance variables). Now, if we create an instance of the updated `Fish` class ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "bluef = Fish('Bluefin', 'Tuna')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "... and call the function `askSize()` ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Your fish's size is: large\n"
     ]
    }
   ],
   "source": [
    "bluef.askSize()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "... we get a printout to the screen, which was defined in the private `__printeSize()` method. However, this private method was called from the `askSize()` method, not from outside the class."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you would try to access either the private attribute `__size` or the private method `__printSize()` from outside the class, you would receive an `AttributeError`. Private attributes and methods are not accessible from outside the class. You can try this below, by uncommenting one of the lines at a time:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {},
   "outputs": [],
   "source": [
    "#bluef.__size\n",
    "#bluef.__printSize()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A.5 A class method can receive an instance of its own class as argument\n",
    "\n",
    "One very powerfull desing for classes creation, is the possibility of passing the instance of a class as argument to a method of a class. This can be the instance of any class, but it can also be an instance of the same class. Now you may start realizing, how complex OOP can become and that it may take a while to both design and read such data structures.\n",
    "\n",
    "Let's look at a simple example for illustrating this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Fish:\n",
    "        \n",
    "    def __init__(self, first_name):\n",
    "        self.first_name = first_name\n",
    "\n",
    "    def makeFishFriends(self, fishfriend):\n",
    "        print(\"The fish \" + self.first_name + \" and \" + fishfriend.first_name + \" have become really good friends!\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have added a new method `makeFishFriends()` to the class `Fish`. This method receives one argument (after self): `fishfriend`. Now, this could be any object type, if looking only at the `def` line. But when inspecting the `print()` statement below, it should be more clear, what kind of object type this has to be. The syntax for using the `fishfriend` variable in the `print()` statement ist:\n",
    "```python\n",
    "fishfriend.first_name\n",
    "```\n",
    "This is likel a class-related object, which is hinted by the `.` operator. After the `.`, a variable `first_name` is referenced. And, our class `Fish` has exactly such an instance variable. So we could pass an second instance of the class `Fish` to the method `makeFishFriends()` and that would use the variable `first_name` of the instance `fishfriend` in the `print()`  statement. In addition, the `print()` statements also contains the `self.first_name`, which prints the `last_name` from the instance that the method `makeFishFriends()` is called from.\n",
    "\n",
    "Let's look at an example, if that becomes to make this more clear. First, we define two instances of the new `Fish` class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "bass = Fish('Bass')\n",
    "bluef = Fish('Bluefin')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can call the function `makeFishFriends()` for one of the instances and pass the other instances."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The fish Bass and Bluefin have become really good friends!\n"
     ]
    }
   ],
   "source": [
    "bass.makeFishFriends(bluef)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You could also perform this the other way around:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The fish Bluefin and Bass have become really good friends!\n"
     ]
    }
   ],
   "source": [
    "bluef.makeFishFriends(bass)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So, what again exactly happens here?\n",
    "\n",
    "Both `Fish` instances get a `first_name` during instance creation. The class `Fish` also contains the method `makeFishFriends()`. This method expects one argument (after self), which has the name `fishfriend`. Then, the method `makeFishFriends()` calls a `print()` statement, which references the argument `fishfriend` as instance of the same class `Fish`. \n",
    "\n",
    "This allows us to pass the instance `bluef` to the instance `bass` (or the other way around). This allows for the method `makeFishFriends()` to  address both of their names in one `print()`.\n",
    "\n",
    "You can also let a fish make friend with itself. Not that this would make any sense, but it works:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The fish Bass and Bass have become really good friends!\n"
     ]
    }
   ],
   "source": [
    "bass.makeFishFriends(bass)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A.6 An example for a GIS relevant class\n",
    "\n",
    "Let's apply the knowledge on OOP and classes discussed so far, and build a completely new class that has more affinity to GIS problems. \n",
    "\n",
    "The cell below defines a class `Point`, which receives `x` and `y` coordinates as arguments during instance creation. The coordinates are set to zero by default. A method `display()` is available to print the coordinates of a `Point` instance to screen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Defining a class Point\n",
    "class Point:\n",
    "\n",
    "    def __init__(self, x=0.0, y=0.0): # default values of x and y coordinates are 0 \n",
    "        self.x = x\n",
    "        self.y = y\n",
    "        \n",
    "    def display(self):  # displays the coordinates\n",
    "        print('xCoord = ', self.x)\n",
    "        print('yCoord = ', self.y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the next step, let's define two points with different coordinates. Since we defined `x=0.0` and `y=0.0` by default in the constructor method, we can begin with just creating the points, without passing any arguments to the constructor method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "xCoord =  0.0\n",
      "yCoord =  0.0\n",
      "xCoord =  0.0\n",
      "yCoord =  0.0\n"
     ]
    }
   ],
   "source": [
    "P1 = Point()\n",
    "P2 = Point()\n",
    "P1.display()\n",
    "P2.display()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, all coordinates received the default values. Now, we can to keep those values for `P1`, but let's change those of `P2`. So we should fill the coordinates of `P2` with different values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "xCoord =  0.0\n",
      "yCoord =  0.0\n",
      "xCoord =  1.4\n",
      "yCoord =  2.7\n"
     ]
    }
   ],
   "source": [
    "P2.x = 1.4\n",
    "P2.y = 2.7\n",
    "P1.display()\n",
    "P2.display()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We created two points P(x,y): P1(0,0) and P2(1.4,2.7)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, this looks already pretty handy and what we have just created, is indeed one of the most basic classes defined in several GIS relevant Python packages!\n",
    "\n",
    "Now, we would like to show, how we can utilize OOP concepts for handeling point data. For example, let's code a very regularily needed calculation for points, like the distance $d$ between two points. The equation for that is:\n",
    "\n",
    "$d(P_1,P_2) = \\sqrt{ (x_2-x_1)^2 + (y_2-y_1)^2) }$\n",
    "\n",
    "In the equation the distance $d$ is given by the sqared root of the squared sum of the differences between the x and y coordinates of two points $P_1(x_1,y_1)$ and $P_2(x_2,y_2)$. \n",
    "\n",
    "If you want to code this equation, you could write a Python function that receives the coordinates of the two points, caluculates the distance according to the equation above and returns the result for $d$. \n",
    "\n",
    "In object-oriented programming, such a function is embedded into the `Point` class. Such a method, calculating the distance of a point to another point, could receive an instance of its own class as argument. (This is very congruent to the example above for the `Fish` class and its method `makeFishFriends()`.)\n",
    "\n",
    "So, let's write down code for a `distance()` method.\n",
    "First, we extend the class `Point` by a function `distance()` that receives an instance of its own class as argument (after `self`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Importing the math modules to access sqrt()\n",
    "import math\n",
    "\n",
    "# Defining a class Point\n",
    "class Point:\n",
    "    \n",
    "    def __init__(self, x=0.0, y=0.0): # initial values of x and y coordinates are 0 \n",
    "        self.x = x\n",
    "        self.y = y\n",
    "        \n",
    "    def display(self):  # displays the coordinates\n",
    "        print('xCoord = ', self.x)\n",
    "        print('yCoord = ', self.y)\n",
    "    \n",
    "    # methdo calculates the distance from self.x/y to secondPoint.x/y        \n",
    "    def distance(self, secondPoint): \n",
    "        # Equation for distance btw two points:\n",
    "        dist = math.sqrt( (secondPoint.x-self.x)**2 + (secondPoint.y-self.y)**2 )\n",
    "        return(dist)  # returns the result to the method caller\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, we have added an import of the `math` module, to be able to use it's `sqrt()` function. Then we coded the equation for distance calculation in the method `distanc()`, using the coordinates of the `Point` class as well as the coordinates of anoter instance of the `Point` class, named `secondPoint`.\n",
    "\n",
    "Now, let's use and test this. We have to create two instances of the updated class `Point`, let's name them points `P1` and `P2` and fill them with coordinates given in kilometer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "xCoord =  0.0\n",
      "yCoord =  0.0\n",
      "xCoord =  1.4\n",
      "yCoord =  2.7\n"
     ]
    }
   ],
   "source": [
    "P1 = Point()\n",
    "P2 = Point(1.4, 2.7)\n",
    "P1.display()\n",
    "P2.display()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we can call the distance method for one point and pass the other point as argument. This would start the calculation of the equation for the distance $d$ between `P1` and `P2`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The distance between the points is: 3.04 km.\n"
     ]
    }
   ],
   "source": [
    "d = P1.distance(P2)\n",
    "print(\"The distance between the points is: {:.2f} km.\".format(d))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There you go! This is a very simple GIS operation coded object-oriented in Python.\n",
    "\n",
    "Now you should be able to write functions and methods that accept arguments being class instances. In the next section, we will go one step further in complexity of OOP code design, which is the creation of nested classes. The actual professional term in OOP for that is superclasses (also base classes or parent classes) and subclasses (also child classes)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "# B. Advanced Topic: Understanding Class Inheritance in Python\n",
    "\n",
    "Object-oriented programming creates reusable patterns of code to curtail redundancy in development projects. One way that object-oriented programming achieves recyclable code is through inheritance, when one subclass can leverage code from another base class.\n",
    "\n",
    "In this part we will go through some of the major aspects of inheritance in Python, including how parent classes and child classes work, how to override methods and attributes, how to use the super() function, and how to make use of multiple inheritance. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What is Inheritance?\n",
    "\n",
    "**Inheritance** is when a class uses code constructed within another class. If we think of inheritance in terms of biology, we can think of a child inheriting certain traits from their parent. That is, a child can inherit a parent’s height or eye color. Children also may share the same last name with their parents.\n",
    "\n",
    "Classes called **child classes** or **subclasses** inherit methods and variables from **parent classes** or **base classes**.\n",
    "\n",
    "We can think of a parent class called `Parent` that has class variables for `last_name`, `height`, and `eye_color` that the child class `Child` will inherit from the `Parent`.\n",
    "\n",
    "Because the `Child` subclass is inheriting from the `Parent` base class, the `Child` class can reuse the code of `Parent`, allowing the programmer to use fewer lines of code and decrease redundancy. \n",
    "\n",
    "Only, private attributes and methods will not be inherited."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Parent Classes\n",
    "\n",
    "Parent or base classes create a pattern out of which child or subclasses can be based on. Parent classes allow us to create child classes through inheritance without having to write the same code over again each time. Any class can be made into a parent class, so they are each fully functional classes in their own right, rather than just templates.\n",
    "\n",
    "Let’s say we have a general `Bank_account` parent class that has `Personal_account` and `Business_account` child classes. Many of the methods between personal and business accounts will be similar, such as methods to withdraw and deposit money, so those can belong to the parent class of `Bank_account`. The `Business_account` subclass would have methods specific to it, including perhaps a way to collect business records and forms, as well as an `employee_identification_number` variable.\n",
    "\n",
    "Similarly, an Animal class may have `eating()` and `sleeping()` methods, and a `Snake` subclass may include its own specific `hissing()` and `slithering()` methods.\n",
    "\n",
    "Let’s create a `Fish` **parent** class that we will later use to construct types of fish as its subclasses. Each of these fish will have first names and last names in addition to characteristics.\n",
    "\n",
    "We’ll create new code below and start with the `__init__()` constructor method, which we’ll populate with `first_name` and `last_name` variables for each `Fish` object or subclass."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Fish:\n",
    "    def __init__(self, first_name, last_name=\"Fish\"):\n",
    "        self.first_name = first_name\n",
    "        self.last_name = last_name"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have initialized our `last_name` variable with the string `\"Fish\"` because we know that most fish will have this as their last name.\n",
    "\n",
    "Let’s also add some other methods:\n",
    "\n",
    "```python\n",
    "    def swim(self):\n",
    "        print(\"The fish is swimming.\")\n",
    "\n",
    "    def swim_backwards(self):\n",
    "        print(\"The fish can swim backwards.\")\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Fish:\n",
    "    def __init__(self, first_name, last_name=\"Fish\"):\n",
    "        self.first_name = first_name\n",
    "        self.last_name = last_name\n",
    "\n",
    "    def swim(self):\n",
    "        print(\"The fish is swimming.\")\n",
    "\n",
    "    def swim_backwards(self):\n",
    "        print(\"The fish can swim backwards.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have added the methods `swim()` and `swim_backwards()` to the `Fish` class, so that every subclass will also be able to make use of these methods.\n",
    "\n",
    "Since most of the fish we’ll be creating are considered to be bony fish (as in they have a skeleton made out of bone) rather than cartilaginous fish (as in they have a skeleton made out of cartilage), we can add a few more attributes to the `__init__()` method:\n",
    "\n",
    "```python\n",
    "        self.skeleton = skeleton\n",
    "        self.eyelids = eyelids\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Fish:\n",
    "    def __init__(self, first_name, last_name=\"Fish\",\n",
    "                 skeleton=\"bone\", eyelids=False):\n",
    "        self.first_name = first_name\n",
    "        self.last_name = last_name\n",
    "        self.skeleton = skeleton\n",
    "        self.eyelids = eyelids\n",
    "\n",
    "    def swim(self):\n",
    "        print(\"The fish is swimming.\")\n",
    "\n",
    "    def swim_backwards(self):\n",
    "        print(\"The fish can swim backwards.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Building a parent class follows the same methodology as building any other class, except we are thinking about what methods the child classes will be able to make use of once we create those. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Child Classes\n",
    "\n",
    "Child or subclasses are classes that will inherit from the parent class. That means that each child class will be able to make use of the methods and variables of the parent class.\n",
    "\n",
    "For example, a `Goldfish` **child** class that subclasses the Fish class will be able to make use of the `swim()` method declared in `Fish` without needing to declare it.\n",
    "\n",
    "We can think of each child class as being a class of the parent class. That is, if we have a child class called `Rhombus` and a parent class called `Parallelogram`, we can say that a `Rhombus` is a `Parallelogram`, just as a `Goldfish` is a `Fish`.\n",
    "\n",
    "The first line of a child class looks a little different than non-child classes as you must pass the parent class into the child class as a parameter:\n",
    "\n",
    "```python\n",
    "class Trout(Fish):\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `Trout` class is a child of the `Fish` class. We know this because of the inclusion of the word `Fish` in parentheses.\n",
    "\n",
    "With child classes, we can choose to add more methods, override existing parent methods, or simply accept the default parent methods with the pass keyword, which we’ll do in this case:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Trout(Fish):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now create a `Trout` object without having to define any additional methods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "terry = Trout(\"Terry\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have created a `Trout` object `terry` that makes use of each of the methods of the `Fish` class even though we did not define those methods in the `Trout` child class. We only needed to pass the value of `\"Terry\"` to the `first_name` variable because all of the other variables were initialized.\n",
    "\n",
    "We can check if all of that worked, by the following print out statements and method calls:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Terry Fish\n",
      "bone\n",
      "False\n",
      "The fish is swimming.\n",
      "The fish can swim backwards.\n"
     ]
    }
   ],
   "source": [
    "print(terry.first_name + \" \" + terry.last_name)\n",
    "print(terry.skeleton)\n",
    "print(terry.eyelids)\n",
    "terry.swim()\n",
    "terry.swim_backwards()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, let’s create another child class that includes its own method. We’ll call this class `Clownfish`, and its special method will permit it to live with sea anemone:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Clownfish(Fish):\n",
    "\n",
    "    def live_with_anemone(self):\n",
    "        print(\"The clownfish is coexisting with sea anemone.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, let’s create a Clownfish object to see how this works:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Casey Fish\n",
      "The fish is swimming.\n",
      "The clownfish is coexisting with sea anemone.\n"
     ]
    }
   ],
   "source": [
    "casey = Clownfish(\"Casey\")\n",
    "print(casey.first_name + \" \" + casey.last_name)\n",
    "casey.swim()\n",
    "casey.live_with_anemone()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The output shows that the `Clownfish` object casey is able to use the `Fish` methods `__init__()` and `swim()` as well as its child class method of `live_with_anemone()`.\n",
    "\n",
    "If we try to use the `live_with_anemone()` method in a `Trout` object, we’ll receive an `AttributeError` error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'Trout' object has no attribute 'live_with_anemone'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-44-af868852b370>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mterry\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlive_with_anemone\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m: 'Trout' object has no attribute 'live_with_anemone'"
     ]
    }
   ],
   "source": [
    "terry.live_with_anemone()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is because the method `live_with_anemone()` belongs only to the `Clownfish` child class, and not the `Fish` parent class.\n",
    "\n",
    "Child classes inherit the methods of the parent class it belongs to, so each child class can make use of those methods within programs."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Overriding Parent Methods\n",
    "\n",
    "So far, we have looked at the child class `Trout` that made use of the `pass` keyword to inherit all of the parent class `Fish` behaviors, and another child class `Clownfish` that inherited all of the parent class behaviors and also created its own unique method that is specific to the child class. Sometimes, however, we will want to make use of some of the parent class behaviors but not all of them. When we change parent class methods we **override** them.\n",
    "\n",
    "When constructing parent and child classes, it is important to keep program design in mind so that overriding does not produce unnecessary or redundant code.\n",
    "\n",
    "We’ll create a `Shark` child class of the `Fish` parent class. But let's first copy the `Fish` parent class below, so you don't have to scroll all the way back up, to review it's content: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "# parent class\n",
    "class Fish:\n",
    "    def __init__(self, first_name, last_name=\"Fish\",\n",
    "                 skeleton=\"bone\", eyelids=False):\n",
    "        self.first_name = first_name\n",
    "        self.last_name = last_name\n",
    "        self.skeleton = skeleton\n",
    "        self.eyelids = eyelids\n",
    "\n",
    "    def swim(self):\n",
    "        print(\"The fish is swimming.\")\n",
    "\n",
    "    def swim_backwards(self):\n",
    "        print(\"The fish can swim backwards.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because we created the `Fish` class with the idea that we would be creating primarily bony fish, we’ll have to make adjustments for the `Shark` class that is instead a cartilaginous fish. In terms of program design, if we had more than one non-bony fish, we would most likely want to make separate classes for each of these two types of fish.\n",
    "\n",
    "Sharks, unlike bony fish, have skeletons made of cartilage instead of bone. They also have eyelids and are unable to swim backwards. Sharks can, however, maneuver themselves backwards by sinking.\n",
    "\n",
    "In light of this, we’ll be overriding the `__init__()` constructor method and the `swim_backwards()` method. We don’t need to modify the `swim()` method since sharks are fish that can swim. Let’s take a look at this child class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "# child class\n",
    "class Shark(Fish):\n",
    "    def __init__(self, first_name, last_name=\"Shark\",\n",
    "                 skeleton=\"cartilage\", eyelids=True):\n",
    "        self.first_name = first_name\n",
    "        self.last_name = last_name\n",
    "        self.skeleton = skeleton\n",
    "        self.eyelids = eyelids\n",
    "\n",
    "    def swim_backwards(self):\n",
    "        print(\"The shark cannot swim backwards, but can sink backwards.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have overridden the initialized parameters in the `__init__()` method, so that the `last_name` variable is now set equal to the string `\"Shark\"`, the skeleton variable is now set equal to the string `\"cartilage\"`, and the `eyelids` variable is now set to the Boolean value `True`. Each instance of the class can also override these parameters.\n",
    "\n",
    "The method `swim_backwards()` now prints a different string than the one in the `Fish` parent class because sharks are not able to swim backwards in the way that bony fish can.\n",
    "\n",
    "We can now create an instance of the `Shark` child class, which will still make use of the `swim()` method of the `Fish` parent class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sammy Shark\n",
      "The fish is swimming.\n",
      "The shark cannot swim backwards, but can sink backwards.\n",
      "True\n",
      "cartilage\n"
     ]
    }
   ],
   "source": [
    "sammy = Shark(\"Sammy\")\n",
    "print(sammy.first_name + \" \" + sammy.last_name)\n",
    "sammy.swim()\n",
    "sammy.swim_backwards()\n",
    "print(sammy.eyelids)\n",
    "print(sammy.skeleton)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `Shark` child class successfully overrode the `__init__()` and `swim_backwards()` methods of the `Fish` parent class, while also inheriting the `swim()` method of the parent class.\n",
    "\n",
    "When there will be a limited number of child classes that are more unique than others, overriding parent class methods can prove to be useful."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The `super()` Function\n",
    "\n",
    "With the `super()` function, you can gain access to inherited methods that have been overwritten in a class object.\n",
    "\n",
    "When we use the `super()` function, we are calling a parent method into a child method to make use of it. For example, we may want to override one aspect of the parent method with certain functionality, but then call the rest of the original parent method to finish the method.\n",
    "\n",
    "In a program that grades students, we may want to have a child class for `Weighted_grade` that inherits from the `Grade` parent class. In the child class `Weighted_grade`, we may want to override a `calculate_grade()` method of the parent class in order to include functionality to calculate a weighted grade, but still keep the rest of the functionality of the original class. By invoking the `super()` function we would be able to achieve this.\n",
    "\n",
    "The `super()` function is most commonly used within the `__init__()` method because that is where you will most likely need to add some uniqueness to the child class and then complete initialization from the parent.\n",
    "\n",
    "To see how this works, let’s modify our `Trout` child class. Since trout are typically freshwater fish, let’s add a `water` variable to the `__init__()` method and set it equal to the string `\"freshwater\"`, but then maintain the rest of the parent class’s variables and parameters:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Trout(Fish):\n",
    "    def __init__(self, water = \"freshwater\"):\n",
    "        self.water = water\n",
    "        super().__init__(self)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have overridden the `__init__()` method in the `Trout` child class, providing a different implementation of the `__init__()` that is already defined by its parent class Fish. Within the `__init__()` method of our `Trout` class we have explicitly invoked the `__init__()` method of the `Fish` class.\n",
    "\n",
    "Because we have overridden the method, we no longer need to pass `first_name` in as a parameter to `Trout`, and if we did pass in a parameter, we would reset `freshwater` instead. We will therefore initialize the `first_name` by calling the variable in our object instance.\n",
    "\n",
    "Now we can invoke the initialized variables of the parent class and also make use of the unique child variable. Let’s use this in an instance of `Trout`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Terry Fish\n",
      "False\n",
      "freshwater\n",
      "The fish is swimming.\n"
     ]
    }
   ],
   "source": [
    "terry = Trout()\n",
    "\n",
    "# Initialize first name\n",
    "terry.first_name = \"Terry\"\n",
    "\n",
    "# Use parent __init__() through super()\n",
    "print(terry.first_name + \" \" + terry.last_name)\n",
    "print(terry.eyelids)\n",
    "\n",
    "# Use child __init__() override\n",
    "print(terry.water)\n",
    "\n",
    "# Use parent swim() method\n",
    "terry.swim()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The output shows that the object `terry` of the `Trout` child class is able to make use of both the child-specific `__init__()` variable water while also being able to call the Fish parent `__init__()` variables of `first_name`, `last_name`, and `eyelids`.\n",
    "\n",
    "The built-in Python function `super()` allows us to utilize parent class methods even when overriding certain aspects of those methods in our child classes. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Multiple Inheritance\n",
    "\n",
    "**Multiple inheritance** is when a class can inherit attributes and methods from more than one parent class. This can allow programs to reduce redundancy, but it can also introduce a certain amount of complexity as well as ambiguity, so it should be done with thought to overall program design.\n",
    "\n",
    "To show how multiple inheritance works, let’s create a `Coral_reef` child class than inherits from a `Coral` class and a `Sea_anemone` class. We can create a method in each and then use the `pass` keyword in the `Coral_reef` child class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Coral:\n",
    "\n",
    "    def community(self):\n",
    "        print(\"Coral lives in a community.\")\n",
    "\n",
    "\n",
    "class Anemone:\n",
    "\n",
    "    def protect_clownfish(self):\n",
    "        print(\"The anemone is protecting the clownfish.\")\n",
    "\n",
    "\n",
    "class CoralReef(Coral, Anemone):\n",
    "    pass\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `Coral` class has a method called `community()` that prints one line, and the `Anemone` class has a method called `protect_clownfish()` that prints another line. Then we call both classes into the inheritance tuple. This means that `Coral` is inheriting from two parent classes.\n",
    "\n",
    "Let’s now instantiate a `Coral` object:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "great_barrier = CoralReef()\n",
    "great_barrier.community()\n",
    "great_barrier.protect_clownfish()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The object great_barrier is set as a `CoralReef object`, and can use the methods in both parent classes. \n",
    "\n",
    "The output shows that methods from both parent classes were effectively used in the child class.\n",
    "\n",
    "Multiple inheritance allows us to use the code from more than one parent class in a child class. If the same method is defined in multiple parent methods, the child class will use the method of the first parent declared in its tuple list.\n",
    "\n",
    "Though it can be used effectively, multiple inheritance should be done with care so that our programs do not become ambiguous and difficult for other programmers to understand."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conclusion\n",
    "\n",
    "In Section B of this notebook, we went through constructing parent classes and child classes, overriding parent methods and attributes within child classes, using the super() function, and allowing for child classes to inherit from multiple parent classes.\n",
    "\n",
    "Inheritance in object-oriented coding can allow for adherence to the DRY (don’t repeat yourself) principle of software development, allowing for more to be done with less code and repetition. Inheritance also compels programmers to think about how they are designing the programs they are creating to ensure that code is effective and clear. "
   ]
  }
 ],
 "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}