oops.ipynb.ipynb.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "a24cfffd-0fb6-4943-bbb4-e1b769fd9766",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "a=\"Anushka\"\n",
    "print(type(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "1b53330a-0ff8-4bb1-b1d5-cd8145aba3bf",
   "metadata": {},
   "outputs": [],
   "source": [
    "#above code is printing <class 'str'> so what is this class\n",
    "#class= is basically a blue print for a real world entity but not exactly entity is holds basic info of that entity\n",
    "#object is basically a real world entity \n",
    "#classes brings modularity in the code it also incs reusability it becomes others to debug the code with the hepl of oops concpets\n",
    "#creating a class\n",
    "class c1:\n",
    "    #write code of the specified class here it can conyain variables , methods if we want to create a blank class use pass key\n",
    "    #without any code interpreter will throw err\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "8df8354a-b9af-4241-92d9-aaf97c89e1a8",
   "metadata": {},
   "outputs": [],
   "source": [
    "#if we create any method inside a class then we should use self as a arg in tha method to bind it with the class\n",
    "class c2:\n",
    "    def welMsg(self):\n",
    "        print(\"hey anushka welcome to python learning course\")\n",
    "#we always create a instance or object of a  class to use it \n",
    "co=c2()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "a7eb172b-b43c-4a17-aa25-77df5b8502da",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hey anushka welcome to python learning course\n"
     ]
    }
   ],
   "source": [
    "#we access any method of a class throug its object using the dot(.)\n",
    "co.welMsg()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "39e374b0-b736-44b0-88e8-73274b2a41d1",
   "metadata": {},
   "outputs": [],
   "source": [
    "#we can also pass data for various people by using various obj\n",
    "class c3:\n",
    "    #thhis fun is basically the constructor executuin will start forom it\n",
    "    def __init__(self,name,idd,phn):\n",
    "        #here we will use self keyword to bind the variable with the class or tell class that its ur variab;e\n",
    "        self.name=name\n",
    "        self.idd=idd\n",
    "        self.phn=phn\n",
    "    def get_stdnts_details(self):\n",
    "        #we have to use self keyword to access class variable\n",
    "        return self.name, self.idd,self.phn\n",
    "me=c3(\"Anushka\",19,9044823845)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "406983ce-9714-4d5d-929d-5a36fe0ae314",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('Anushka', 19, 9044823845)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "me.get_stdnts_details()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "d83b09d8-9f34-4f14-852d-94a3f9a1b2a3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('suehl', 112, 8979966833)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#similarly we can creat obj for other students\n",
    "#we cna creat infinite no of obj of a class\n",
    "friend1=c3(\"suehl\",112,8979966833)\n",
    "friend1.get_stdnts_details()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "639e9668-4d45-4f9b-8ee2-9d61a292c6fd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'suehl'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#we can access val of a perticular attribute of obj by obj.atrname \n",
    "friend1.name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "fdd8dc87-8d33-4cd7-89ee-eddef5d7f41f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Ansu;a'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#we can access only class methods or attributes using the obj. accessor for eg--\n",
    "class c4:\n",
    "    #thhis fun is basically the constructor executuin will start forom it\n",
    "    def __init__(self,name,idd,phn):\n",
    "        #here we will use self keyword to bind the variable with the class or tell class that its ur variab;e\n",
    "        self.name1=name\n",
    "        self.idd1=idd\n",
    "        self.phn1=phn\n",
    "    def get_stdnts_details(self):\n",
    "        #we have to use self keyword to access class variable\n",
    "        return self.name1, self.idd1,self.phn1\n",
    "em1=c4(\"Ansu;a\",199,87465)\n",
    "#em1.name willl show err because inside the class the class's atribute is name1 so we have access atr's value by name1 only not by the name by whicj init method's atr is \n",
    "em1.name1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "9df2539b-4cbd-406c-b3fa-f5d9997cd1c2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'siya'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#here IMPORTANT is that self is not the reserve keyword to bind a method or atr with the class we can use any valid var name \n",
    "#but will have to use same throughout\n",
    "#the first arg is just a pointer to indicate that it is to be binded with class\n",
    "class c5:\n",
    "    #thhis fun is basically the constructor executuin will start forom it\n",
    "    def __init__(anu,name,idd,phn):\n",
    "        #here we will use self keyword to bind the variable with the class or tell class that its ur variab;e\n",
    "        anu.name=name\n",
    "        anu.idd=idd\n",
    "        anu.phn=phn\n",
    "    def get_stdnts_details(anu):\n",
    "        #we have to use self keyword to access class variable\n",
    "        return anu.name, anu.idd,anu.phn\n",
    "a=c5(\"siya\",67,456773)\n",
    "a.name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "2c34ad30-d506-41dc-9e48-0a46e4dda55d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('siya', 67, 456773)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.get_stdnts_details()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "86b143dc-f177-4e3c-8e7c-d92e5ff45567",
   "metadata": {},
   "source": [
    "polymorphism"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "965f44e6-652e-4344-9979-b9526f401c03",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#poly -  many morphs- forms means that any entity can have different different roles.works, forms at diff places or situations\n",
    "def c6(x,y):\n",
    "    return x+y\n",
    "c6(5,6)#will show addition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "dad51a4f-a2f6-42eb-a5aa-5aef7921b85f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ansuhka gupta'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c6(\"ansuhka \",\"gupta\")#will show concatenation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "f6c90daf-0070-46a2-a63d-a7f9c2024343",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c6([1,2],[3,4])#will show list concatenation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "9af924e0-4def-4367-b53d-805cdcb05c7e",
   "metadata": {},
   "outputs": [],
   "source": [
    "class me:\n",
    "    def qualities(self):\n",
    "        print(\"cutu cutu\")\n",
    "class he:\n",
    "    def qualities(self):\n",
    "        print(\"sexu sexu\")\n",
    "class us:\n",
    "    def quality(self,l):\n",
    "        for i in l:\n",
    "            i.qualities()\n",
    "em=me()\n",
    "eh=he()\n",
    "su=us()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "2b91b255-ddeb-4b4d-b184-8478d13df16a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cutu cutu\n",
      "sexu sexu\n"
     ]
    }
   ],
   "source": [
    "l=[em,eh]\n",
    "su.quality(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc8c4e47-cdfb-4537-b38d-989224a47979",
   "metadata": {},
   "source": [
    "encapsulation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "1fbd9c1d-3faa-45e4-9ca3-386758e441bc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#encapsulation is basically hiding of unnecessary or important data from the user\n",
    "class e:\n",
    "    def __init__(self,a,b):\n",
    "        self.a=a\n",
    "        self.b=b\n",
    "eo=e(4,5)\n",
    "#we can see vlue of a by even we can see number of attributes by clicking tab below after the eo.\n",
    "#but this is against privacy any user can see and modify data\n",
    "eo.a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "a8b4d6ab-de77-4ded-a215-6616a305b8d9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "345"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eo.a=345\n",
    "eo.a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "b343becb-7ac0-42a0-9d47-de1b9382a3f2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "78"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#so prevent user from stealing the data or changing the data we use encapsulation\n",
    "#we can define privilage and availabe actions for ther user so that he can access or modify only allowed data\n",
    "class e1:\n",
    "    def __init__(self,speed,model,year,company):\n",
    "        #we use __ befor the variable to make it private to the class\n",
    "        self.__speed=speed\n",
    "        self.__model=model\n",
    "        self.__year=year\n",
    "        self.__company=company\n",
    "\n",
    "eo1=e1(45,\"fortuner\",2015,\"toyota\")\n",
    "#after writing eo1. if we press tab we wont get any info about the class atrbs even we cant acces or get or change value of atr\n",
    "#eo1.speed err--'e1' object has no attribute 'speed' because we have made that private\n",
    "#we can only access it by using class name like obj._classname__varname\n",
    "#it wil save data because user dont knows class name cause ut is wrapped in a module\n",
    "eo1._e1__speed=78\n",
    "eo1._e1__speed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "a2c71daf-95c0-4cc9-9820-8b6b876dea75",
   "metadata": {},
   "outputs": [],
   "source": [
    "#insted of this class menthod we can set getters and setters method to set and get speed and other atrbs\n",
    "class e1:\n",
    "    def __init__(self,speed,model,year,company):\n",
    "        #we use __ befor the variable to make it private to the class\n",
    "        self.__speed=speed\n",
    "        self.__model=model\n",
    "        self.__year=year\n",
    "        self.__company=company\n",
    "    #here we are not allowing uers to access variables directly insted made a variable for user to modify and accesss\n",
    "    def set_speed(self,speed):\n",
    "        self.__speed=speed\n",
    "    def get_speed(self):\n",
    "        print(self.__speed)\n",
    "eo2=e1(45,\"fortuner\",2017,\"toyota\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "1ba2737c-5397-42e1-b916-12dcd67db407",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "45\n"
     ]
    }
   ],
   "source": [
    "#we are getting functions here by pressing tab after eo2. cause for now methods are not private\n",
    "eo2.get_speed()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "84cff1f1-35de-43bd-8c4e-fca3750db869",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "75\n"
     ]
    }
   ],
   "source": [
    "eo2.set_speed(75)\n",
    "eo2.get_speed()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "0e6b6c40-130d-42f0-9051-15e6714d7daa",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3000"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class bank_account:\n",
    "    def __init__(self,balance):\n",
    "        self.__balance=balance\n",
    "    def deposit(self,amount):\n",
    "        self.__balance=self.__balance+amount\n",
    "        print(\"now your balance is \",self.__balance)\n",
    "    def withdraw(self,amount):\n",
    "        if self.__balance>=amount:\n",
    "            self.__balance= self.__balance-amount\n",
    "            print(\"now your balance is \",self.__balance)\n",
    "        else:\n",
    "            print(\"your account have only rs\",self.__balance,\"so please enter a lesser or equal amount to it\")\n",
    "    def get_balance(self):\n",
    "        return self.__balance\n",
    "anu=bank_account(3000)\n",
    "anu.get_balance()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "1cb0527e-11b5-4a9d-b811-aa99241623c1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "now your balance is  4000\n"
     ]
    }
   ],
   "source": [
    "anu.deposit(1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "5e3a2fa6-dbf2-42eb-b497-479c22cb81c8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "now your balance is  3000\n"
     ]
    }
   ],
   "source": [
    "anu.withdraw(1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "1550309d-2fb3-4bd9-8561-37b497daf661",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "your account have only rs 3000 so please enter a lesser or equal amount to it\n"
     ]
    }
   ],
   "source": [
    "anu.withdraw(10000)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "207aad65-2974-4b29-982b-b0b20eaa1124",
   "metadata": {},
   "source": [
    "inheritance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "fc66a172-90b2-4b51-a0cb-13735f7c77c8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this is my first class\n"
     ]
    }
   ],
   "source": [
    "#inheritance is basiically a property of taking data atr or methods from another class by calling it during creating child class\n",
    "#child class may not have the atr or method but still it can use its parents classes properties\n",
    "class parent:\n",
    "    def fun1(self):\n",
    "        print(\"this is my first class\")\n",
    "class child(parent):\n",
    "    def fun2(self):\n",
    "        print(\"this mehod is of second class\")\n",
    "inchild=child()\n",
    "#without even declaring the method fun1 the child class accessd it\n",
    "inchild.fun1()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "2b4972c9-97ac-40ac-8549-64e59ea79f7f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this is my first class\n"
     ]
    }
   ],
   "source": [
    "#multilevel inheritance\n",
    "#class1-->class2-->class3 here class3 can access the methods of class1 also beacuse its parent class has extended parnt cls so it can also use its methohds\n",
    "class child1(child):\n",
    "    pass\n",
    "inchild1=child1()\n",
    "#here pressing tab after inchild1. we get that its showing fun1 and fun2 both because of multilevel inheritance\n",
    "inchild1.fun1()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "9ae542b8-9892-4c3a-97ba-229e62df0ee9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this mehod is of second class\n"
     ]
    }
   ],
   "source": [
    "inchild1.fun2()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "89bc509b-d6c7-4948-bf47-b77dcc80420e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this is my first class\n"
     ]
    }
   ],
   "source": [
    "#multiple inheritance class3 can access class1 and class2 both but class2 is not accessing class1 is multiple inheritance\n",
    "# parent  parent1\n",
    "#   \\      /\n",
    "#    child2\n",
    "class parent1:\n",
    "    def fun3(self):\n",
    "        print(\"this is parent1 class:\")\n",
    "        #below is the syntax how we apply multiple inheritance\n",
    "class child2(parent, parent1):\n",
    "    pass\n",
    "inchild2=child2()\n",
    "#after pressing tab after inchild2. we are getting mehtods of parent and parent1 both due to multiple inheritance\n",
    "inchild2.fun1()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "0f3cb94b-1f1d-45aa-b1e2-60e8769b14ad",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this is parent1 class:\n"
     ]
    }
   ],
   "source": [
    "inchild2.fun3()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "003ead49-346c-4409-ae67-8a4d8538ec12",
   "metadata": {},
   "source": [
    "Decoraters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "5b325719-0a8f-4091-a9b7-fea16f4f62f3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "here my function starts\n",
      "here is the execution\n",
      "here my function end\n"
     ]
    }
   ],
   "source": [
    "#are basically used for assigning something whener a function is called and started its execution and whenever a func ends\n",
    "#it is widely used for calculating the time used for executing a function by finding start time - end time eg--\n",
    "def printi():\n",
    "    print(\"here my function starts\")\n",
    "    print(\"here is the execution\")\n",
    "    print(\"here my function end\")\n",
    "    #the short way of doing abovw work is basicaly decorators\n",
    "    #if i want to do it for 100000000 times then we have to write it for 1000000000 times \n",
    "    #but with decorators we define decorator fun once then we can use it 1000000000 times \n",
    "printi()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "d5a3c8dc-abaf-4bb3-aa56-8a56a6b56874",
   "metadata": {},
   "outputs": [],
   "source": [
    "#basic structure of deco function\n",
    "def deco(func):\n",
    "    def inner_deco():\n",
    "        print(\"here my function starts\")\n",
    "        func()\n",
    "        print(\"here my function ends\")\n",
    "    return inner_deco"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "7e067d97-7e26-482f-8407-44ae788f14c9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "here my function starts\n",
      "0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 here my function ends\n"
     ]
    }
   ],
   "source": [
    "#to use it call it before defining a function as @deco\n",
    "#this will put the function as arg of the deco function and further execution will occur according to syntax of deco fn\n",
    "@deco\n",
    "def useDeco():\n",
    "    for i in range(100):\n",
    "        print(i,end=\" \")\n",
    "useDeco()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "aa25e881-ab21-4156-9867-99de82a8986b",
   "metadata": {},
   "outputs": [],
   "source": [
    "#create decorator fun to calculate execution time of a fn\n",
    "from time import time\n",
    "def decotime(func):\n",
    "    def inner_decotime():\n",
    "        start= time()\n",
    "        func()\n",
    "        end=time()\n",
    "        print(\"time taken is \",end-start)\n",
    "    return inner_decotime"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "0a92c69f-cac6-444f-9471-ab046ec529f5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 time taken is  0.0004038810729980469\n"
     ]
    }
   ],
   "source": [
    "@decotime\n",
    "def useDeco1():\n",
    "    for i in range(100):\n",
    "        print(i,end=\" \")\n",
    "useDeco1()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "295b7517-00b3-46d7-a26b-fbac861d6e5c",
   "metadata": {},
   "source": [
    "class method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "048065c7-2c9c-4b20-be4a-cae2a1b33a00",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "anushka 12\n"
     ]
    }
   ],
   "source": [
    "#python does not allows func overloading so if we need to overload the constructor we use class method \n",
    "#class method is just another way of defining , calling a class\n",
    "#eg in normal case:\n",
    "class cm1:\n",
    "    def __init__(self,name, classs):\n",
    "        self.name = name\n",
    "        self.classs=classs\n",
    "    def printtDet(self):\n",
    "        print(self.name,self.classs)\n",
    "cmo=cm1(\"anushka\",12)\n",
    "#we can access everything like method, arg of the class and function by this obj \n",
    "#but there is another mtethod class method by which we can acces everything without even creating the object\n",
    "cmo.printtDet()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "04154adf-f424-4a76-8c86-d7059070796e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<__main__.cm2 at 0x7f19404980a0>"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#with the help of this class method we can overload the __init__ method aka constructor\n",
    "class cm2:\n",
    "    def __init__(self,name, classs):\n",
    "        self.name = name\n",
    "        self.classs=classs\n",
    "    #init is basically a constructor so it works when we create the obj and then pass value as the arg \n",
    "    #here we are using cls as a pointer to bind the metjod with the class \n",
    "    #we can also do it with the help of self pointer also but since it used in init method so we hav to create obj to use it\n",
    "    #but without self we can call this method without creating obj\n",
    "    #now the below is the prototype for the class method function we also have to write a predefined decorator above to this class method\n",
    "    #here decorator decorates the below method in such a way that if we call below method instead of calling init we can enter data\n",
    "    #and also this enterd data by this method will also be available throughout the class\n",
    "    @classmethod\n",
    "    def enterDetail(cls,name,classs):\n",
    "        return cls(name,classs)\n",
    "    def printtDet(self):\n",
    "        print(self.name,self.classs)\n",
    "#calling the class method of this class without creating the object of the class\n",
    "cm2.enterDetail(\"anudhka\",10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "7aee8db6-f03d-425c-9334-af1e19c8ca36",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "anudhka 10\n"
     ]
    }
   ],
   "source": [
    "#here we are trying to overload init method means without creating obj by init, direct access all args and methods by this class method \n",
    "cmo1=cm2.enterDetail(\"anudhka\",10)\n",
    "cmo1.printtDet()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "6b00c7ca-1245-40c0-b72e-b7714766b516",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'anudhka'"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#we can also get args by this \n",
    "cmo1.name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "1e9514df-235f-43d8-8ff6-0bbcd95415c9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9042545222"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#class method is basically something which we can access directly with class name without creating obj and changed var which we remain throughout\n",
    "class cm3:\n",
    "    mob_no=9042545222\n",
    "    def __init__(self,name, classs):\n",
    "        self.name = name\n",
    "        self.classs=classs\n",
    "    @classmethod\n",
    "    def change_nmbr(cls,mob_no):\n",
    "        cm3.mob_no=mob_no\n",
    "    @classmethod\n",
    "    def enterDetail(cls,name,classs):\n",
    "        return cls(name,classs)\n",
    "    #we can pass class var in a method by below way\n",
    "    def printtDet(self):\n",
    "        print(self.name,self.classs,cm3.mob_no)#here we are using clsname.clsvar not self coz it is cls var\n",
    "cm3.mob_no"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "2daa5b62-9838-4461-8b63-18f50ac36053",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9044823844"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cm3.change_nmbr(9044823844)\n",
    "cm3.mob_no"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "a6b9db00-aa56-408a-a2a4-7e0e63ca1f99",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "anushhh 12 9044823844\n"
     ]
    }
   ],
   "source": [
    "#the first way by which we can declare the class obj and access its method which are not clas method\n",
    "#1- by creating obj with init------\n",
    "#here if we have to access a method whch is not class method we have to create the obj of clas\n",
    "cm3_obj=cm3(\"anushhh\",12)#we are pasing 2 arg cause class's constructor init have only 2 args\n",
    "cm3_obj.printtDet()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "a3daf637-10d9-4361-9202-a79224a2351a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "anushkawwwwww 12 9044823844\n"
     ]
    }
   ],
   "source": [
    "#2- by creating obj with class method------\n",
    "cm3_obj1=cm3.enterDetail(\"anushkawwwwww\",12)\n",
    "cm3_obj1.printtDet()\n",
    "#so now we can conclude that normaly method overloading is not available in the pythob=n but with the help of class method we can achieve fun over;oading"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "bbb846ec-9e21-429b-9d93-157037f83b6d",
   "metadata": {},
   "outputs": [],
   "source": [
    "#now we are creating a external func and we want to make it a part of class method--\n",
    "def courses(cls,coursename):\n",
    "    print(\"course is : \" , coursename)\n",
    "#if we try now if this method can be accessed by class cm3??? check it by pressing tab\n",
    "#cm3.prss tab , its not showing thw courses mehtod"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "e36400a5-4ad8-4c8f-a8e3-159ac6bd1e6e",
   "metadata": {},
   "outputs": [],
   "source": [
    "#to add this as a class method we do follloeing procedure\n",
    "cm3.courses=classmethod(courses)#inbuilt method to add a ext method inside a classmethod"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "b64c8765-1ae8-4d14-b90f-c8cbe11b1a95",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "course is :  datascience\n"
     ]
    }
   ],
   "source": [
    "#now cm3.prss tab , its now showing the courses mehtod\n",
    "cm3.courses(\"datascience\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "c10ac6c1-2170-4147-80b2-3584deb3202b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def mentor(cls, list_mentors):\n",
    "    print(list_mentors)\n",
    "cm3.mentor=classmethod(mentor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "583aade4-af32-4019-a439-07ebbd950f65",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['ashu', 'chukkku', 'anuu']\n"
     ]
    }
   ],
   "source": [
    "cm3.mentor([\"ashu\", \"chukkku\",\"anuu\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "511e492d-52ae-4756-bf9f-86c9484ff954",
   "metadata": {},
   "outputs": [],
   "source": [
    "#deleting a classmethod--\n",
    "class cm4:\n",
    "    mob_no=9042545222\n",
    "    def __init__(self,name, classs):\n",
    "        self.name = name\n",
    "        self.classs=classs\n",
    "    @classmethod\n",
    "    def change_nmbr(cls,mob_no):\n",
    "        cm4.mob_no=mob_no\n",
    "    @classmethod\n",
    "    def enterDetail(cls,name,classs):\n",
    "        return cls(name,classs)\n",
    "    #we can pass class var in a method by below way\n",
    "    def printtDet(self):\n",
    "        print(self.name,self.classs,cm4.mob_no)\n",
    "#cm4.presstab will show all the methods written"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "7927372e-6580-4f0c-a72b-cbe0f5cdc664",
   "metadata": {},
   "outputs": [],
   "source": [
    "#lets delete the change_nmbr method--\n",
    "del cm4.change_nmbr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "cf1b5cb5-7469-4739-9fe6-83e6009159fe",
   "metadata": {},
   "outputs": [],
   "source": [
    "#cm4.presstab not showing change_nmbr function\n",
    "#one more method to dlt a class method\n",
    "delattr(cm4,\"enterDetail\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "82ccada8-cb99-4ca9-a6cd-45663fc30331",
   "metadata": {},
   "outputs": [],
   "source": [
    "#cm4.presstab not showing enterDetail function :)\n",
    "#by delattr we can dlt the method inside a class which is not a classmethod , yes we can\n",
    "delattr(cm4,\"printtDet\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "4781ccb5-a0f6-48a5-abfc-362f2fa59729",
   "metadata": {},
   "outputs": [],
   "source": [
    "#cm4.presstab not showing printtDet function :)\n",
    "##by delattr we can dlt the class variable also\n",
    "delattr(cm4,\"mob_no\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "3fdb639c-aac0-4154-870c-c406fad49fcf",
   "metadata": {},
   "outputs": [],
   "source": [
    "#cm4.presstab not showing mob_no variable"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1aac00d5-18c8-4e9a-a0e8-0d4d9425b7c9",
   "metadata": {},
   "source": [
    "static method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "e8ccefdd-53c5-4aa4-980f-98e58cb39ce1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['ansujla', 'ajkhd']\n"
     ]
    }
   ],
   "source": [
    "#class method binds the method to the class \n",
    "#but we want to create a method that we can access without creating a obj and that aslo not binds with the class \n",
    "#we can do it by a static method ;)\n",
    "#we use it to create utilities\n",
    "class sm1:\n",
    "    def stddetail(self,name, ids):\n",
    "        print(self,name, ids)\n",
    "    @staticmethod\n",
    "    def mentors(listofmentor):#its not binded and created as a normal method and we can access it without creating obj diret by cls name\n",
    "        print(listofmentor)\n",
    "sm1.mentors([\"ansujla\",\"ajkhd\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "d25d0498-6fe9-4526-959e-69df266d8194",
   "metadata": {},
   "outputs": [],
   "source": [
    "#this is usefull like mentor for any class are limited and if we bind it with class to jitne bar class obj bnege utne bar mentor bnega\n",
    "#mtlb jitne student utne montor :_) but ye to possible nhi hai hence its usefull to create static method here\n",
    "class sm1:\n",
    "    def stddetail(self,name, ids):\n",
    "        print(self,name, ids)\n",
    "    @staticmethod\n",
    "    def mentors(listofmentor):#its not binded and created as a normal method and we can access it without creating obj diret by cls name\n",
    "        print(listofmentor)\n",
    "    def mentor(self,mentorlist):\n",
    "        print(self,mentorlist)\n",
    "    #here every time when the obj of this fn is created then the instance of this method is also created in the memory\n",
    "    #sp the memory consumption will be high so static method saves the memory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "31125959-1700-4e73-b1b1-276d65813099",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this is clalss method\n",
      "['ansuhka', 'gupta']\n",
      "anushkagupta@gmail.com\n"
     ]
    }
   ],
   "source": [
    "#using a static method inside a static method, class method , instance method----\n",
    "class sm1:\n",
    "    def stddetail(self,name, ids):\n",
    "        print(self,name, ids)\n",
    "    @staticmethod\n",
    "    def mentors_id(mentors_id):#its not binded and created as a normal method and we can access it without creating obj diret by cls name\n",
    "        print(mentors_id)\n",
    "    #calling a static method inside a staitc method---\n",
    "    @staticmethod\n",
    "    def mentors(listofmentor):#its not binded and created as a normal method and we can access it without creating obj diret by cls name\n",
    "        print(listofmentor)\n",
    "        sm1.mentors_id(\"anushkagupta@gmail.com\")\n",
    "    #using static inside instance fn---\n",
    "    def mentor(self):\n",
    "        print(\"this is a instance class\")\n",
    "        self.mentors([\"ansuhka\",\"gupta\"])\n",
    "    #using static inside class method fn---\n",
    "    @classmethod\n",
    "    def clas_method(cls):\n",
    "        print(\"this is clalss method\")\n",
    "        cls.mentors([\"ansuhka\",\"gupta\"])#sm1.mentors() missing 1 required positional argument: 'listofmentor'\n",
    "#since we have called cls.mentors(); so we have to pass arg of mentors method listoofmentor\n",
    "sm1.clas_method()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "afd43343-ed43-4c08-93c5-9ab110554efb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['ansuhka', 'gupta']\n",
      "anushkagupta@gmail.com\n"
     ]
    }
   ],
   "source": [
    "sm1.mentors([\"ansuhka\",\"gupta\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "bfe4d467-0eb9-45be-b3d2-db5fd4274b2e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this is a instance class\n",
      "['ansuhka', 'gupta']\n",
      "anushkagupta@gmail.com\n"
     ]
    }
   ],
   "source": [
    "#for using the instance method we have to create a obj of the class\n",
    "so1=sm1()\n",
    "so1.mentor()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "649aacb2-9d00-4569-967a-0b8c4708eb6d",
   "metadata": {},
   "source": [
    "special(magic/dunder) methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "4dfcbd29-1ad6-4208-8b2d-09ff2b8eea0e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__abs__',\n",
       " '__add__',\n",
       " '__and__',\n",
       " '__bool__',\n",
       " '__ceil__',\n",
       " '__class__',\n",
       " '__delattr__',\n",
       " '__dir__',\n",
       " '__divmod__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__float__',\n",
       " '__floor__',\n",
       " '__floordiv__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__getnewargs__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__index__',\n",
       " '__init__',\n",
       " '__init_subclass__',\n",
       " '__int__',\n",
       " '__invert__',\n",
       " '__le__',\n",
       " '__lshift__',\n",
       " '__lt__',\n",
       " '__mod__',\n",
       " '__mul__',\n",
       " '__ne__',\n",
       " '__neg__',\n",
       " '__new__',\n",
       " '__or__',\n",
       " '__pos__',\n",
       " '__pow__',\n",
       " '__radd__',\n",
       " '__rand__',\n",
       " '__rdivmod__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__rfloordiv__',\n",
       " '__rlshift__',\n",
       " '__rmod__',\n",
       " '__rmul__',\n",
       " '__ror__',\n",
       " '__round__',\n",
       " '__rpow__',\n",
       " '__rrshift__',\n",
       " '__rshift__',\n",
       " '__rsub__',\n",
       " '__rtruediv__',\n",
       " '__rxor__',\n",
       " '__setattr__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__sub__',\n",
       " '__subclasshook__',\n",
       " '__truediv__',\n",
       " '__trunc__',\n",
       " '__xor__',\n",
       " 'as_integer_ratio',\n",
       " 'bit_count',\n",
       " 'bit_length',\n",
       " 'conjugate',\n",
       " 'denominator',\n",
       " 'from_bytes',\n",
       " 'imag',\n",
       " 'numerator',\n",
       " 'real',\n",
       " 'to_bytes']"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#dunder methods-- __dunderMethodName__\n",
    "#dunder methods-- __dunderMethodName__\n",
    "#below will show what func are used to implement integer's various fns\n",
    "dir(int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "635c7e7d-6d95-490e-a44e-2575e3d4c3f7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__add__',\n",
       " '__class__',\n",
       " '__contains__',\n",
       " '__delattr__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__getitem__',\n",
       " '__getnewargs__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__init__',\n",
       " '__init_subclass__',\n",
       " '__iter__',\n",
       " '__le__',\n",
       " '__len__',\n",
       " '__lt__',\n",
       " '__mod__',\n",
       " '__mul__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__rmod__',\n",
       " '__rmul__',\n",
       " '__setattr__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__subclasshook__',\n",
       " 'capitalize',\n",
       " 'casefold',\n",
       " 'center',\n",
       " 'count',\n",
       " 'encode',\n",
       " 'endswith',\n",
       " 'expandtabs',\n",
       " 'find',\n",
       " 'format',\n",
       " 'format_map',\n",
       " 'index',\n",
       " 'isalnum',\n",
       " 'isalpha',\n",
       " 'isascii',\n",
       " 'isdecimal',\n",
       " 'isdigit',\n",
       " 'isidentifier',\n",
       " 'islower',\n",
       " 'isnumeric',\n",
       " 'isprintable',\n",
       " 'isspace',\n",
       " 'istitle',\n",
       " 'isupper',\n",
       " 'join',\n",
       " 'ljust',\n",
       " 'lower',\n",
       " 'lstrip',\n",
       " 'maketrans',\n",
       " 'partition',\n",
       " 'removeprefix',\n",
       " 'removesuffix',\n",
       " 'replace',\n",
       " 'rfind',\n",
       " 'rindex',\n",
       " 'rjust',\n",
       " 'rpartition',\n",
       " 'rsplit',\n",
       " 'rstrip',\n",
       " 'split',\n",
       " 'splitlines',\n",
       " 'startswith',\n",
       " 'strip',\n",
       " 'swapcase',\n",
       " 'title',\n",
       " 'translate',\n",
       " 'upper',\n",
       " 'zfill']"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#these are called as magic fn caouse these these are inbuilt and just by passing name it does work so magically our work is done\n",
    "dir(str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "832d823f-d90e-46b5-8024-888edc7b20e0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "105"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#eg--\n",
    "a=100\n",
    "a+5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "ddb3ac15-8413-498f-83c2-6c7711710e64",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "106"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#how do above fn performs?\n",
    "#it does it with a magic or dunder fn\n",
    "#actual executuin looks like\n",
    "a.__add__(6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "a1d71e5f-9db8-4a6f-aaab-60a0c76d59ce",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8247365"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class fn1:\n",
    "    def __init__(self):\n",
    "        self.my_no=8247365\n",
    "fno1=fn1()     \n",
    "fno1.my_no"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "610c928c-759b-47db-885c-194780d2f15f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hey this is new\n"
     ]
    }
   ],
   "source": [
    "#here we think that firstly init is called but its not true , first new fn is called to crt the obj of cls\n",
    "#new method helps us in terms of creating instance of a fun\n",
    "class fn2:\n",
    "    def __new__(self):\n",
    "        print(\"hey this is new\")\n",
    "    def __init__(self):\n",
    "        print(\"hey this is init\")\n",
    "fno2=fn2()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "c3a2d7c1-c750-43f2-b6c9-0f27b0be1b18",
   "metadata": {},
   "outputs": [],
   "source": [
    "fno2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "4363653a-2f36-4a2e-9860-842877390c13",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hey this is init\n",
      "hey this is str\n"
     ]
    }
   ],
   "source": [
    "class fn3:\n",
    "    def __init__(self):\n",
    "        print(\"hey this is init\")\n",
    "    def __str__(self):\n",
    "        return \"hey this is str\"\n",
    "#on printing the obj of a fn <__main__.fn2 object at 0x7f760c3fe860> but if we want to pring something specific about fn we use str method of fb\n",
    "fno3=fn3()\n",
    "print(fno3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "3a2b1577-5cb7-4dbf-93b3-c8d3c55f2ea3",
   "metadata": {},
   "outputs": [],
   "source": [
    "#important--- we dont use magic or dunder fn directly inko system internally call kr leta hai so avoid using these fn"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b71e4a62-4e22-4b18-9cc2-cc0edbf29503",
   "metadata": {},
   "source": [
    "Property Decorators Getters, Setters, And Deletes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "f01f4633-5b49-4c70-adee-28424eb60b7a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'dbms'"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#we cant access private variables of a class to access them indirectly we create getters and setters function to get and set values\n",
    "class fn4:\n",
    "    def __init__(self,course_id,course_price):\n",
    "        self.course_id=course_id\n",
    "        self.__course_price=course_price\n",
    "fno4=fn4(\"dbms\",34)\n",
    "fno4.course_id\n",
    "#but cant access and change __course_price var because its private"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "b20d966b-e0fa-405d-8d19-1a91f22271c4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "34"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#so to resolve it we create methods setter and getter to access it indirectly with methods\n",
    "class fn5:\n",
    "    def __init__(self,course_id,course_price):\n",
    "        self.course_id=course_id\n",
    "        self.__course_price=course_price\n",
    "    @property\n",
    "    def getter_course_price(self):\n",
    "        return self.__course_price\n",
    "    @getter_course_price.setter\n",
    "    def setter_course_price(self,price):\n",
    "        if price<3500:\n",
    "            print(\"cantt be less than 3500\")\n",
    "        else :\n",
    "            self.__course_price=price\n",
    "fno5=fn5(\"dbms\",34)\n",
    "fno5.getter_course_price"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "05dbfe65-fdba-4233-88f6-9c2689d827e0",
   "metadata": {},
   "outputs": [],
   "source": [
    "#to set\n",
    "fno5.setter_course_price=5000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "872e1ca4-76ec-466e-8364-8b98f5edaa54",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5000"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fno5.getter_course_price"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "53f24ae0-0da6-4984-a563-06a6103fc413",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "34"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#\n",
    "class fn6:\n",
    "    def __init__(self,course_id,course_price):\n",
    "        self.course_id=course_id\n",
    "        self.__course_price=course_price\n",
    "    @property\n",
    "    def getter_course_price(self):\n",
    "        return self.__course_price\n",
    "    @getter_course_price.setter\n",
    "    def setter_course_price(self,price):\n",
    "        if price<3500:\n",
    "            print(\"cantt be less than 3500\")\n",
    "        else :\n",
    "            self.__course_price=price\n",
    "    #to delete var\n",
    "    @getter_course_price.deleter\n",
    "    def del_course_price(self):\n",
    "        del self.__course_price\n",
    "fno6=fn6(\"dbms\",34)\n",
    "fno6.getter_course_price"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "2a77a54f-638f-4121-867f-6af288c0b6c1",
   "metadata": {},
   "outputs": [],
   "source": [
    "#now if we want to del course price var we have to call fn\n",
    "del fno6.del_course_price"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "db6a89fe-567b-4d15-a671-01e71bb40536",
   "metadata": {},
   "outputs": [],
   "source": [
    "#fno6.getter_course_price  showing err 'fn6' object has no attribute '_fn6__course_price' \"hence successfully deleted the var"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fd683eba-e512-4f65-9bdd-686451b385b1",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "735cec8e-902f-4f37-aca2-2edef3ef3847",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}