.ipynb_checkpoints/OOPS-checkpoint.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Object oriented programming\n",
    "\n",
    "\n",
    "In all the programs we wrote till now, we have designed our program around functions i.e. blocks of statements which manipulate data. This is called the procedure-oriented way of programming.\n",
    "\n",
    "There is another way of organizing your program which is to combine data and functionality and wrap it inside something called an object. This is called the object oriented programming paradigm.\n",
    "\n",
    "Most of the time you can use procedural programming, but when writing large programs or have a problem that is better suited to this method, you can use object oriented programming techniques.\n",
    "\n",
    "Classes and objects are the two main aspects of object oriented programming. A class creates a new type where objects are instances of the class.\n",
    "\n",
    "1. Encapsulation\n",
    "2. Abstraction\n",
    "3. Inheritance\n",
    "4. Polymorphism\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "a=5\n",
    "print(isinstance(a,object))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<__main__.Person object at 0x00ADB070>\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    pass\n",
    "\n",
    "p = Person()\n",
    "print(p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Math:\n",
    "    def add(a, b):\n",
    "        return a+b\n",
    "    \n",
    "    def sub(a, b):\n",
    "        return a-b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "m=Math()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Math.add(5,6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dunders or Magic Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "class Car:\n",
    "    def __init__(self, model, mileage):\n",
    "        self.model = model\n",
    "        self.mileage = mileage\n",
    "    \n",
    "    def __str__(self):\n",
    "        return \"model: {} mileage: {}\".format(self.model, self.mileage)\n",
    "    \n",
    "    def __eq__(self, other):\n",
    "        return self.mileage == other.mileage\n",
    "    \n",
    "    def __gt__(self, other):\n",
    "        return self.mileage > other.mileage\n",
    "    \n",
    "    def __lt__(self, other):\n",
    "        return False\n",
    "\n",
    "    def __add__(self, other):\n",
    "        return self.mileage + other.mileage"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "c1 = Car('sr',74)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "c2 = Car('sc',21)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "95"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c1+c2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c1==c2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "model: sr mileage: 74\n"
     ]
    }
   ],
   "source": [
    "print(str(c1))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c1<c2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Ostream:\n",
    "    def __lshift__(self,other):\n",
    "        print(other,end='')\n",
    "        return self"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "cout = Ostream()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SCSR"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<__main__.Ostream at 0xe22050>"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cout << \"SC\" << \"SR\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Class with a method\n",
    "Class methods have only one specific difference from ordinary functions - they must have an extra first name that has to be added to the beginning of the parameter list, but you do not give a value for this parameter when you call the method, Python will provide it. This particular variable refers to the object itself, and by convention, it is given the name self."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SR\n",
      "Hello, how are you SR?\n",
      "Hello, how are you SC?\n",
      "Hello, how are you SR?\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    \n",
    "    name = \"SR\"\n",
    "    \n",
    "    def __init__(self):\n",
    "        pass\n",
    "    \n",
    "    def say_hi(context):\n",
    "        print('Hello, how are you ' + context.name +  \"?\")\n",
    "        \n",
    "    def change(self):\n",
    "        self.name = \"SC\"\n",
    "p = Person()\n",
    "print(p.name)\n",
    "p.say_hi()\n",
    "p.change()\n",
    "p.say_hi()\n",
    "\n",
    "p1 = Person()\n",
    "p1.say_hi()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, my name is SR\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    def __init__(self, name):\n",
    "        self.name = 'SR'\n",
    "\n",
    "    def say_hi(self):\n",
    "        print('Hello, my name is', self.name)\n",
    "\n",
    "p = Person('SC')\n",
    "p.say_hi()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dog:\n",
    "    kind = 'canine'         # class variable shared by all instances\n",
    "\n",
    "    def __init__(self, name):\n",
    "        self.name = name    # instance variable unique to each instance\n",
    "    def change_kind(self, kind):\n",
    "        self.kind = kind"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tommy\n",
      "pug\n",
      "tommy2\n",
      "canine\n"
     ]
    }
   ],
   "source": [
    "tommy = Dog('tommy')\n",
    "tommy.change_kind('pug')\n",
    "\n",
    "print(tommy.name)\n",
    "print(tommy.kind)\n",
    "\n",
    "tommy2 = Dog('tommy2')\n",
    "print(tommy2.name)\n",
    "print(tommy2.kind)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dog:\n",
    "\n",
    "    tricks = set()          # mistaken use of a class variable\n",
    "\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "\n",
    "    def add_trick(self, trick):\n",
    "        self.tricks.add(trick)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'jump'}\n"
     ]
    }
   ],
   "source": [
    "dog1 = Dog(\"adam\")\n",
    "dog1.add_trick(\"jump\")\n",
    "print(dog1.tricks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'jump', 'something'}\n"
     ]
    }
   ],
   "source": [
    "dog2 = Dog(\"sweeny\")\n",
    "dog2.add_trick(\"something\")\n",
    "print(dog2.tricks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'jump', 'something'}\n"
     ]
    }
   ],
   "source": [
    "\n",
    "dog3 = Dog(\"klasjdfl\")\n",
    "print(dog3.tricks)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Inheritance\n",
    "One of the major benefits of object oriented programming is reuse of code and one of the ways this is achieved is through the inheritance mechanism. Inheritance can be best imagined as implementing a type and subtype relationship between classes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Initialized SchoolMember: SR)\n",
      "heya !\n",
      "(Initialized Teacher: SR)\n",
      "heya !\n",
      "(Initialized SchoolMember: SC)\n",
      "heya !\n",
      "(Initialized Student: SC)\n"
     ]
    }
   ],
   "source": [
    "class SchoolMember:\n",
    "    '''Represents any school member.'''\n",
    "    def __init__(self, name, age):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "        print('(Initialized SchoolMember: {})'.format(self.name))\n",
    "        self.base()\n",
    "\n",
    "    def tell(self):\n",
    "        '''Tell my details.'''\n",
    "        print('Name:\"{}\" Age:\"{}\"'.format(self.name, self.age), end=\" \")\n",
    "        \n",
    "    def base(self):\n",
    "        print(\"heya !\")\n",
    "\n",
    "class Teacher(SchoolMember):\n",
    "    '''Represents a teacher.'''\n",
    "    def __init__(self, name, age, salary):\n",
    "        SchoolMember.__init__(self, name, age)\n",
    "#         self.name = name\n",
    "#         self.age = age\n",
    "        self.salary = salary\n",
    "        print('(Initialized Teacher: {})'.format(self.name))\n",
    "        self.base()\n",
    "\n",
    "    def tell(self):\n",
    "        SchoolMember.tell(self)\n",
    "        print('Salary: \"{:d}\"'.format(self.salary))\n",
    "        \n",
    "        \n",
    "class Student(SchoolMember):\n",
    "    '''Represents a student.'''\n",
    "    def __init__(self, name, age, marks):\n",
    "        #SchoolMember.__init__(self, name, age)\n",
    "        super().__init__( name, age)\n",
    "        self.marks = marks\n",
    "        print('(Initialized Student: {})'.format(self.name))\n",
    "\n",
    "    def tell(self):\n",
    "        SchoolMember.tell(self)\n",
    "        print('Marks: \"{:d}\"'.format(self.marks))\n",
    "\n",
    "        \n",
    "t = Teacher('SR', 40, 3000000)\n",
    "s = Student('SC', 25, 75)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "class A:\n",
    "    pass\n",
    "class B(A):\n",
    "    x = 5\n",
    "class C(B):\n",
    "    pass\n",
    "class D(A):\n",
    "    x = 10\n",
    "\n",
    "class E( C, D):\n",
    "    def show(self):\n",
    "        print(self.x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "e = E()\n",
    "e.show()"
   ]
  },
  {
   "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
}