oop-python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Object-Oriented Programming (OOP) in Python 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "https://realpython.com/python3-object-oriented-programming/#instance-attributes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Python 2.x Class Definition:\n",
    "class Dog(object):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Python 3\n",
    "class Dog:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All classes create objects, and all objects contain characteristics called attributes "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Instance Attributes "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use the __init__() method to initialize (e.g., specify) an object’s initial attributes by giving them their default value (or state)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This method must have at least one argument as well as the self variable, which refers to the object itself (e.g., Dog)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ClassName:\n",
    "    # Initializer / Instance Attributes\n",
    "    def __init__(self, attribute1, attribute2, attribute3):\n",
    "        self.attribute1 = attribute1\n",
    "        self.attribute2 = attribute2\n",
    "        self.attribute3 = attribute3\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "self variable is also an instance of the class, helps to keep track of individual instances of each class."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__While instance attributes are specific to each object, class attributes are the same for all instances__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Class Attributes "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ClassName:\n",
    "    \n",
    "    # Class Attribute\n",
    "    calssname = 'ClassName'\n",
    "    \n",
    "    # Initializer / Instance Attributes\n",
    "    def __init__(self, attribute1, attribute2, attribute3):\n",
    "        self.attribute1 = attribute1\n",
    "        self.attribute2 = attribute2\n",
    "        self.attribute3 = attribute3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Car:\n",
    "    # Class Attribute (only Ford cars, nothing else)\n",
    "    carbrand = 'Ford'\n",
    "    \n",
    "    # Initializer / Instance Attributes\n",
    "    def __init__(self, age, engine, mpg):\n",
    "        self.age = age\n",
    "        self.engine = engine\n",
    "        self.mpg = mpg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "car1 = Car(15, 'big', 12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "car2 = Car(3, 'small', 33)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ford\n"
     ]
    }
   ],
   "source": [
    "print(car1.carbrand)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ford\n"
     ]
    }
   ],
   "source": [
    "print(car2.carbrand)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "big\n"
     ]
    }
   ],
   "source": [
    "print(car1.engine)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "small\n"
     ]
    }
   ],
   "source": [
    "print(car2.engine)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Determine the oldest car\n",
    "def get_biggest_number(*args):\n",
    "    return max(args)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The oldest car is 15 years old\n"
     ]
    }
   ],
   "source": [
    "print('The oldest car is ' + str(get_biggest_number(car1.age, car2.age)) + ' years old')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Instance Methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Instance methods are defined inside a class and are used to get the contents of an instance. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ClassName:\n",
    "    \n",
    "    # Class Attribute\n",
    "    calssname = 'ClassName'\n",
    "    \n",
    "    # Initializer / Instance Attributes\n",
    "    def __init__(self, attribute1, attribute2, attribute3):\n",
    "        self.attribute1 = attribute1\n",
    "        self.attribute2 = attribute2\n",
    "        self.attribute3 = attribute3\n",
    "        \n",
    "    # Instance Method\n",
    "    def instance_method(self):\n",
    "        return self.attribute1\n",
    "    \n",
    "    def instance_method2(self, atribute):\n",
    "        return self.attribute1 + atribute"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "carclass = ClassName(15,'small',33)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "carclass.instance_method()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "115"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "carclass.instance_method2(100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Modifying Attributes "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can change the value of attributes based on some behavior:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ClassName:\n",
    "    def __init__(self, attribute1):\n",
    "        self.attribute1 = attribute1\n",
    "    \n",
    "    def change_attr1(self):\n",
    "        self.attribute1 = 100+self.attribute1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "car = ClassName(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "print(car.attribute1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "car.change_attr1()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "105\n"
     ]
    }
   ],
   "source": [
    "print(car.attribute1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python Object Inheritance "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Inheritance is the process by which one class takes on the attributes and methods of another"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Newly formed classes are called child classes, and the classes that child classes are derived from are called parent classes.__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__It’s important to note that child classes override or extend the functionality (e.g., attributes and behaviors) of parent classes.__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Extending the Functionality of a Parent Class "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ClassName:\n",
    "    \n",
    "    # Class Attribute\n",
    "    calssname = 'ClassName'\n",
    "    \n",
    "    # Initializer / Instance Attributes\n",
    "    def __init__(self, attribute1, attribute2, attribute3):\n",
    "        self.attribute1 = attribute1\n",
    "        self.attribute2 = attribute2\n",
    "        self.attribute3 = attribute3\n",
    "        \n",
    "    # Instance Method\n",
    "    def instance_method(self):\n",
    "        return self.attribute1\n",
    "    \n",
    "    def instance_method2(self, atribute):\n",
    "        return self.attribute1 + atribute"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ClassChild1(ClassName):\n",
    "    def child_instance_method(self, attribute4):\n",
    "        return (self.attribute1 + self.attribute2 + self.attribute3) + attribute4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "car = ClassName(10,20,30)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "car2 = ClassChild1(10,20,30)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "160"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "car2.child_instance_method(100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "110"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "car2.instance_method2(100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Parent vs. Child Classes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The isinstance() function is used to determine if an instance is also an instance of a certain parent class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(isinstance(car2, ClassName))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(isinstance(car, ClassName))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(isinstance(car2, ClassChild1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "print(isinstance(car, ClassChild1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# super() lets you avoid referring to the base class explicitly"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But the main advantage comes with multiple inheritance."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Super can be called upon in a single inheritance, in order to refer to the parent class or multiple classes without explicitly naming them. It’s somewhat of a shortcut, but more importantly, it helps keep your code maintainable for the foreseeable future."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Super can be called upon in a dynamic execution environment for multiple or collaborative inheritance."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__The great thing about super is that it can be used to enhance any module method. Plus, there’s no need to know the details about the base class that’s being used as an extender. The super function handles all of it for you.__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "We are printing from ClassChild1\n",
      "***Name set in ClassChild1***  this is Name from the Parent Class called ClassName\n"
     ]
    }
   ],
   "source": [
    "class ClassName(object):\n",
    "  def __init__(self, Name):\n",
    "    print(Name, ' this is Name from the Parent Class called ClassName')\n",
    "    \n",
    "class ClassChild1(ClassName):\n",
    "  def __init__(self):\n",
    "    print('We are printing from ClassChild1')\n",
    "    super().__init__('***Name set in ClassChild1***')\n",
    "    \n",
    "classchild1 = ClassChild1()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# super() with Multiple Inheritance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ClassName(object):\n",
    "  def __init__(self, Name):\n",
    "    self.Name = Name\n",
    "    print(self.Name, 'Name printed in ClassName (Parent Class)')\n",
    "    \n",
    "class ClassChild1(ClassName):\n",
    "  def __init__(self, Child1Name):\n",
    "    print(Child1Name, 'Name printed in ClassChild1')\n",
    "    super().__init__(Child1Name)\n",
    "    \n",
    "class ClassGrandChild1(ClassChild1):\n",
    "  def __init__(self, GName1):\n",
    "    print(GName1, \"Name printed in ClassGrandChild1\")\n",
    "    super().__init__(GName1)\n",
    "\n",
    "class ClassGrandChild2(ClassChild1):\n",
    "  def __init__(self, GName2):\n",
    "    print(GName2, \"Name printed in ClassGrandChild2\")\n",
    "    super().__init__(GName2)\n",
    "    \n",
    "class use_two(ClassGrandChild1, ClassGrandChild2):\n",
    "    def __init__(self):\n",
    "        super().__init__('***Named that will be passed around*** ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "***Named that will be passed around***  Name printed in ClassGrandChild1\n",
      "***Named that will be passed around***  Name printed in ClassGrandChild2\n",
      "***Named that will be passed around***  Name printed in ClassChild1\n",
      "***Named that will be passed around***  Name printed in ClassName (Parent Class)\n"
     ]
    }
   ],
   "source": [
    "class1 = use_two()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "***Named that will be passed around*** Name printed in ClassGrandChild2\n",
      "***Named that will be passed around*** Name printed in ClassChild1\n",
      "***Named that will be passed around*** Name printed in ClassName (Parent Class)\n"
     ]
    }
   ],
   "source": [
    "class2 = ClassGrandChild2(\"***Named that will be passed around***\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:Python3]",
   "language": "python",
   "name": "conda-env-Python3-py"
  },
  "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.5.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}