OOP in Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "8cb0cb5a",
   "metadata": {
    "init_cell": true
   },
   "source": [
    "<center>\n",
    "    <img src=\"images/logo.jpg\" width=\"150\" alt=\"EPYTHON LAB logo\"  />\n",
    "</center>\n",
    "<hr>\n",
    "\n",
    "<h2 id='string' align='center'>OOP-Object Oriented Programming </h2>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "62b0da78",
   "metadata": {},
   "source": [
    "## Learning Objectives"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "840e5866",
   "metadata": {},
   "source": [
    "After completing this topic, you will be able to get understanding:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e0f74e5",
   "metadata": {},
   "source": [
    "> - What is Object Oriented Programming in Python?\n",
    "> - What is Object?\n",
    "> - What is Class?\n",
    "> - How to define class in Python?\n",
    "> - How to instantiate object?\n",
    "> - Attributes and Methods in Class\n",
    "> - Constructor\n",
    "> - Inheritance"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df3e748f",
   "metadata": {},
   "source": [
    "<hr><br><br>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08f0b599",
   "metadata": {},
   "source": [
    "### What is OOP?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ba0292b",
   "metadata": {},
   "source": [
    "> **Object-oriented programming (OOP)** is a method of structuring a program by bundling related **properties and behaviors** into individual **objects**."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a4a3672",
   "metadata": {},
   "source": [
    "> **OOP** is a programming paradigm that provides a means of structuring programs so that properties and behaviors are bundled into individual objects."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "295cf645",
   "metadata": {},
   "source": [
    "<br><br>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98514dfb",
   "metadata": {},
   "source": [
    "### What is Object?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5690bcff",
   "metadata": {},
   "source": [
    "> Everything is in Python treated as an **object, including variable, function, list, tuple, dictionary, set, etc**. Every object belongs to its class\n",
    "\n",
    "> An object is simply a collection of **data (variables) and methods (functions)** that act on those data."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c1d3900",
   "metadata": {},
   "source": [
    "For instance, an object could represent a person with properties like a **name, age, and address** and **behaviors** such as **walking, talking, breathing, and running**. Or it could represent an email with properties like a recipient list, subject, and body and behaviors like adding attachments and sending. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ab0bd8f",
   "metadata": {},
   "source": [
    "> **Properties** define the state of the object. This is the data that the object stores. This data can be a built-in type like `int, string`, ect.\n",
    "\n",
    "> **Behaviors** are the actions our object can take. Oftentimes, this involves using or modifying the properties of our object."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d541e3a",
   "metadata": {},
   "source": [
    "For now we can think of an object as anything we can store in a variable. We can have objects with different `type`. We might also call an object's `type` its **class**. We'll talk about class later."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "26d4bb7a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "42 is an object of <class 'int'>\n",
      "Hello world! is an object of <class 'str'>\n",
      "{'name': 'Asibeh', 'age': 30} is an object of <class 'dict'>\n",
      "[2, 3, 4] is an object of <class 'list'>\n"
     ]
    }
   ],
   "source": [
    "x = 42\n",
    "print('%d is an object of %s' % (x, type(x)))\n",
    "\n",
    "x = 'Hello world!'\n",
    "print('%s is an object of %s' % (x, type(x)))\n",
    "\n",
    "x = {'name': 'Asibeh', 'age': 30}\n",
    "print('%s is an object of %s' % (x, type(x)))\n",
    "\n",
    "x= [2, 3, 4]\n",
    "print('{} is an object of {}'.format(x, type(x)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "29a9d19d",
   "metadata": {},
   "source": [
    "We already know that **integers, strings, lists, and dictionaries** behave differently. They have different properties and different capabilities. In the language of programming, we say they have different **attributes and methods**."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98582dd3",
   "metadata": {},
   "source": [
    "An object's attributes are its internal variables that are used to store information about the object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c821bfee",
   "metadata": {},
   "outputs": [],
   "source": [
    "# a complex number has real and imaginary parts\n",
    "#  a + bi, a and b are real number and i is an imaginary\n",
    "x = complex(9, 5)\n",
    "print(x.real)\n",
    "print(x.imag)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4be00443",
   "metadata": {},
   "source": [
    "An object's methods are its internal functions that implement different capabilities."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "03e6ac7f",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = ' Asibeh '\n",
    "print(x.lower())\n",
    "print(x.upper())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b0d34410",
   "metadata": {},
   "outputs": [],
   "source": [
    "x.strip()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f9b8a53",
   "metadata": {},
   "source": [
    "We'll interact with an object's methods more often than its attributes. The attributes represent the state of an object. We usually prefer to mutate the state of an object via its methods, since the methods represent the actions one can take safely without breaking the object. Often the attributes of an object will be immutable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5874de44",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%expect_exception AttributeError\n",
    "\n",
    "x = complex(5, 3)\n",
    "x.real = 6"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7cf2a48b",
   "metadata": {},
   "source": [
    "An example of a method that mutates an object is the append method of a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b08b2a21",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [35, 'example', 348.1]\n",
    "x.append(True)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "456986e9",
   "metadata": {},
   "source": [
    "How do we know what the attributes and methods of an object are? We can use Python's `dir` function. We can use `dir` on an object or on a `class`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6c86330d",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 3.4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "335c37b6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# dir on an object\n",
    "x = 42\n",
    "print(dir(x)[-6:]) # I've truncated the results for clarity\n",
    "\n",
    "# dir on a class\n",
    "print(dir(int)[6:])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "34e8eed8",
   "metadata": {},
   "source": [
    "<hr>\n",
    "<div class=\"alert alert-success alertsuccess\" style=\"margin-top: 30px\">\n",
    "[TIP]: <code>dir()</code> is a powerful inbuilt function in Python3, which returns list of the <strong>attributes and methods</strong> of any object (say functions , modules, strings, lists, dictionaries etc.)\n",
    "</div>\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "33b2c8fd",
   "metadata": {},
   "source": [
    "We can also look up documentation on the class. For example, here's <a href='https://docs.python.org/3/library/stdtypes.html'>Python's documentation on the built-in Python types</a>. We'll use documentation more and more as we incorporate third-party libraries and tools into Python."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "afe879e6",
   "metadata": {},
   "source": [
    "<br><br>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6065302e",
   "metadata": {},
   "source": [
    "## Classes"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3aae4200",
   "metadata": {},
   "source": [
    "### What is a class?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "95b3a41a",
   "metadata": {},
   "source": [
    "**Definition**:\n",
    "\n",
    ">In object-oriented programming, a class is an extensible program-code-template for creating objects, providing initial values for state and implementations of behavior.\n",
    "> Objects have member variables and have behaviour associated with them. \n",
    "\n",
    "\n",
    ">  A class is a blueprint that defines the variables and the methods common to all objects of a certain kind. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f9f11d10",
   "metadata": {},
   "source": [
    "> For instance we can think of class as a sketch (prototype) of a house. It contains all the details about the floors, doors, windows etc. Based on these descriptions we build the house. House is the object.\n",
    "\n",
    "> As many houses can be made from a house's blueprint, we can create many objects from a class. An object is also called an instance of a class and the process of creating this object is called **instantiation**."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa525c52",
   "metadata": {},
   "source": [
    "### Define a class"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b4d3b26",
   "metadata": {},
   "source": [
    "> **Primitive data structures**—like numbers, strings, and lists—are designed to represent simple pieces of information, such as the cost of an apple, the name of a poem, or your favorite colors, respectively.\n",
    "What if you want to represent something more complex?\n",
    "\n",
    "For example, let’s say you want to track employees in Coca Cola Company. You need to store some basic information about each employee, such as their **name, age, position, salary, and the year they started working**.\n",
    "\n",
    "One way to do this is to represent each employee as a `list`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b3223b54",
   "metadata": {},
   "outputs": [],
   "source": [
    "cesar=[\"Cesar Vanegas\",38,\"AI Developer\",2698, '2018']\n",
    "at=[\"Asibeh Tenager\",31,\"Data Analyst\",1568, '2021']\n",
    "el = ['Elizabet Akta', 'Designer', 1233, '2021']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cd6a4cef",
   "metadata": {},
   "source": [
    "There are a number of issues in this approach."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "45d33516",
   "metadata": {},
   "source": [
    "1. It can make larger code files more difficult to manage. If you reference `cesar[0]` several lines away from where the `at` list is declared, will you remember that the element with index `0` is the employee’s name? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "21b82154",
   "metadata": {},
   "outputs": [],
   "source": [
    "cesar[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "134f2cc3",
   "metadata": {},
   "source": [
    "2. It can introduce errors if not every employee has the same number of elements in the list. In the `el` list above, the `age` is missing, so `el[1]` will return `Designer` instead of `age`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7a9f8b90",
   "metadata": {},
   "outputs": [],
   "source": [
    "el[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "33c1ae55",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-success alertsuccess\" style=\"margin-top: 30px\">A great way to make this type of code more manageable and more maintainable is to use <strong> classes</strong>.</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0bce9c2d",
   "metadata": {},
   "source": [
    "### How can we define a class?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "34ee805b",
   "metadata": {},
   "source": [
    "In python:\n",
    "> - a class is created by the keyword `class`. \n",
    "> - An object is created using the constructor of the `class`. This object will then be called the `instance` of the class. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "180c21c3",
   "metadata": {},
   "outputs": [],
   "source": [
    "def func():\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5bc281f7",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define an empty class\n",
    "class ClassName:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc2cfc22",
   "metadata": {},
   "source": [
    "\n",
    "<hr/>\n",
    "<div class=\"alert alert-success alertsuccess\" style=\"margin-top: 30px\">\n",
    "    [TIP]: Python class names are written in <strong>CapitalizedWords</strong> notation by convention. For example, a class for a specific breed of dog like the Jack Russell Terrier would be written as <strong>JackRussellTerrier</strong>.\n",
    "\n",
    "</div>\n",
    "<hr/>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "988d6bb9",
   "metadata": {},
   "source": [
    "### Creating an Object"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e03056f4",
   "metadata": {},
   "source": [
    "To instantiate the object of the class:\n",
    "`instance = ClassName(list_of_arguments)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0278f2b1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# instantiate the object of the class\n",
    "instance_name = ClassName() # constractor name\n",
    "print(instance_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "79002183",
   "metadata": {},
   "source": [
    "### What is constructor?\n",
    "\n",
    "A **constructor**\n",
    "> is a special method that is used to initialize a newly created object and is called just after the memory is allocated for the object. \n",
    "\n",
    "> It can be used to initialize the objects to desired values or default values at the time of object creation."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3eaf4f7c",
   "metadata": {},
   "source": [
    "## Attributes and Methods in class:\n",
    "\n",
    "> A class by itself is of no use unless there is some functionality associated with it. Functionalities are defined by setting attributes, which act as containers for data and functions related to those attributes. Those functions are called methods."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "28facccf",
   "metadata": {},
   "source": [
    "### Example:\n",
    "Let's implement a class called **Rational** for working with fractional numbers `(e.g. 5/15)`. This class will have an attribute `frac`. The first thing we'll need Rational to do is to be able to set an attribute inside the class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f1bab060",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define class Rational\n",
    "class Rational:\n",
    "    \n",
    "    # set an attribute `frac` of the class\n",
    "    frac = \"5/15\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ded92aa1",
   "metadata": {},
   "source": [
    "Once we set an attribute in the class, we can be able to create the object of the class `Rational` and can assign the class to a variable. This is called object instantiation. You will then be able to access the attributes that are present inside the class using the dot `.` operator. \n",
    "\n",
    "For example, in the `Rational` example, you can access the attribute `frac` of the class `Rational`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cc3f6ca7",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create an object for the class Rational\n",
    "fraction = Rational()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f93ed5bc",
   "metadata": {},
   "outputs": [],
   "source": [
    "fraction.frac"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f972af56",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# access the class attribute\n",
    "print(fraction.frac)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b7bb30a",
   "metadata": {},
   "source": [
    "### Methods\n",
    "\n",
    "> Once there are attributes that `belong` to the class, you can define functions that will access the class attribute. These functions are called **methods**. When you define methods, you will need to always provide the first argument to the method with a `self` keyword."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f5f89418",
   "metadata": {},
   "source": [
    "For example, we can define a class `Rational`, which has two attributes `numerator`, and `denominator` and one method `fraction`. The method will take in an argument `new_numerator` and `new_denominator` along with the keyword `self`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "61009c8a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# define class \n",
    "class Rational(object):\n",
    "    # Create attributes\n",
    "    numerator = 1\n",
    "    denominator = 3\n",
    "    \n",
    "    # define the method\n",
    "    def fraction(self, new_numerator, new_denominator):\n",
    "        self.numerator = new_numerator\n",
    "        self.denominator = new_denominator\n",
    "        \n",
    "        # return the fraction\n",
    "        return '{}/{}' .format(self.numerator, self.denominator)\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ebb74585",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create object\n",
    "frac = Rational()\n",
    "\n",
    "# call the modeth\n",
    "result = frac.fraction(5, 15) ## passing arguments to the paramaters \n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "65c6a4d4",
   "metadata": {},
   "source": [
    "<hr>\n",
    "<div class=\"alert alert-success alertsuccess\" style=\"margin-top: 30px\">\n",
    "    [TIP] : the <code>self</code> keyword represents the instance of the class. By using the <code>self</code> keyword we can access the attributes and methods of the class in python. This allows each object to have its own attributes and methods.\n",
    "</div>\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a1a2433",
   "metadata": {},
   "source": [
    "### Instance attributes and the `init` method"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f983f4b7",
   "metadata": {},
   "source": [
    "> We define how the class `Rational` should work with a special (hidden) method called `__init__`. We'll also define another special method called `__repr__` that tells Python how to print out the object.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "727b7fe1",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Rational(object):\n",
    "\n",
    "    def __init__(self, numerator, denominator):\n",
    "        self.numerator = numerator\n",
    "        self.denominator = denominator\n",
    "\n",
    "    def __repr__(self):\n",
    "        return 'Fraction: {}/{}'.format(self.numerator, self.denominator)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2f679887",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dog(object):\n",
    "    \n",
    "    def __init__(self, name, age):\n",
    "        \n",
    "        self.name = name\n",
    "        self.age = age\n",
    "    def __repr__(self):\n",
    "        return \"I'm {} and I'm {} years old. \".format(self.name, self.age)\n",
    "    \n",
    "    def speak(self, is_speak):\n",
    "        if is_speak == True:\n",
    "            return \"Speak\"\n",
    "        else:\n",
    "            return \"Not speak\"\n",
    "            \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4919a547",
   "metadata": {},
   "outputs": [],
   "source": [
    "dog = Dog(\"Poly\", 2)\n",
    "\n",
    "dog.speak(True)\n",
    "\n",
    "print(dog)\n",
    "print(dog.speak(True))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ea805b40",
   "metadata": {},
   "outputs": [],
   "source": [
    "frac = Rational(3, 4)\n",
    "\n",
    "print(frac)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a7ce194",
   "metadata": {},
   "source": [
    "<hr>\n",
    "<div class=\"alert alert-success alertsuccess\" style=\"margin-top: 30px\">\n",
    "    [TIP]: <code> __init__</code> is one of the reserved methods in Python. In object oriented programming, it is known as a constructor. The <code>__init__</code> method can be called when an object is created from the class, and access is required to initialize the attributes of the class.\n",
    "</div>\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "21cc258e",
   "metadata": {},
   "source": [
    "You might have noticed that both of the methods took as a first argument the keyword `self`. The first argument to any method in a class is the instance of the class upon which the method is being called. Think of a class like a blueprint from which possibly many objects are built. The `self` argument is the mechanism Python uses so that the method can know which instance of the class it is being called upon. When the method is actually called, we can call it in two ways. \n",
    "\n",
    "Lets say we create a class `MyClass` with method .`do_it(self)`, if we instantiate an object from this class, we can call the method in two ways:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0be6a4d6",
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyClass(object):\n",
    "    def __init__(self, num):\n",
    "        self.num = num\n",
    "        \n",
    "    def do_it(self):\n",
    "        print(self.num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ee750534",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating object for class MyClass\n",
    "myclass = MyClass(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "87110ffd",
   "metadata": {},
   "source": [
    "In on way `myclass.do_it()` the `self` argument is understood because `myclass` is an instance of `MyClass`. This is the almost universal way to do call a method.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "58134c1c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# First way\n",
    "myclass.do_it()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf0387c1",
   "metadata": {},
   "source": [
    "The other possibility is `MyClass.do_it(myclass)` where we are passing in the object myclass as the `self` argument, this syntax is much less common."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "813e1bb0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Second way\n",
    "MyClass.do_it(myclass)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b6e4e25d",
   "metadata": {},
   "source": [
    "<br>\n",
    "Like all Python arguments, there is no need for `self` to be named `self`, we could also call it `this or apple or wizard`. However, the use of `self` is a very strong Python convention which is rarely broken. You should use this convention so that your code is understood by other people.\n",
    "\n",
    "Lets get back to our `Rational` class. So far, we can make a `Rational` object and print it out, but it can't do much else. We might also want a `reduce` method that will **divide the numerator and denominator** by their **greatest common divisor**. We will therefore need to write a function that computes the greatest common divisor. We'll add these to our class definition."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e323b936",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Rational(object):\n",
    "\n",
    "    def __init__(self, numerator, denominator):\n",
    "        self.numerator = numerator\n",
    "        self.denominator = denominator\n",
    "\n",
    "    def __repr__(self):\n",
    "        return '%d/%d' % (self.numerator, self.denominator)\n",
    "\n",
    "    def _gcd(self):\n",
    "        smaller = min(self.numerator, self.denominator)\n",
    "        small_divisors = {i for i in range(1, smaller + 1) if smaller % i == 0}\n",
    "        larger = max(self.numerator, self.denominator)\n",
    "        common_divisors = {i for i in small_divisors if larger % i == 0}\n",
    "        return max(common_divisors)\n",
    "\n",
    "    def reduce(self):\n",
    "        gcd = self._gcd() # 5\n",
    "        self.numerator = self.numerator / gcd\n",
    "        self.denominator = self.denominator / gcd\n",
    "        return self"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5f7aaf26",
   "metadata": {},
   "outputs": [],
   "source": [
    "16/32 = 1/2 4/8 * 4/4 = 1/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7b3718f2",
   "metadata": {},
   "outputs": [],
   "source": [
    "fraction = Rational(16, 32)\n",
    "fraction.reduce()\n",
    "print(fraction)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a2d1029",
   "metadata": {},
   "source": [
    "We're gradually building up the functionality of our `Rational` class, but it has a huge problem: we can't do math with it!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "87f2136b",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%expect_exception TypeError\n",
    "\n",
    "print(4 * fraction)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f687b65d",
   "metadata": {},
   "source": [
    "We have to tell Python how to implement mathematical operators `(+, -, *, /)` for our class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e6a4c75f",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(dir(int))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "75b9feb8",
   "metadata": {},
   "source": [
    "<br>\n",
    "\n",
    "If we look at `dir(int)` we see it has hidden methods like __add__, __div__, __mul__, __sub__, etc. Just like __repr__ tells Python how to print our object, these hidden methods tell Python how to handle mathematical operators.\n",
    "\n",
    "Let's add the methods implementing mathematical operations to our class definition. To perform addition or subtraction, we'll have to find a common denominator with the number we're adding. For simplicity, we'll only implement multiplication. We won't be able to add, subtract, or divide. Even implementing only multiplication will require quite a bit of logic.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "80e7910a",
   "metadata": {},
   "outputs": [],
   "source": [
    "else if"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cf8c418e",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Rational(object):\n",
    "\n",
    "    def __init__(self, numerator, denominator):\n",
    "        self.numerator = numerator\n",
    "        self.denominator = denominator\n",
    "\n",
    "    def __repr__(self):\n",
    "        return '%d/%d' % (self.numerator, self.denominator)\n",
    "\n",
    "    def __mul__(self, number = Rational(2, 3)):\n",
    "        if isinstance(number, int):\n",
    "            return Rational(self.numerator * number, self.denominator)\n",
    "        elif isinstance(number, Rational):\n",
    "            return Rational(self.numerator * number.numerator, self.denominator * number.denominator)\n",
    "        else:\n",
    "            raise TypeError('Expected number to be int or Rational. Got %s' % type(number))\n",
    "            \n",
    "    def __rmul__(self, number):\n",
    "        return self.__mul__(number)\n",
    "    \n",
    "    \n",
    "    def _gcd(self):\n",
    "        smaller = min(self.numerator, self.denominator)\n",
    "        small_divisors = {i for i in range(1, smaller + 1) if smaller % i == 0}\n",
    "        larger = max(self.numerator, self.denominator)\n",
    "        common_divisors = {i for i in small_divisors if larger % i == 0}\n",
    "        return max(common_divisors)\n",
    "\n",
    "    def reduce(self):\n",
    "        gcd = self._gcd()\n",
    "        self.numerator = self.numerator / gcd\n",
    "        self.denominator = self.denominator / gcd\n",
    "        return self"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "339c7fd6",
   "metadata": {},
   "source": [
    "<hr>\n",
    "<div class=\"alert alert-success alertsuccess\" style=\"margin-top: 30px\">\n",
    "    [TIP]: The <code>isinstance()</code> function returns <code>True</code> if the specified object is of the specified type, otherwise <code>False</code>. If the type parameter is a <code>tuple</code>, this function will return <code>True</code> if the object is one of the types in the tuple.\n",
    "</div>\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "93b771b8",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(Rational(4, 6) * 3)\n",
    "print(Rational(5, 9) * Rational(2, 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b66ad499",
   "metadata": {},
   "outputs": [],
   "source": [
    "3 * Rational(4, 6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3ba299c2",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%expect_exception TypeError\n",
    "\n",
    "# remember, no support for float\n",
    "print(Rational(4, 6) * 2.3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d4abf9f7",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%expect_exception TypeError\n",
    "\n",
    "# also, no addition, subtraction, etc.\n",
    "print(Rational(4, 6) + Rational(2, 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1bb6ea9d",
   "metadata": {},
   "source": [
    "<br>\n",
    "Defining classes can be a lot of work. We have to imagine all the ways we might want to use an object, and where we might run into trouble. This is also true of defining functions, but classes will typically handle many tasks while a function might only do one."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a984c1ec",
   "metadata": {},
   "source": [
    "<br> <br>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a86b8c3",
   "metadata": {},
   "source": [
    "# Inheritance"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "80c80368",
   "metadata": {},
   "source": [
    ">In object oriented programming, **Inheritance** is the capability of one class to derive or inherit the properties from some other class. \n",
    "\n",
    "**Inheritance** allows us to define a class that inherits all the methods and properties from another class. \n",
    "\n",
    "- **Parent class** is the class being inherited from, also called **base class**.\n",
    "\n",
    "- **Child class** is the class that inherits from another class, also called **derived class**."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a5fbdf1",
   "metadata": {},
   "source": [
    "### Create a Parent Class\n",
    "\n",
    "Let's write a general class called `Rectangle`, it will have two attributes, **a width and a lenght**, as well as a few methods."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "32bcb29e",
   "metadata": {},
   "source": [
    "**FYI:** \n",
    "\n",
    "rectangle:\n",
    "\n",
    "$$area = length * width$$\n",
    "\n",
    " $$perimeter = 2(width + length)$$\n",
    " \n",
    " Square:\n",
    " $$area = a^2$$\n",
    " $$perimeter = 4a$$\n",
    "   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "71a312e5",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Rectangle(object):\n",
    "    def __init__(self, width, length):\n",
    "        self.width = width\n",
    "        self.length = length\n",
    "    \n",
    "    def area(self):\n",
    "        return self.width * self.length\n",
    "    \n",
    "    def perimeter(self):\n",
    "        return 2 * (self.width + self.length)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "0e481c50",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "200"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rec = Rectangle(10, 20)\n",
    "rec.area()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "7ee7468b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "60"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rec.perimeter()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af82146b",
   "metadata": {},
   "source": [
    "## Create a Child class"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb355ff6",
   "metadata": {},
   "source": [
    "Now a `square` is also a `rectangle`, but its somewhat more restricted in that it has the same **height as length**, so we can subclass Rectangle and enforce this in code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "92a5411b",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Square(Rectangle):\n",
    "    \n",
    "    def __init__(self, length):\n",
    "        super(Square, self).__init__(length, length)\n",
    "    \n",
    "        \n",
    "    def area(self):\n",
    "        print(\"Calculating area square...\")\n",
    "        return super(Square, self).area() "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca270d7e",
   "metadata": {},
   "source": [
    "<hr>\n",
    "<div class=\"alert alert-success alertsuccess\" style=\"margin-top: 30px\">\n",
    "    [TIP]: The <code>super()</code>function is used to give access to methods and properties of a parent or sibling class. It returns an object that represents the parent class.\n",
    "</div>\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "e61ab4c0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calculating area square...\n",
      "25\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = Square(5)\n",
    "\n",
    "print(s.area())\n",
    "\n",
    "s.perimeter()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "b92063ef",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Parent class\n",
    "class Person(object):\n",
    "    \n",
    "    def __init__(self, name, age):\n",
    "        self.name = name\n",
    "        self.age = age "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "bf0f5e14",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Child class\n",
    "class Employee(Person):\n",
    "    \n",
    "    def __init__(self, name, age, salary):\n",
    "        super().__init__(name, age) # inherit all property and methods of the super class\n",
    "        \n",
    "        self.salary = salary # add new property\n",
    "        \n",
    "    def display(self):\n",
    "        return \"My name is {} and I'm {} years old. My salary is {} USD.\".format(self.name, self.age, self.salary)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "e7c42ddb",
   "metadata": {},
   "outputs": [],
   "source": [
    "# child\n",
    "class Student(Person):\n",
    "    def __init__(self, name, age):\n",
    "        super().__init__(name, age)\n",
    "    \n",
    "    def display(self, year): \n",
    "        return '''\n",
    "        My name is  {} and I'm {} years old. \n",
    "        I'm a graduate student of the class year {}.'''.format(self.name, self.age, year)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "400ba85b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My name is cesar and I'm 38 years old. My salary is 333 USD.\n"
     ]
    }
   ],
   "source": [
    "e = Employee(\"cesar\", 38, 333)\n",
    "print(e.display())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "8bab1654",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "        My name is  Paul and I'm 18 years old. \n",
      "        I'm a graduate student of the class year 2021.\n"
     ]
    }
   ],
   "source": [
    "st = Student(\"Paul\", 18)\n",
    "print(st.display(2021))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d4f2092f",
   "metadata": {},
   "source": [
    "Sometimes (although not often) we want to actually check the type of a python object (what class it is from). There are two ways of doing this, lets first look at a few examples to get a sense of the difference."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "15f02512",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(e) == Person"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "025d9303",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(st) == Student"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "b39f220b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isinstance(st, Person)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "813d6758",
   "metadata": {},
   "source": [
    "As you might have noticed checking type quality only checks the exact class to which an object belongs, whereas `isinstance(c, Class)` checks if `c` is either a member of class `Class` or a member of a subclass of `Class`.\n",
    "\n",
    "Almost always `isinstance` is the proper way to check this, because if a class implements some sort of functionality, its subclasses usually implement the same functionality (they just might have some extra bonus functionality!)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9741a437",
   "metadata": {},
   "source": [
    "\n",
    "# Summary\n",
    "\n",
    "- Now that we understand `objects and classes`, `Constuctor and Inhritance`\n",
    "\n",
    "- Object oriented programming (OOP) is a perspective that programs are essentially about the creation of objects and the interaction between them. \n",
    "- In OOP, almost every piece of code either describes an object, an object's attributes, or an object's methods. \n",
    "- Keeping this perspective in mind can help us understand what's happening in a program."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6dcb4e05",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "*Copyright &copy; 2021 <a href=\"https://yooutube.com/c/epythonlab\">EPYTHON LAB</a>.  All rights reserved.*"
   ]
  }
 ],
 "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.10.8"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {},
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}