05. Object Oriented Programing.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Object Oriented Programing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sections\n",
    "- [What is OOP](#What-is-OOP)\n",
    "- [Creating an Object](#Creating-an-Object)\n",
    "- [Attributes and Methods](#Attributes-and-Methods)\n",
    "- [Decorators](#Decorators)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What is OOP"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Everything in Python in an Object.\n",
    "We can create our own class Object with the `class` keyword.\n",
    "\n",
    "In OOP, we use camelCase as convention (each new word starts with a capital letter.\n",
    "\n",
    "The data values stored inside an object are called attributes and the functions associated with the object are methods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating a ver simple class\n",
    "\n",
    "class BigObject:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class '__main__.BigObject'>\n",
      "<class '__main__.BigObject'>\n"
     ]
    }
   ],
   "source": [
    "object_1 = BigObject()      # creates an instance of the class BigObject\n",
    "object_2 = BigObject()      # creates an instance of the class BigObject\n",
    "\n",
    "print(type(object_1))\n",
    "print(type(object_2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class '__main__.Robot'>\n",
      "\n",
      "    This class implements a Robot\n",
      "    \n"
     ]
    }
   ],
   "source": [
    "# A basic class\n",
    "class Robot:\n",
    "    \"\"\"\n",
    "    This class implements a Robot\n",
    "    \"\"\"\n",
    "    pass\n",
    "robot1 = Robot()\n",
    "print(type(robot1))\n",
    "print(robot1.__doc__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class '__main__.Robot'>\n",
      "Robot name:  Cachito\n",
      "Build year:  2040\n",
      "Doc string:  \n",
      "    This class implements a Robot\n",
      "    \n",
      "Dictionary:  {'name': 'Cachito', 'year': 2040}\n"
     ]
    }
   ],
   "source": [
    "# Adding the class constructor (or method) __init__\n",
    "class Robot:\n",
    "    \"\"\"\n",
    "    This class implements a Robot\n",
    "    \"\"\"\n",
    "    def __init__(self, name, year):\n",
    "        self.name = name\n",
    "        self.year = year\n",
    "\n",
    "robot1 = Robot(\"Cachito\", 2040)\n",
    "print(type(robot1))\n",
    "print(\"Robot name: \", robot1.name)\n",
    "print(\"Build year: \", robot1.year)\n",
    "print(\"Doc string: \", robot1.__doc__)\n",
    "print(\"Dictionary: \", robot1.__dict__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Creating a new robot. it's name is: Cachito\n"
     ]
    }
   ],
   "source": [
    "# Adding the class destructor __del__ (involves deallocation of resources)\n",
    "# In Python is not very common because Python has a garbage collector. In some cases is used.\n",
    "class Robot:\n",
    "    \"\"\"\n",
    "    This class implements a Robot\n",
    "    \"\"\"\n",
    "    def __init__(self, name, year):\n",
    "        self.name = name\n",
    "        self.year = year\n",
    "        print(\"Creating a new robot. it's name is:\", self.name)\n",
    "    def __del__(self):\n",
    "        print(\"Bye\", self.name)\n",
    "\n",
    "robot1 = Robot(\"Cachito\", 2040)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bye Cachito\n"
     ]
    }
   ],
   "source": [
    "del robot1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Creating a new robot. it's name is: Cachito\n",
      "Dictionary:  {'name': 'Cachito', 'year': 2040}\n",
      "Dictionary:  {'name': 'Cachito', 'year': 2040, 'energy': 100}\n",
      "Energy available: 100\n",
      "Energy produced: robot without producing\n",
      "Dictionary:  {'name': 'Cachito', 'year': 2040, 'energy': 100}\n"
     ]
    }
   ],
   "source": [
    "class Robot:\n",
    "    \"\"\"\n",
    "    This class implements a Robot\n",
    "    \"\"\"\n",
    "    def __init__(self, name, year):\n",
    "        self.name = name\n",
    "        self.year = year\n",
    "        print(\"Creating a new robot. it's name is:\", self.name)\n",
    "    def setEnergy(self, energy):\n",
    "        self.energy = energy\n",
    "\n",
    "robot1 = Robot(\"Cachito\", 2040)\n",
    "print(\"Dictionary: \", robot1.__dict__)\n",
    "robot1.setEnergy(100)\n",
    "print(\"Dictionary: \", robot1.__dict__)\n",
    "# getattr is another option to get attributes and deflared default values (avoids errors)\n",
    "print(\"Energy available:\", getattr(robot1, \"energy\"))\n",
    "print(\"Energy produced:\", getattr(robot1, \"produced\", \"robot without producing\"))\n",
    "print(\"Dictionary: \", robot1.__dict__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Creating a new robot. it's name is: Arturitu\n",
      "Creating a new robot. it's name is: Citripiu\n",
      "Robot population: 2\n",
      "Robot population: 2\n",
      "Robot population: 2\n"
     ]
    }
   ],
   "source": [
    "class Robot:\n",
    "    \"\"\"\n",
    "    This class implements a Robot\n",
    "    \"\"\"\n",
    "    # Class attributes are declared at the begining, they are available for all instances\n",
    "    # We will add this attribute to see how many instances have been created\n",
    "    population = 0\n",
    "    def __init__(self, name, year):\n",
    "        self.name = name\n",
    "        self.year = year\n",
    "        Robot.population += 1\n",
    "        print(\"Creating a new robot. it's name is:\", self.name)\n",
    "robot1 = Robot(\"Arturitu\", 1989)\n",
    "robot2 = Robot(\"Citripiu\", 1990)\n",
    "print(\"Robot population:\", Robot.population)\n",
    "print(\"Robot population:\", robot1.population)\n",
    "print(\"Robot population:\", robot2.population)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Magic methods\n",
    "\n",
    "- `__init__` : class constructor\n",
    "- `__add__` : addition operator\n",
    "- `__str__` : called when printing the object\n",
    "- `__lt__` : less than\n",
    "- `__gt__` : greater than"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello, I am a robot, my name is Arturitu and I was built in 1989.\n"
     ]
    }
   ],
   "source": [
    "class Robot:\n",
    "    \"\"\"\n",
    "    This class implements a Robot\n",
    "    \"\"\"\n",
    "    # Class attributes are declared at the begining, they are available for all instances\n",
    "    # We will add this attribute to see how many instances have been created\n",
    "    population = 0\n",
    "    def __init__(self, name, year):\n",
    "        self.name = name\n",
    "        self.year = year\n",
    "        Robot.population += 1\n",
    "    def __str__(self):\n",
    "        return f\"hello, I am a robot, my name is {self.name} and I was built in {self.year}.\"\n",
    "        \n",
    "robot1 = Robot(\"Arturitu\", 1989)\n",
    "print(robot1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating a more complex class\n",
    "class PlayerCharacter:\n",
    "    membership = True                     # this will be an attribute for all instances\n",
    "    \n",
    "    def __init__(self, name=\"anonymous\", age=0):\n",
    "        if age >= 18: \n",
    "            self.name = name              # this will be an attribute\n",
    "            self.age = age\n",
    "            print(f\"Created player: {self.name}\")\n",
    "        else:\n",
    "            print(\"Sorry, you are underage to play this game.\")\n",
    "    \n",
    "    def run(self):\n",
    "        print(f\"{self.name} RUUUNNN!\")    # this will be a method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Created player: Yopi\n",
      "Sorry, you are underage to play this game.\n"
     ]
    }
   ],
   "source": [
    "player1 = PlayerCharacter(\"Yopi\", 44)\n",
    "player2= PlayerCharacter(\"Tupi\", 11)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<__main__.PlayerCharacter object at 0x0000014EE69DC108>\n"
     ]
    }
   ],
   "source": [
    "print(player1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Yopi\n"
     ]
    }
   ],
   "source": [
    "print(player1.name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "44\n"
     ]
    }
   ],
   "source": [
    "print(player1.age)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Yopi RUUUNNN!\n"
     ]
    }
   ],
   "source": [
    "player1.run()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "player1.membership"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "player1.attack = 50                   # We can add an attribute, even is not defined"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "50"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "player1.attack"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Decorators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This ones are not very common, and are part of decorators.\n",
    "\n",
    "- `@classmethod`\n",
    "You can call methods without instanciating a class.\n",
    "\n",
    "- `@staticmethod`\n",
    "You can call methods without instanciating a class.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Encapsultaion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The four pilars of Object Oriented programing are:\n",
    "- Encapsulation: we encapsulate data and functions in an object.\n",
    "- Abstracion: hide information an show only the necesary.\n",
    "- inheritance: alows new objects to take properties of existing objects\n",
    "- Polymorphism: mean many forms, in Python refers that object clases can share the same method names, and change them."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inheritance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Attacking with power of magic.\n"
     ]
    }
   ],
   "source": [
    "# Example of inheritance\n",
    "\n",
    "class User:\n",
    "    def sign_in(self):\n",
    "        print(\"logged in\")\n",
    "\n",
    "class Wizard(User):\n",
    "    def __init__(self, name, power):\n",
    "        self.name = name\n",
    "        self.power = power\n",
    "    def attack(self):\n",
    "        print(f\"Attacking with power of {self.power}.\")\n",
    "        \n",
    "class Archer(User):\n",
    "    def __init__(self, name, arrows):\n",
    "        self.name = name\n",
    "        self.arrows = arrows\n",
    "    def attack(self):\n",
    "        print(f\"Attacking with arrows: arrows left {self.arrows}.\")\n",
    "\n",
    "wizard1 = Wizard(\"Merlin\", \"magic\")\n",
    "archer1 = Archer(\"Robin\", 50)\n",
    "wizard1.attack()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# In Python we have a funtion to verify if an object is an instance of a class\n",
    "print(isinstance(wizard1, Wizard))\n",
    "print(isinstance(wizard1, User))\n",
    "# the object class is an object base class, this allows all objects to inheret all dunder methods in Python\n",
    "print(isinstance(wizard1, object))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Polymorphism"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Attacking with power of magic.\n"
     ]
    }
   ],
   "source": [
    "# Example of polymorphism\n",
    "# Wizard and Archer shared the same method name attack\n",
    "\n",
    "class User:\n",
    "    def sign_in(self):\n",
    "        print(\"logged in\")\n",
    "\n",
    "class Wizard(User):\n",
    "    def __init__(self, name, power):\n",
    "        self.name = name\n",
    "        self.power = power\n",
    "    def attack(self):\n",
    "        print(f\"Attacking with power of {self.power}.\")\n",
    "        \n",
    "class Archer(User):\n",
    "    def __init__(self, name, arrows):\n",
    "        self.name = name\n",
    "        self.arrows = arrows\n",
    "    def attack(self):\n",
    "        print(f\"Attacking with arrows: arrows left {self.arrows}.\")\n",
    "\n",
    "def player_attack(char):\n",
    "    char.attack()\n",
    "        \n",
    "wizard1 = Wizard(\"Merlin\", \"magic\")\n",
    "archer1 = Archer(\"Robin\", 50)\n",
    "\n",
    "wizard1.attack()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Extending properties of functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100\n",
      "5\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "class SuperList(list):\n",
    "    def __len__(self):\n",
    "        return 100\n",
    "\n",
    "super_list1 = SuperList()\n",
    "\n",
    "print(len(super_list1))\n",
    "super_list1.append(5)\n",
    "print(super_list1[0])\n",
    "print(issubclass(SuperList, list))\n",
    "print(issubclass(list, object))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Method Resolution Order"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Method resolution Order or MRO"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "[<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]\n"
     ]
    }
   ],
   "source": [
    "class A:\n",
    "    num = 10\n",
    "    \n",
    "class B(A):\n",
    "    pass\n",
    "\n",
    "class C(A):\n",
    "    num = 1\n",
    "\n",
    "class D(B, C):\n",
    "    pass\n",
    "\n",
    "print(D.num)\n",
    "print(D.mro())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Private vs Public variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "in Python, to define a private variable, you use underscore. that meeans that is a private variable an not any programer should change that"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We use a snlge _ to show that we should not touch that variable name\n",
    "class PlayerCharacter:   \n",
    "    def __init__(self, name=\"anonymous\", age=0):\n",
    "        if age >= 18: \n",
    "            self._name = name             \n",
    "            self._age = age\n",
    "        def run(self):\n",
    "            print(f\"{self.name} RUNNNN!\")\n",
    "        \n",
    "        def speak(self):\n",
    "            print(f\"My name is {self.name} and I am {self.age} years old.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dunders methods we should not change them too."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dunder methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Many function sin Python are implemented using dunder methods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<__main__.Toy object at 0x0000014EE6995AC8>\n",
      "<__main__.Toy object at 0x0000014EE6995AC8>\n"
     ]
    }
   ],
   "source": [
    "class Toy():\n",
    "    def __init__(self, color, age):\n",
    "        self.color =color\n",
    "        self.age = age\n",
    "\n",
    "action_figure = Toy(\"red\", 0)\n",
    "# lets see a dunder method that has a builtin function\n",
    "print(action_figure.__str__())\n",
    "print(str(action_figure))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "red\n",
      "red\n",
      "5\n",
      "deleted\n"
     ]
    }
   ],
   "source": [
    "# We can modified (not recommended)\n",
    "class Toy():\n",
    "    def __init__(self, color, age):\n",
    "        self.color =color\n",
    "        self.age = age\n",
    "    def __str__(self):\n",
    "        return f\"{self.color}\"\n",
    "    def __len__(self):\n",
    "        return 5\n",
    "    def __deleted__(self):\n",
    "        return \"deleted\"\n",
    "    \n",
    "action_figure = Toy(\"red\", 0)\n",
    "# lets see a dunder method that has a builtin function\n",
    "print(action_figure.__str__())\n",
    "print(str(action_figure))\n",
    "print(len(action_figure))\n",
    "print(action_figure.__deleted__())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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
}