05_OOP/05_oop.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "figured-estate",
   "metadata": {},
   "source": [
    "In Python, everything is an **object**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "ranking-hebrew",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "<class 'list'>\n",
      "<class 'tuple'>\n",
      "<class 'dict'>\n"
     ]
    }
   ],
   "source": [
    "print(type(1))\n",
    "print(type([]))\n",
    "print(type(()))\n",
    "print(type({}))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "quarterly-retailer",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class '__main__.Sample'>\n"
     ]
    }
   ],
   "source": [
    "# Create a new object type called Sample\n",
    "class Sample:\n",
    "    pass\n",
    "\n",
    "# Instance of Sample\n",
    "x = Sample()\n",
    "\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "light-workshop",
   "metadata": {},
   "source": [
    "**self** is like **this** keyword in Java.\n",
    "\n",
    "**init()** function is like the **constructor** in Java."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "certain-yemen",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dog:\n",
    "    def __init__(self, breed):\n",
    "        self.breed = breed\n",
    "        \n",
    "sam = Dog(breed = 'Lab')\n",
    "frank = Dog(breed = 'Huskie')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "reduced-intersection",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Huskie'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "frank.breed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "separated-spider",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Lab'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sam.breed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "above-activation",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dog:\n",
    "    \n",
    "    # Class Object Attribute\n",
    "    species = 'mammal'\n",
    "\n",
    "    def __init__(self, breed, name):\n",
    "        self.breed = breed\n",
    "        self.name = name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "marked-banner",
   "metadata": {},
   "outputs": [],
   "source": [
    "sam = Dog('Lab', 'Sam')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "everyday-adolescent",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'mammal'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sam.species"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fewer-sperm",
   "metadata": {},
   "source": [
    "### Methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "periodic-biography",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Radius is:  1\n",
      "Area is:  3.14\n",
      "Circumference is:  6.28\n"
     ]
    }
   ],
   "source": [
    "class Circle:\n",
    "    pi = 3.14\n",
    "\n",
    "    # Circle gets instantiated with a radius (default is 1)\n",
    "    def __init__(self, radius=1):\n",
    "        self.radius = radius \n",
    "        self.area = radius * radius * Circle.pi\n",
    "\n",
    "    # Method for resetting Radius\n",
    "    def setRadius(self, new_radius):\n",
    "        self.radius = new_radius\n",
    "        self.area = new_radius * new_radius * self.pi\n",
    "\n",
    "    # Method for getting Circumference\n",
    "    def getCircumference(self):\n",
    "        return self.radius * self.pi * 2\n",
    "\n",
    "\n",
    "c = Circle()\n",
    "\n",
    "print('Radius is: ', c.radius)\n",
    "print('Area is: ', c.area)\n",
    "print('Circumference is: ', c.getCircumference())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "institutional-feedback",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Radius is:  2\n",
      "Area is:  12.56\n",
      "Circumference is:  12.56\n"
     ]
    }
   ],
   "source": [
    "c.setRadius(2)\n",
    "\n",
    "print('Radius is: ', c.radius)\n",
    "print('Area is: ', c.area)\n",
    "print('Circumference is: ', c.getCircumference())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "banned-evanescence",
   "metadata": {},
   "source": [
    "## Inheritance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "controversial-eight",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Animal:\n",
    "    def __init__(self):\n",
    "        print(\"Animal created\")\n",
    "\n",
    "    def whoAmI(self):\n",
    "        print(\"Animal\")\n",
    "\n",
    "    def eat(self):\n",
    "        print(\"Eating\")\n",
    "\n",
    "\n",
    "class Dog(Animal):\n",
    "    def __init__(self):\n",
    "        Animal.__init__(self)\n",
    "        print(\"Dog created\")\n",
    "\n",
    "    def whoAmI(self):\n",
    "        print(\"Dog\")\n",
    "\n",
    "    def bark(self):\n",
    "        print(\"Woof!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "trying-whole",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Animal created\n",
      "Dog created\n"
     ]
    }
   ],
   "source": [
    "d = Dog()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "external-draft",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dog\n"
     ]
    }
   ],
   "source": [
    "d.whoAmI()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "patent-painting",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Eating\n"
     ]
    }
   ],
   "source": [
    "d.eat()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "wrong-metallic",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Woof!\n"
     ]
    }
   ],
   "source": [
    "d.bark()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dated-search",
   "metadata": {},
   "source": [
    "## Polymorphism"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "dominant-awareness",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Niko says Woof!\n",
      "Felix says Meow!\n"
     ]
    }
   ],
   "source": [
    "class Dog:\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "\n",
    "    def speak(self):\n",
    "        return self.name + ' says Woof!'\n",
    "    \n",
    "class Cat:\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "\n",
    "    def speak(self):\n",
    "        return self.name + ' says Meow!' \n",
    "    \n",
    "niko = Dog('Niko')\n",
    "felix = Cat('Felix')\n",
    "\n",
    "print(niko.speak())\n",
    "print(felix.speak())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "careful-guarantee",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Niko says Woof!\n",
      "Felix says Meow!\n"
     ]
    }
   ],
   "source": [
    "for pet in [niko, felix]:\n",
    "    print(pet.speak())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "resistant-moral",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Niko says Woof!\n",
      "Felix says Meow!\n"
     ]
    }
   ],
   "source": [
    "def pet_speak(pet):\n",
    "    print(pet.speak())\n",
    "\n",
    "pet_speak(niko)\n",
    "pet_speak(felix)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "opponent-worker",
   "metadata": {},
   "source": [
    "## Abstract Class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "voluntary-portuguese",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fido says Woof!\n",
      "Isis says Meow!\n"
     ]
    }
   ],
   "source": [
    "class Animal:\n",
    "    def __init__(self, name):    # Constructor of the class\n",
    "        self.name = name\n",
    "\n",
    "    def speak(self):              # Abstract method, defined by convention only\n",
    "        raise NotImplementedError(\"Subclass must implement abstract method\")\n",
    "\n",
    "\n",
    "class Dog(Animal):\n",
    "    \n",
    "    def speak(self):\n",
    "        return self.name + ' says Woof!'\n",
    "    \n",
    "class Cat(Animal):\n",
    "\n",
    "    def speak(self):\n",
    "        return self.name + ' says Meow!'\n",
    "    \n",
    "fido = Dog('Fido')\n",
    "isis = Cat('Isis')\n",
    "\n",
    "print(fido.speak())\n",
    "print(isis.speak())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "discrete-hammer",
   "metadata": {},
   "source": [
    "## Special Methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "lucky-broadway",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Book:\n",
    "    def __init__(self, title, author, pages):\n",
    "        print(\"A book is created\")\n",
    "        self.title = title\n",
    "        self.author = author\n",
    "        self.pages = pages\n",
    "\n",
    "    def __str__(self):\n",
    "        return \"Title: %s, author: %s, pages: %s\" %(self.title, self.author, self.pages)\n",
    "\n",
    "    def __len__(self):\n",
    "        return self.pages\n",
    "\n",
    "    def __del__(self):\n",
    "        print(\"A book is destroyed\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "tested-thanksgiving",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A book is created\n",
      "Title: Great Expectations, author: Charles Dickens, pages: 320\n",
      "320\n",
      "A book is destroyed\n"
     ]
    }
   ],
   "source": [
    "book = Book(\"Great Expectations\", \"Charles Dickens\", 320)\n",
    "\n",
    "#Special Methods\n",
    "print(book)\n",
    "print(len(book))\n",
    "del book"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "floral-grant",
   "metadata": {},
   "source": [
    "The __init__(), __str__(), __len__() and __del__() methods\n",
    "\n",
    "These special methods are defined by their use of underscores. They allow us to use Python specific functions on objects created through our class."
   ]
  }
 ],
 "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.9.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}