ObjectOrientedProgramming.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# Object Oriented Programming\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list1 = [10,20,30 ,20]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remember how we could call methods on a list?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list1.count(20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Objects\n",
    "In Python, *everything is an object*. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "<class 'str'>\n",
      "<class 'list'>\n",
      "<class 'tuple'>\n",
      "<class 'dict'>\n"
     ]
    }
   ],
   "source": [
    "print(type(10))\n",
    "print(type(\"daman\"))\n",
    "print(type([]))\n",
    "print(type(()))\n",
    "print(type({}))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## class\n",
    "User defined objects are created using the <code>class</code> keyword. \n",
    "\n",
    "The class is a blueprint that defines the nature of a future object.\n",
    "From classes we can construct instances/objects. \n",
    "An instance is a specific object created from a particular class. \n",
    "\n",
    "For example, above we created the object <code>list1</code> which was an instance of a list object. \n",
    "\n",
    "\n",
    "Class                            Employees  ====    ===   Dict            List\n",
    "Instance ===Object               Daman , Sachin  ======    dict1           l1\n",
    " \n",
    "Attributes                        Age, Name, PhoneNo      key , value\n",
    "Methods==Functions                 SalCalc()               .keys(), "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'Employee' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-3-11da4e069d96>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0mdict1\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m{\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m4\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m}\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0mEmployee\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      4\u001b[0m \u001b[0me_obj\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mEmployee\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mNameError\u001b[0m: name 'Employee' is not defined"
     ]
    }
   ],
   "source": [
    "dict1 = {2:3,4:3}\n",
    "\n",
    "Employee\n",
    "e_obj = Employee()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class\n",
    "create obj of the class\n",
    "\n",
    "using object of class, attributes , methods\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a new object type called Sample\n",
    "class Sample123:\n",
    "    pass\n",
    "    \n",
    "\n",
    "# Instance of Sample\n",
    "x = Sample123()\n",
    "\n",
    "print(type(x))\n",
    "\n",
    "#Common noun  === Class Name\n",
    "#Proper noun ==== Instance Name /Object Name\n",
    "\n",
    "#class Dog\n",
    "\n",
    "#Objects : Snow , petter , Leo\n",
    "\n",
    "#Attributes : breed , age , height\n",
    "\n",
    "#Methods : bark, sit , stand\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By convention we give classes a name that starts with a capital letter. \n",
    "\n",
    "By x , we **instantiate** the Sample class.\n",
    "\n",
    "Inside of the class we currently just have pass. But we can define class attributes and methods.\n",
    "\n",
    "An **attribute** is a characteristic of an object.\n",
    "A **method** is an operation we can perform with the object.\n",
    "\n",
    "For example, we can create a class called Dog. An attribute of a dog may be its breed or its name, while a method of a dog may be defined by a .bark() method which returns a sound.\n",
    "\n",
    "\n",
    "## Attributes\n",
    "The syntax for creating an attribute is:\n",
    "    \n",
    "    self.attribute = something\n",
    "    \n",
    "There is a special method called:\n",
    "\n",
    "    __init__()\n",
    "\n",
    "This method is used to initialize the attributes of an object. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Bike:\n",
    "    def __init__(self,type1 ,x1 , y1 , z1):\n",
    "        self.type = type1\n",
    "        self.x = x1\n",
    "        self.y = y1\n",
    "        self.z = z1\n",
    "        print(\"Object has been created\")\n",
    "        \n",
    "daman = Bike(type1 = ' Road ' , x1 = 1 ,y1 = 3 ,z1 = 5)\n",
    "print(daman.x)\n",
    "sachin = Bike(\"Mountain\" , 3 ,5 ,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(daman.type)\n",
    "print(daman.x)\n",
    "print(daman.y)\n",
    "print(daman.z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note how we don't have any parentheses after breed; this is because it is an attribute and doesn't take any arguments.\n",
    "\n",
    "In Python there are also *class object attributes*. These Class Object Attributes are the same for any instance of the class. For example, we could create the attribute *species* for the Dog class. Dogs, regardless of their breed, name, or other attributes, will always be mammals. We apply this logic in the following manner:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "snow = Dog('Lab','Sam')\n",
    "snow1 = Dog('Lab1','Sam1')\n",
    "print(snow.breed)\n",
    "print(snow.species)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(snow.name)\n",
    "print(snow.breed)\n",
    "print(snow.species)\n",
    "print(snow1.name)\n",
    "print(snow1.breed)\n",
    "print(snow1.species)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the Class Object Attribute is defined outside of any methods in the class. Also by convention, we place them first before the init."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dog():\n",
    "    \"\"\"A simple attempt to model a dog.\"\"\"\n",
    "\n",
    "    def __init__(self, name, age):   #name = x ,age = 2\n",
    "        \"\"\"Initialize name and age attributes.\"\"\"   \n",
    "        self.name = name              #snow.name = x\n",
    "        self.age = age\n",
    "\n",
    "    def sit(self):\n",
    "        \"\"\"Simulate a dog sitting in response to a command.\"\"\"\n",
    "        print(self.name.title() + \" is now sitting.\")\n",
    " \n",
    "    def roll_over(self):\n",
    "         \"\"\"Simulate rolling over in response to a command.\"\"\"\n",
    "         print(self.name.title() + \" rolled over!\")\n",
    "\n",
    "snow = Dog('x' , 2)\n",
    "snow.sit()\n",
    "snow.roll_over()\n",
    "print(snow.name)\n",
    "print(snow.age)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Methods\n",
    "\n",
    "Methods are functions defined inside the body of a class. They are used to perform operations with the attributes of our objects. Methods are a key concept of the OOP paradigm. They are essential to dividing responsibilities in programming, especially in large applications.\n",
    "\n",
    "You can basically think of methods as functions acting on an Object that take the Object itself into account through its *self* argument.\n",
    "\n",
    "Let's go through an example of creating a Circle class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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 * self.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 * Circle.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())\n",
    "\n",
    "c.setRadius(10)\n",
    "c.setRadius(5)\n",
    "\n",
    "print('Radius is: ',c.radius)\n",
    "print('Area is: ',c.area)\n",
    "print('Circumference is: ',c.getCircumference())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the \\__init__ method above, in order to calculate the area attribute, we had to call Circle.pi. This is because the object does not yet have its own .pi attribute, so we call the Class Object Attribute pi instead.<br>\n",
    "In the setRadius method, however, we'll be working with an existing Circle object that does have its own pi attribute. Here we can use either Circle.pi or self.pi.<br><br>\n",
    "Now let's change the radius and see how that affects our Circle object:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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",
   "metadata": {},
   "source": [
    "\n",
    "## Inheritance\n",
    "\n",
    "Inheritance is a way to form new classes using classes that have already been defined. The newly formed classes are called derived classes, the classes that we derive from are called base classes. Important benefits of inheritance are code reuse and reduction of complexity of a program. The derived classes (descendants) override or extend the functionality of base classes (ancestors).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = Dog()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d.whoAmI()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d.eat()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d.bark()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, we have two classes: Animal and Dog. The Animal is the base class, the Dog is the derived class. \n",
    "\n",
    "The derived class inherits the functionality of the base class. \n",
    "\n",
    "* It is shown by the eat() method. \n",
    "\n",
    "The derived class modifies existing behavior of the base class.\n",
    "\n",
    "* shown by the whoAmI() method. \n",
    "\n",
    "Finally, the derived class extends the functionality of the base class, by defining a new bark() method."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Polymorphism\n",
    "\n",
    "We've learned that while functions can take in different arguments, methods belong to the objects they act on. In Python, *polymorphism* refers to the way in which different object classes can share the same method name, and those methods can be called from the same place even though a variety of different objects might be passed in. The best way to explain this is by example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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": "markdown",
   "metadata": {},
   "source": [
    "Here we have a Dog class and a Cat class, and each has a `.speak()` method. When called, each object's `.speak()` method returns a result unique to the object.\n",
    "\n",
    "There a few different ways to demonstrate polymorphism. First, with a for loop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for pet in [niko,felix]:\n",
    "    print(pet.speak())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another is with functions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pet_speak(pet):\n",
    "    print(pet.speak())\n",
    "\n",
    "pet_speak(niko)\n",
    "pet_speak(felix)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "In both cases we were able to pass in different object types, and we obtained object-specific results from the same mechanism.\n",
    "\n",
    "A more common practice is to use abstract classes and inheritance. An abstract class is one that never expects to be instantiated. For example, we will never have an Animal object, only Dog and Cat objects, although Dogs and Cats are derived from Animals:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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",
   "metadata": {},
   "source": [
    "Real life examples of polymorphism include:\n",
    "* opening different file types - different tools are needed to display Word, pdf and Excel files\n",
    "* adding different objects - the `+` operator performs arithmetic and concatenation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"2\"+\"2\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Special Methods\n",
    "Finally let's go over special methods. Classes in Python can implement certain operations with special method names. These methods are not actually called directly but by Python specific language syntax. For example let's create a Book class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "book = Book(\"Python Rocks!\", \"Jose Portilla\", 159)\n",
    "\n",
    "#Special Methods\n",
    "print(book)\n",
    "print(len(book))\n",
    "del book"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    The __init__(), __str__(), __len__() and __del__() methods\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.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 1_2_5\n",
    "y = 2\n",
    "res = x*y\n",
    "res\n",
    "type(x)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if 9 == 9.0:\n",
    "    print(\"HI\")"
   ]
  },
  {
   "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}