Python16.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "9c1f20fa",
   "metadata": {},
   "source": [
    "# Last Discussed\n",
    "\n",
    " - Vs Code\n",
    " - Exceptions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6ca3e09c",
   "metadata": {},
   "source": [
    "# Today Discussed\n",
    "\n",
    "- Object Oriented Programing\n",
    "- OOP in Python\n",
    "- Class\n",
    "- Object\n",
    "- Self\n",
    "- Init\n",
    "- Updating/Changing attribute value directly\n",
    "- Updating/Changing attribute value by get & set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "a5d43dd0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# what is object oriented programing?\n",
    "# what are other types of programing?\n",
    "# what we have learn so far is what type of programing?\n",
    "\"\"\"\n",
    "Procedural programing - write line by line or step by step and code execute step by step\n",
    "Functional programing - using function and than call them\n",
    "Object Oriented Programing - Everything inside OOP is an object\n",
    "\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f78307e",
   "metadata": {},
   "source": [
    "### OOP stands for Object-Oriented Programming.\n",
    "\n",
    "Procedural programming is about writing procedures or functions that perform operations on the data, while object-oriented programming is about creating objects that contain both data and functions."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "94c86456",
   "metadata": {},
   "source": [
    "Object-oriented programming (OOP) is a computer programming model that organizes software design around data, or objects, rather than functions and logic. An object can be defined as a data field that has unique attributes and behavior."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ab258e03",
   "metadata": {},
   "source": [
    "Object-oriented programming is a programming paradigm based on the concept of \"objects\", which can contain data and code: data in the form of fields, and code, in the form of procedures"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ac6c64a",
   "metadata": {},
   "source": [
    "There are four main coding styles:\n",
    "    \n",
    "    - Imperative\n",
    "    - Functional\n",
    "    - Object Oriented\n",
    "    - Procedural"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "669d004c",
   "metadata": {},
   "source": [
    " In Python everything is Object"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8b7d93e1",
   "metadata": {},
   "source": [
    "int, str, list, set, bool, dic, tuple, these are object in python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "55431a84",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Class is a map / blueprint / model\n",
    "# Class is a definition of object"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f0c0bf7",
   "metadata": {},
   "source": [
    "A class describes the contents of the objects that belong to it: it describes an aggregate of data fields (called instance variables), and defines the operations (called methods). object: an object is an element (or instance) of a class; objects have the behaviors of their class."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd96c5dc",
   "metadata": {},
   "source": [
    "Every object is once invented for the first time and that first time object is known as class\n",
    "\n",
    "Object must have:\n",
    " Characteristics (color, size, memory,ram, battery, )\n",
    " Actions (What action can we perform through the object)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "40d369f0",
   "metadata": {},
   "source": [
    "Object:\n",
    "    - Real World Object\n",
    "    i.e pen \n",
    "    book \n",
    "    table \n",
    "    keyboard \n",
    "    screen\n",
    "    cellphone (object) - belongs to its own class\n",
    "    man\n",
    "    chairs\n",
    "    banner\n",
    "    car (object) - belongs to its own class\n",
    "    \n",
    "Class:\n",
    "\n",
    "Every object have its own unique class\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f95c622f",
   "metadata": {},
   "source": [
    "Car  :\n",
    "     #Characteristic\n",
    "     Make\n",
    "     Model\n",
    "     Registration\n",
    "     Color \n",
    "     Engine\n",
    "     AC\n",
    "     Power Steering\n",
    "     #Actions\n",
    "     Run\n",
    "     Stop\n",
    "     Open Door\n",
    "     Close Door"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f328930c",
   "metadata": {},
   "source": [
    "Dog:\n",
    "    #Char\n",
    "    Name\n",
    "    breed\n",
    "    age\n",
    "    weight\n",
    "    size\n",
    "    color\n",
    "    #actions\n",
    "    Bark\n",
    "    bite\n",
    "    walk\n",
    "    run\n",
    "    eat"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "65126b59",
   "metadata": {},
   "source": [
    "boy:\n",
    "    Name \n",
    "    Age\n",
    "    Height\n",
    "    Weight\n",
    "    Bloodgroup\n",
    "    Qualification\n",
    "    Address\n",
    "    #Actions\n",
    "    Eat\n",
    "    Walk\n",
    "    Sleep\n",
    "    Run\n",
    "    Read\n",
    "    Write\n",
    "    Speak\n",
    "    Laugh"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "d536c11f",
   "metadata": {},
   "outputs": [],
   "source": [
    "class car():\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "4ffd6098",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Model car\n",
    "# Blueprint / Map\n",
    "class car():\n",
    "    \n",
    "    #Characteristics/properties ==> in programming they are called Attributes\n",
    "    #Characteristics are always variables\n",
    "    \n",
    "    make = \"CIVIC\"\n",
    "    reg = \"2022\"\n",
    "    col = \"white\"\n",
    "    model = \"2019\"\n",
    "    Engine = \"1300cc\"\n",
    "    \n",
    "    #Object can only have class attribute \n",
    "    #Object must have class attributes\n",
    "    \n",
    "    #Actions ==> in programming they are called behaviors\n",
    "    #Behaviors are represented by functions\n",
    "    #If functions are inside class they are called methods\n",
    "    \n",
    "    def run(): \n",
    "        print(\"Car is running\") \n",
    "    def stop():\n",
    "        print(\"Car stops\")\n",
    "    def doorOpen():\n",
    "        print(\"Door open\")\n",
    "    def doorClose():\n",
    "        print(\"Door closed\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dcb3b062",
   "metadata": {},
   "outputs": [],
   "source": [
    "def add(val1, val2): # parameters\n",
    "    \n",
    "    num1 = val1\n",
    "    num2 = val2\n",
    "    sum = num1 + num2\n",
    "    \n",
    "add(2,3) #arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "5dfb79b6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Model \n",
    "class Human():\n",
    "    def __init__(self,name, gender, age, blood_group):\n",
    "        \"\"\"\n",
    "        This function init is called initializer. (Constructor)\n",
    "        Values required in initialzer are mandatory to supply\n",
    "        to create an object\n",
    "        \"\"\"\n",
    "        #### Attributes of Humans ####\n",
    "        self.name        = name\n",
    "        self.gender      = gender\n",
    "        self.age         = age\n",
    "        self.blood_group = blood_group\n",
    "        \n",
    "        \"\"\"\n",
    "        This can also be name as given below\n",
    "        self.human_name        = name\n",
    "        self.human_gender      = gender\n",
    "        self.human_age         = age\n",
    "        self.human_blood_group = blood_group\n",
    "        \"\"\"\n",
    "    # must be inside class body not inside init function   \n",
    "    def eat(self):\n",
    "        print(f\" {self.name} is eating\")\n",
    "    def sleep(self):\n",
    "        print(f\"{self.name} is sleeping\")\n",
    "    def read(self):\n",
    "        print(f\"{self.name} is reading\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "d2cebd19",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating an object\n",
    "human1 = Human(\"Nasir\", \"Male\", 30, \"B+\")\n",
    "# object/instance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "2557a509",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating another object\n",
    "human2 = Human(\"Osama\", \"Male\", 23, \"B+\")\n",
    "# object/instance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "8ebb7e9a",
   "metadata": {},
   "outputs": [],
   "source": [
    "human3 = Human(\"Sam\", \"Male\", 23, \"B+\")\n",
    "# object/instance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "8cc843c8",
   "metadata": {},
   "outputs": [],
   "source": [
    "human4 = Human(\"Shiza\", \"Female\", 18, \"A+\")\n",
    "# object/instance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "aeb083e5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Nasir'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "human1.name\n",
    "# object is accessing its property"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "a7f36b56",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Male'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "human1.gender\n",
    "# object is accessing its property\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "30b18aa9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "human1.age\n",
    "# object is accessing its property"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "bbb3295d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'B+'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "human1.blood_group\n",
    "# object is accessing its property"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "1c2a2379",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Nasir is eating\n"
     ]
    }
   ],
   "source": [
    "human1.eat()\n",
    "# object is accessing its behavior"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "9b79eae0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nasir is sleeping\n"
     ]
    }
   ],
   "source": [
    "human1.sleep()\n",
    "# object is accessing its behavior"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "0f805420",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nasir is reading\n"
     ]
    }
   ],
   "source": [
    "human1.read()\n",
    "# object is accessing its behavior"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "2a65cda9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Osama is sleeping\n"
     ]
    }
   ],
   "source": [
    "human2.sleep()\n",
    "# object is accessing its behavior"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "2e6321ca",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class int in module builtins:\n",
      "\n",
      "class int(object)\n",
      " |  int([x]) -> integer\n",
      " |  int(x, base=10) -> integer\n",
      " |  \n",
      " |  Convert a number or string to an integer, or return 0 if no arguments\n",
      " |  are given.  If x is a number, return x.__int__().  For floating point\n",
      " |  numbers, this truncates towards zero.\n",
      " |  \n",
      " |  If x is not a number or if base is given, then x must be a string,\n",
      " |  bytes, or bytearray instance representing an integer literal in the\n",
      " |  given base.  The literal can be preceded by '+' or '-' and be surrounded\n",
      " |  by whitespace.  The base defaults to 10.  Valid bases are 0 and 2-36.\n",
      " |  Base 0 means to interpret the base from the string as an integer literal.\n",
      " |  >>> int('0b100', base=0)\n",
      " |  4\n",
      " |  \n",
      " |  Built-in subclasses:\n",
      " |      bool\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __abs__(self, /)\n",
      " |      abs(self)\n",
      " |  \n",
      " |  __add__(self, value, /)\n",
      " |      Return self+value.\n",
      " |  \n",
      " |  __and__(self, value, /)\n",
      " |      Return self&value.\n",
      " |  \n",
      " |  __bool__(self, /)\n",
      " |      self != 0\n",
      " |  \n",
      " |  __ceil__(...)\n",
      " |      Ceiling of an Integral returns itself.\n",
      " |  \n",
      " |  __divmod__(self, value, /)\n",
      " |      Return divmod(self, value).\n",
      " |  \n",
      " |  __eq__(self, value, /)\n",
      " |      Return self==value.\n",
      " |  \n",
      " |  __float__(self, /)\n",
      " |      float(self)\n",
      " |  \n",
      " |  __floor__(...)\n",
      " |      Flooring an Integral returns itself.\n",
      " |  \n",
      " |  __floordiv__(self, value, /)\n",
      " |      Return self//value.\n",
      " |  \n",
      " |  __format__(self, format_spec, /)\n",
      " |      Default object formatter.\n",
      " |  \n",
      " |  __ge__(self, value, /)\n",
      " |      Return self>=value.\n",
      " |  \n",
      " |  __getattribute__(self, name, /)\n",
      " |      Return getattr(self, name).\n",
      " |  \n",
      " |  __getnewargs__(self, /)\n",
      " |  \n",
      " |  __gt__(self, value, /)\n",
      " |      Return self>value.\n",
      " |  \n",
      " |  __hash__(self, /)\n",
      " |      Return hash(self).\n",
      " |  \n",
      " |  __index__(self, /)\n",
      " |      Return self converted to an integer, if self is suitable for use as an index into a list.\n",
      " |  \n",
      " |  __int__(self, /)\n",
      " |      int(self)\n",
      " |  \n",
      " |  __invert__(self, /)\n",
      " |      ~self\n",
      " |  \n",
      " |  __le__(self, value, /)\n",
      " |      Return self<=value.\n",
      " |  \n",
      " |  __lshift__(self, value, /)\n",
      " |      Return self<<value.\n",
      " |  \n",
      " |  __lt__(self, value, /)\n",
      " |      Return self<value.\n",
      " |  \n",
      " |  __mod__(self, value, /)\n",
      " |      Return self%value.\n",
      " |  \n",
      " |  __mul__(self, value, /)\n",
      " |      Return self*value.\n",
      " |  \n",
      " |  __ne__(self, value, /)\n",
      " |      Return self!=value.\n",
      " |  \n",
      " |  __neg__(self, /)\n",
      " |      -self\n",
      " |  \n",
      " |  __or__(self, value, /)\n",
      " |      Return self|value.\n",
      " |  \n",
      " |  __pos__(self, /)\n",
      " |      +self\n",
      " |  \n",
      " |  __pow__(self, value, mod=None, /)\n",
      " |      Return pow(self, value, mod).\n",
      " |  \n",
      " |  __radd__(self, value, /)\n",
      " |      Return value+self.\n",
      " |  \n",
      " |  __rand__(self, value, /)\n",
      " |      Return value&self.\n",
      " |  \n",
      " |  __rdivmod__(self, value, /)\n",
      " |      Return divmod(value, self).\n",
      " |  \n",
      " |  __repr__(self, /)\n",
      " |      Return repr(self).\n",
      " |  \n",
      " |  __rfloordiv__(self, value, /)\n",
      " |      Return value//self.\n",
      " |  \n",
      " |  __rlshift__(self, value, /)\n",
      " |      Return value<<self.\n",
      " |  \n",
      " |  __rmod__(self, value, /)\n",
      " |      Return value%self.\n",
      " |  \n",
      " |  __rmul__(self, value, /)\n",
      " |      Return value*self.\n",
      " |  \n",
      " |  __ror__(self, value, /)\n",
      " |      Return value|self.\n",
      " |  \n",
      " |  __round__(...)\n",
      " |      Rounding an Integral returns itself.\n",
      " |      Rounding with an ndigits argument also returns an integer.\n",
      " |  \n",
      " |  __rpow__(self, value, mod=None, /)\n",
      " |      Return pow(value, self, mod).\n",
      " |  \n",
      " |  __rrshift__(self, value, /)\n",
      " |      Return value>>self.\n",
      " |  \n",
      " |  __rshift__(self, value, /)\n",
      " |      Return self>>value.\n",
      " |  \n",
      " |  __rsub__(self, value, /)\n",
      " |      Return value-self.\n",
      " |  \n",
      " |  __rtruediv__(self, value, /)\n",
      " |      Return value/self.\n",
      " |  \n",
      " |  __rxor__(self, value, /)\n",
      " |      Return value^self.\n",
      " |  \n",
      " |  __sizeof__(self, /)\n",
      " |      Returns size in memory, in bytes.\n",
      " |  \n",
      " |  __sub__(self, value, /)\n",
      " |      Return self-value.\n",
      " |  \n",
      " |  __truediv__(self, value, /)\n",
      " |      Return self/value.\n",
      " |  \n",
      " |  __trunc__(...)\n",
      " |      Truncating an Integral returns itself.\n",
      " |  \n",
      " |  __xor__(self, value, /)\n",
      " |      Return self^value.\n",
      " |  \n",
      " |  as_integer_ratio(self, /)\n",
      " |      Return integer ratio.\n",
      " |      \n",
      " |      Return a pair of integers, whose ratio is exactly equal to the original int\n",
      " |      and with a positive denominator.\n",
      " |      \n",
      " |      >>> (10).as_integer_ratio()\n",
      " |      (10, 1)\n",
      " |      >>> (-10).as_integer_ratio()\n",
      " |      (-10, 1)\n",
      " |      >>> (0).as_integer_ratio()\n",
      " |      (0, 1)\n",
      " |  \n",
      " |  bit_length(self, /)\n",
      " |      Number of bits necessary to represent self in binary.\n",
      " |      \n",
      " |      >>> bin(37)\n",
      " |      '0b100101'\n",
      " |      >>> (37).bit_length()\n",
      " |      6\n",
      " |  \n",
      " |  conjugate(...)\n",
      " |      Returns self, the complex conjugate of any int.\n",
      " |  \n",
      " |  to_bytes(self, /, length, byteorder, *, signed=False)\n",
      " |      Return an array of bytes representing an integer.\n",
      " |      \n",
      " |      length\n",
      " |        Length of bytes object to use.  An OverflowError is raised if the\n",
      " |        integer is not representable with the given number of bytes.\n",
      " |      byteorder\n",
      " |        The byte order used to represent the integer.  If byteorder is 'big',\n",
      " |        the most significant byte is at the beginning of the byte array.  If\n",
      " |        byteorder is 'little', the most significant byte is at the end of the\n",
      " |        byte array.  To request the native byte order of the host system, use\n",
      " |        `sys.byteorder' as the byte order value.\n",
      " |      signed\n",
      " |        Determines whether two's complement is used to represent the integer.\n",
      " |        If signed is False and a negative integer is given, an OverflowError\n",
      " |        is raised.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Class methods defined here:\n",
      " |  \n",
      " |  from_bytes(bytes, byteorder, *, signed=False) from builtins.type\n",
      " |      Return the integer represented by the given array of bytes.\n",
      " |      \n",
      " |      bytes\n",
      " |        Holds the array of bytes to convert.  The argument must either\n",
      " |        support the buffer protocol or be an iterable object producing bytes.\n",
      " |        Bytes and bytearray are examples of built-in objects that support the\n",
      " |        buffer protocol.\n",
      " |      byteorder\n",
      " |        The byte order used to represent the integer.  If byteorder is 'big',\n",
      " |        the most significant byte is at the beginning of the byte array.  If\n",
      " |        byteorder is 'little', the most significant byte is at the end of the\n",
      " |        byte array.  To request the native byte order of the host system, use\n",
      " |        `sys.byteorder' as the byte order value.\n",
      " |      signed\n",
      " |        Indicates whether two's complement is used to represent the integer.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods defined here:\n",
      " |  \n",
      " |  __new__(*args, **kwargs) from builtins.type\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors defined here:\n",
      " |  \n",
      " |  denominator\n",
      " |      the denominator of a rational number in lowest terms\n",
      " |  \n",
      " |  imag\n",
      " |      the imaginary part of a complex number\n",
      " |  \n",
      " |  numerator\n",
      " |      the numerator of a rational number in lowest terms\n",
      " |  \n",
      " |  real\n",
      " |      the real part of a complex number\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "bdd0f1c7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class str in module builtins:\n",
      "\n",
      "class str(object)\n",
      " |  str(object='') -> str\n",
      " |  str(bytes_or_buffer[, encoding[, errors]]) -> str\n",
      " |  \n",
      " |  Create a new string object from the given object. If encoding or\n",
      " |  errors is specified, then the object must expose a data buffer\n",
      " |  that will be decoded using the given encoding and error handler.\n",
      " |  Otherwise, returns the result of object.__str__() (if defined)\n",
      " |  or repr(object).\n",
      " |  encoding defaults to sys.getdefaultencoding().\n",
      " |  errors defaults to 'strict'.\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __add__(self, value, /)\n",
      " |      Return self+value.\n",
      " |  \n",
      " |  __contains__(self, key, /)\n",
      " |      Return key in self.\n",
      " |  \n",
      " |  __eq__(self, value, /)\n",
      " |      Return self==value.\n",
      " |  \n",
      " |  __format__(self, format_spec, /)\n",
      " |      Return a formatted version of the string as described by format_spec.\n",
      " |  \n",
      " |  __ge__(self, value, /)\n",
      " |      Return self>=value.\n",
      " |  \n",
      " |  __getattribute__(self, name, /)\n",
      " |      Return getattr(self, name).\n",
      " |  \n",
      " |  __getitem__(self, key, /)\n",
      " |      Return self[key].\n",
      " |  \n",
      " |  __getnewargs__(...)\n",
      " |  \n",
      " |  __gt__(self, value, /)\n",
      " |      Return self>value.\n",
      " |  \n",
      " |  __hash__(self, /)\n",
      " |      Return hash(self).\n",
      " |  \n",
      " |  __iter__(self, /)\n",
      " |      Implement iter(self).\n",
      " |  \n",
      " |  __le__(self, value, /)\n",
      " |      Return self<=value.\n",
      " |  \n",
      " |  __len__(self, /)\n",
      " |      Return len(self).\n",
      " |  \n",
      " |  __lt__(self, value, /)\n",
      " |      Return self<value.\n",
      " |  \n",
      " |  __mod__(self, value, /)\n",
      " |      Return self%value.\n",
      " |  \n",
      " |  __mul__(self, value, /)\n",
      " |      Return self*value.\n",
      " |  \n",
      " |  __ne__(self, value, /)\n",
      " |      Return self!=value.\n",
      " |  \n",
      " |  __repr__(self, /)\n",
      " |      Return repr(self).\n",
      " |  \n",
      " |  __rmod__(self, value, /)\n",
      " |      Return value%self.\n",
      " |  \n",
      " |  __rmul__(self, value, /)\n",
      " |      Return value*self.\n",
      " |  \n",
      " |  __sizeof__(self, /)\n",
      " |      Return the size of the string in memory, in bytes.\n",
      " |  \n",
      " |  __str__(self, /)\n",
      " |      Return str(self).\n",
      " |  \n",
      " |  capitalize(self, /)\n",
      " |      Return a capitalized version of the string.\n",
      " |      \n",
      " |      More specifically, make the first character have upper case and the rest lower\n",
      " |      case.\n",
      " |  \n",
      " |  casefold(self, /)\n",
      " |      Return a version of the string suitable for caseless comparisons.\n",
      " |  \n",
      " |  center(self, width, fillchar=' ', /)\n",
      " |      Return a centered string of length width.\n",
      " |      \n",
      " |      Padding is done using the specified fill character (default is a space).\n",
      " |  \n",
      " |  count(...)\n",
      " |      S.count(sub[, start[, end]]) -> int\n",
      " |      \n",
      " |      Return the number of non-overlapping occurrences of substring sub in\n",
      " |      string S[start:end].  Optional arguments start and end are\n",
      " |      interpreted as in slice notation.\n",
      " |  \n",
      " |  encode(self, /, encoding='utf-8', errors='strict')\n",
      " |      Encode the string using the codec registered for encoding.\n",
      " |      \n",
      " |      encoding\n",
      " |        The encoding in which to encode the string.\n",
      " |      errors\n",
      " |        The error handling scheme to use for encoding errors.\n",
      " |        The default is 'strict' meaning that encoding errors raise a\n",
      " |        UnicodeEncodeError.  Other possible values are 'ignore', 'replace' and\n",
      " |        'xmlcharrefreplace' as well as any other name registered with\n",
      " |        codecs.register_error that can handle UnicodeEncodeErrors.\n",
      " |  \n",
      " |  endswith(...)\n",
      " |      S.endswith(suffix[, start[, end]]) -> bool\n",
      " |      \n",
      " |      Return True if S ends with the specified suffix, False otherwise.\n",
      " |      With optional start, test S beginning at that position.\n",
      " |      With optional end, stop comparing S at that position.\n",
      " |      suffix can also be a tuple of strings to try.\n",
      " |  \n",
      " |  expandtabs(self, /, tabsize=8)\n",
      " |      Return a copy where all tab characters are expanded using spaces.\n",
      " |      \n",
      " |      If tabsize is not given, a tab size of 8 characters is assumed.\n",
      " |  \n",
      " |  find(...)\n",
      " |      S.find(sub[, start[, end]]) -> int\n",
      " |      \n",
      " |      Return the lowest index in S where substring sub is found,\n",
      " |      such that sub is contained within S[start:end].  Optional\n",
      " |      arguments start and end are interpreted as in slice notation.\n",
      " |      \n",
      " |      Return -1 on failure.\n",
      " |  \n",
      " |  format(...)\n",
      " |      S.format(*args, **kwargs) -> str\n",
      " |      \n",
      " |      Return a formatted version of S, using substitutions from args and kwargs.\n",
      " |      The substitutions are identified by braces ('{' and '}').\n",
      " |  \n",
      " |  format_map(...)\n",
      " |      S.format_map(mapping) -> str\n",
      " |      \n",
      " |      Return a formatted version of S, using substitutions from mapping.\n",
      " |      The substitutions are identified by braces ('{' and '}').\n",
      " |  \n",
      " |  index(...)\n",
      " |      S.index(sub[, start[, end]]) -> int\n",
      " |      \n",
      " |      Return the lowest index in S where substring sub is found,\n",
      " |      such that sub is contained within S[start:end].  Optional\n",
      " |      arguments start and end are interpreted as in slice notation.\n",
      " |      \n",
      " |      Raises ValueError when the substring is not found.\n",
      " |  \n",
      " |  isalnum(self, /)\n",
      " |      Return True if the string is an alpha-numeric string, False otherwise.\n",
      " |      \n",
      " |      A string is alpha-numeric if all characters in the string are alpha-numeric and\n",
      " |      there is at least one character in the string.\n",
      " |  \n",
      " |  isalpha(self, /)\n",
      " |      Return True if the string is an alphabetic string, False otherwise.\n",
      " |      \n",
      " |      A string is alphabetic if all characters in the string are alphabetic and there\n",
      " |      is at least one character in the string.\n",
      " |  \n",
      " |  isascii(self, /)\n",
      " |      Return True if all characters in the string are ASCII, False otherwise.\n",
      " |      \n",
      " |      ASCII characters have code points in the range U+0000-U+007F.\n",
      " |      Empty string is ASCII too.\n",
      " |  \n",
      " |  isdecimal(self, /)\n",
      " |      Return True if the string is a decimal string, False otherwise.\n",
      " |      \n",
      " |      A string is a decimal string if all characters in the string are decimal and\n",
      " |      there is at least one character in the string.\n",
      " |  \n",
      " |  isdigit(self, /)\n",
      " |      Return True if the string is a digit string, False otherwise.\n",
      " |      \n",
      " |      A string is a digit string if all characters in the string are digits and there\n",
      " |      is at least one character in the string.\n",
      " |  \n",
      " |  isidentifier(self, /)\n",
      " |      Return True if the string is a valid Python identifier, False otherwise.\n",
      " |      \n",
      " |      Call keyword.iskeyword(s) to test whether string s is a reserved identifier,\n",
      " |      such as \"def\" or \"class\".\n",
      " |  \n",
      " |  islower(self, /)\n",
      " |      Return True if the string is a lowercase string, False otherwise.\n",
      " |      \n",
      " |      A string is lowercase if all cased characters in the string are lowercase and\n",
      " |      there is at least one cased character in the string.\n",
      " |  \n",
      " |  isnumeric(self, /)\n",
      " |      Return True if the string is a numeric string, False otherwise.\n",
      " |      \n",
      " |      A string is numeric if all characters in the string are numeric and there is at\n",
      " |      least one character in the string.\n",
      " |  \n",
      " |  isprintable(self, /)\n",
      " |      Return True if the string is printable, False otherwise.\n",
      " |      \n",
      " |      A string is printable if all of its characters are considered printable in\n",
      " |      repr() or if it is empty.\n",
      " |  \n",
      " |  isspace(self, /)\n",
      " |      Return True if the string is a whitespace string, False otherwise.\n",
      " |      \n",
      " |      A string is whitespace if all characters in the string are whitespace and there\n",
      " |      is at least one character in the string.\n",
      " |  \n",
      " |  istitle(self, /)\n",
      " |      Return True if the string is a title-cased string, False otherwise.\n",
      " |      \n",
      " |      In a title-cased string, upper- and title-case characters may only\n",
      " |      follow uncased characters and lowercase characters only cased ones.\n",
      " |  \n",
      " |  isupper(self, /)\n",
      " |      Return True if the string is an uppercase string, False otherwise.\n",
      " |      \n",
      " |      A string is uppercase if all cased characters in the string are uppercase and\n",
      " |      there is at least one cased character in the string.\n",
      " |  \n",
      " |  join(self, iterable, /)\n",
      " |      Concatenate any number of strings.\n",
      " |      \n",
      " |      The string whose method is called is inserted in between each given string.\n",
      " |      The result is returned as a new string.\n",
      " |      \n",
      " |      Example: '.'.join(['ab', 'pq', 'rs']) -> 'ab.pq.rs'\n",
      " |  \n",
      " |  ljust(self, width, fillchar=' ', /)\n",
      " |      Return a left-justified string of length width.\n",
      " |      \n",
      " |      Padding is done using the specified fill character (default is a space).\n",
      " |  \n",
      " |  lower(self, /)\n",
      " |      Return a copy of the string converted to lowercase.\n",
      " |  \n",
      " |  lstrip(self, chars=None, /)\n",
      " |      Return a copy of the string with leading whitespace removed.\n",
      " |      \n",
      " |      If chars is given and not None, remove characters in chars instead.\n",
      " |  \n",
      " |  partition(self, sep, /)\n",
      " |      Partition the string into three parts using the given separator.\n",
      " |      \n",
      " |      This will search for the separator in the string.  If the separator is found,\n",
      " |      returns a 3-tuple containing the part before the separator, the separator\n",
      " |      itself, and the part after it.\n",
      " |      \n",
      " |      If the separator is not found, returns a 3-tuple containing the original string\n",
      " |      and two empty strings.\n",
      " |  \n",
      " |  replace(self, old, new, count=-1, /)\n",
      " |      Return a copy with all occurrences of substring old replaced by new.\n",
      " |      \n",
      " |        count\n",
      " |          Maximum number of occurrences to replace.\n",
      " |          -1 (the default value) means replace all occurrences.\n",
      " |      \n",
      " |      If the optional argument count is given, only the first count occurrences are\n",
      " |      replaced.\n",
      " |  \n",
      " |  rfind(...)\n",
      " |      S.rfind(sub[, start[, end]]) -> int\n",
      " |      \n",
      " |      Return the highest index in S where substring sub is found,\n",
      " |      such that sub is contained within S[start:end].  Optional\n",
      " |      arguments start and end are interpreted as in slice notation.\n",
      " |      \n",
      " |      Return -1 on failure.\n",
      " |  \n",
      " |  rindex(...)\n",
      " |      S.rindex(sub[, start[, end]]) -> int\n",
      " |      \n",
      " |      Return the highest index in S where substring sub is found,\n",
      " |      such that sub is contained within S[start:end].  Optional\n",
      " |      arguments start and end are interpreted as in slice notation.\n",
      " |      \n",
      " |      Raises ValueError when the substring is not found.\n",
      " |  \n",
      " |  rjust(self, width, fillchar=' ', /)\n",
      " |      Return a right-justified string of length width.\n",
      " |      \n",
      " |      Padding is done using the specified fill character (default is a space).\n",
      " |  \n",
      " |  rpartition(self, sep, /)\n",
      " |      Partition the string into three parts using the given separator.\n",
      " |      \n",
      " |      This will search for the separator in the string, starting at the end. If\n",
      " |      the separator is found, returns a 3-tuple containing the part before the\n",
      " |      separator, the separator itself, and the part after it.\n",
      " |      \n",
      " |      If the separator is not found, returns a 3-tuple containing two empty strings\n",
      " |      and the original string.\n",
      " |  \n",
      " |  rsplit(self, /, sep=None, maxsplit=-1)\n",
      " |      Return a list of the words in the string, using sep as the delimiter string.\n",
      " |      \n",
      " |        sep\n",
      " |          The delimiter according which to split the string.\n",
      " |          None (the default value) means split according to any whitespace,\n",
      " |          and discard empty strings from the result.\n",
      " |        maxsplit\n",
      " |          Maximum number of splits to do.\n",
      " |          -1 (the default value) means no limit.\n",
      " |      \n",
      " |      Splits are done starting at the end of the string and working to the front.\n",
      " |  \n",
      " |  rstrip(self, chars=None, /)\n",
      " |      Return a copy of the string with trailing whitespace removed.\n",
      " |      \n",
      " |      If chars is given and not None, remove characters in chars instead.\n",
      " |  \n",
      " |  split(self, /, sep=None, maxsplit=-1)\n",
      " |      Return a list of the words in the string, using sep as the delimiter string.\n",
      " |      \n",
      " |      sep\n",
      " |        The delimiter according which to split the string.\n",
      " |        None (the default value) means split according to any whitespace,\n",
      " |        and discard empty strings from the result.\n",
      " |      maxsplit\n",
      " |        Maximum number of splits to do.\n",
      " |        -1 (the default value) means no limit.\n",
      " |  \n",
      " |  splitlines(self, /, keepends=False)\n",
      " |      Return a list of the lines in the string, breaking at line boundaries.\n",
      " |      \n",
      " |      Line breaks are not included in the resulting list unless keepends is given and\n",
      " |      true.\n",
      " |  \n",
      " |  startswith(...)\n",
      " |      S.startswith(prefix[, start[, end]]) -> bool\n",
      " |      \n",
      " |      Return True if S starts with the specified prefix, False otherwise.\n",
      " |      With optional start, test S beginning at that position.\n",
      " |      With optional end, stop comparing S at that position.\n",
      " |      prefix can also be a tuple of strings to try.\n",
      " |  \n",
      " |  strip(self, chars=None, /)\n",
      " |      Return a copy of the string with leading and trailing whitespace removed.\n",
      " |      \n",
      " |      If chars is given and not None, remove characters in chars instead.\n",
      " |  \n",
      " |  swapcase(self, /)\n",
      " |      Convert uppercase characters to lowercase and lowercase characters to uppercase.\n",
      " |  \n",
      " |  title(self, /)\n",
      " |      Return a version of the string where each word is titlecased.\n",
      " |      \n",
      " |      More specifically, words start with uppercased characters and all remaining\n",
      " |      cased characters have lower case.\n",
      " |  \n",
      " |  translate(self, table, /)\n",
      " |      Replace each character in the string using the given translation table.\n",
      " |      \n",
      " |        table\n",
      " |          Translation table, which must be a mapping of Unicode ordinals to\n",
      " |          Unicode ordinals, strings, or None.\n",
      " |      \n",
      " |      The table must implement lookup/indexing via __getitem__, for instance a\n",
      " |      dictionary or list.  If this operation raises LookupError, the character is\n",
      " |      left untouched.  Characters mapped to None are deleted.\n",
      " |  \n",
      " |  upper(self, /)\n",
      " |      Return a copy of the string converted to uppercase.\n",
      " |  \n",
      " |  zfill(self, width, /)\n",
      " |      Pad a numeric string with zeros on the left, to fill a field of the given width.\n",
      " |      \n",
      " |      The string is never truncated.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods defined here:\n",
      " |  \n",
      " |  __new__(*args, **kwargs) from builtins.type\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      " |  \n",
      " |  maketrans(...)\n",
      " |      Return a translation table usable for str.translate().\n",
      " |      \n",
      " |      If there is only one argument, it must be a dictionary mapping Unicode\n",
      " |      ordinals (integers) or characters to Unicode ordinals, strings or None.\n",
      " |      Character keys will be then converted to ordinals.\n",
      " |      If there are two arguments, they must be strings of equal length, and\n",
      " |      in the resulting dictionary, each character in x will be mapped to the\n",
      " |      character at the same position in y. If there is a third argument, it\n",
      " |      must be a string, whose characters will be mapped to None in the result.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "fe058677",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dog():\n",
    "    def __init__(self    , breed, name = \"Dog\", age = \"N/A\"):\n",
    "            #  obj name  -------\n",
    "        \n",
    "        # attribute\n",
    "        self.name = name\n",
    "        self.age  = age\n",
    "        self.breed= breed\n",
    "        \n",
    "        \n",
    "    # action / behavior \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 a Dog Roll over response to a command\"\"\"\n",
    "        print(self.name.title() + \" rolled over\")\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "4a09dba9",
   "metadata": {},
   "outputs": [],
   "source": [
    "dog1 = Dog(\"german\",\"Tonny\", 2)\n",
    "# Creating an object\n",
    "# To access an object inside or outside the class we must used self with it\n",
    "# Whenever an object is created it automatically calls the clss initializer\n",
    "# if we aren't making initializer in the class the object will be created "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "e1460244",
   "metadata": {},
   "outputs": [],
   "source": [
    "# An objects inherits everything that a class have because an object is an instance of a class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "22e0512a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dog1.age"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "0e5ca29a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Tonny'"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dog1.name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "5ed1916e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'german'"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dog1.breed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "2d254aa1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tonny rolled over\n"
     ]
    }
   ],
   "source": [
    "dog1.roll_over()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "cbb8c0d2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tonny is now sitting\n"
     ]
    }
   ],
   "source": [
    "dog1.sit()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "0b455b2a",
   "metadata": {},
   "outputs": [],
   "source": [
    "dog2 = Dog(\"American\") # using default variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "1b982431",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'N/A'"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dog2.age"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "10e956b4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Dog'"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dog2.name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "35aef325",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'American'"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dog2.breed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "03f45683",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dog rolled over\n"
     ]
    }
   ],
   "source": [
    "dog2.roll_over()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "d47616df",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dog is now sitting\n"
     ]
    }
   ],
   "source": [
    "dog2.sit()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "bd30b7e4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# object name is referenced to self"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "a530339b",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dog():\n",
    "    def __init__(self,name,age, breed):\n",
    "            #  obj name  -------\n",
    "        \n",
    "        # attribute\n",
    "        self.name = name\n",
    "        self.age  = age\n",
    "        self.breed= breed\n",
    "        \n",
    "        \n",
    "    # action / behavior \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 a Dog Roll over response to a command\"\"\"\n",
    "        print(self.name.title() + \" rolled over\")\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "f6b29e03",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "__init__() takes 4 positional arguments but 5 were given",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-82-57b10638f574>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mdog3\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mDog\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"german\"\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;34m\"Dog\"\u001b[0m\u001b[1;33m,\u001b[0m  \u001b[1;36m2\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m\"jecky\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      2\u001b[0m \u001b[1;31m# one argument (object name is hidden) and is sent automatically by python\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mTypeError\u001b[0m: __init__() takes 4 positional arguments but 5 were given"
     ]
    }
   ],
   "source": [
    "dog3 = Dog(\"german\",\"Dog\",  2, \"jecky\")\n",
    "# one argument (object name is hidden) and is sent automatically by python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "ee847cc0",
   "metadata": {},
   "outputs": [],
   "source": [
    "dog3 = Dog( \"jecky\",  2,\"german\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "da8b2aa0",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "sit() missing 1 required positional argument: 'self'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-86-318c6dc9e3ee>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mDog\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msit\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[0m",
      "\u001b[1;31mTypeError\u001b[0m: sit() missing 1 required positional argument: 'self'"
     ]
    }
   ],
   "source": [
    "Dog.sit()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "422cc636",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Jecky is now sitting\n"
     ]
    }
   ],
   "source": [
    "Dog.sit(dog3)\n",
    "# if we call a method or property we will supply object name/reference explicitly(byself ==>khud say)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "id": "7c1e166e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Jecky is now sitting\n"
     ]
    }
   ],
   "source": [
    "dog3.sit()\n",
    "# if we call a method or property object name/refernce goes itself with the call"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "c3af6386",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Self is a reference of object that sent automatically"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "id": "395362e9",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Patient():\n",
    "    def __init__(self, name, gender, disease, contact_number):\n",
    "        self.name           = name\n",
    "        self.gender         = gender\n",
    "        self.disease        = disease\n",
    "        self.contact_number = contact_number\n",
    "    def medicine(self):\n",
    "        print(f\"{self.name} is taking medicine\")\n",
    "    def patient_details(self):\n",
    "        print(f\"\"\"\n",
    "        Name    : {self.name} \n",
    "        Gender  : {self.gender}\n",
    "        Disease : {self.disease}\n",
    "        Contact : {self.contact_number}\n",
    "        \"\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "id": "bc36c9a3",
   "metadata": {},
   "outputs": [],
   "source": [
    "patient1 = Patient(\"Tom\", \"Male\", \"BP\", 4567890)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "id": "d53211f2",
   "metadata": {},
   "outputs": [],
   "source": [
    "patient2 = Patient(\"Jonny\", \"Male\", \"Headache\", 1234567)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "id": "6ee29c3a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "        Name    : Tom \n",
      "        Gender  : Male\n",
      "        Disease : BP\n",
      "        Contact : 4567890\n",
      "        \n"
     ]
    }
   ],
   "source": [
    "Patient.patient_details(patient1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "id": "7628579e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tom is taking medicine\n"
     ]
    }
   ],
   "source": [
    "Patient.medicine(patient1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "id": "907fc45f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Jonny is taking medicine\n"
     ]
    }
   ],
   "source": [
    "patient2.medicine()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "id": "d8755132",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "        Name    : Jonny \n",
      "        Gender  : Male\n",
      "        Disease : Headache\n",
      "        Contact : 1234567\n",
      "        \n"
     ]
    }
   ],
   "source": [
    "patient2.patient_details()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26a67959",
   "metadata": {},
   "source": [
    "## Updating Attribute Value Directly"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "id": "77fe1e95",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'BP'"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "patient1.disease"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "id": "45c27adb",
   "metadata": {},
   "outputs": [],
   "source": [
    "patient1.disease = \"Low BP\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "id": "8a27a56a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Low BP'"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "patient1.disease"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "id": "270bf7fd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "        Name    : Tom \n",
      "        Gender  : Male\n",
      "        Disease : Low BP\n",
      "        Contact : 4567890\n",
      "        \n"
     ]
    }
   ],
   "source": [
    "patient1.patient_details()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "id": "74101fcb",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Updating/Changing variable attribute directly is not a good approach "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "id": "57a18a82",
   "metadata": {},
   "outputs": [],
   "source": [
    "# GETTERs & SETTERs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "id": "0076c309",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Patient():\n",
    "    def __init__(self, name, gender, disease, contact_number):\n",
    "        self.pat_name           = name\n",
    "        self.pat_gender         = gender\n",
    "        self.pat_disease        = disease\n",
    "        self.pat_contact_number = contact_number\n",
    "        \n",
    "    def medicine(self):\n",
    "        print(f\"{self.name} is taking medicine\")\n",
    "    \n",
    "    def patient_details(self):\n",
    "        print(f\"\"\"\n",
    "        Name    : {self.name} \n",
    "        Gender  : {self.gender}\n",
    "        Disease : {self.disease}\n",
    "        Contact : {self.contact_number}\n",
    "        \"\"\")\n",
    "        \n",
    "    # Getter\n",
    "    def get_name(self):\n",
    "        return self.pat_name\n",
    "    \n",
    "    # Setter\n",
    "    def set_name(self, newName):\n",
    "        self.pat_name = newName \n",
    "    \n",
    "    def get_gender(self):\n",
    "        return self.pat_gender\n",
    "    \n",
    "    def set_gender(self, newGender):\n",
    "        self.pat_gender = newGender"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "id": "09275c04",
   "metadata": {},
   "outputs": [],
   "source": [
    "patient1 = Patient(\"Mr.T\", \"Male\", \"BP\", 4567890)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "id": "3806efed",
   "metadata": {},
   "outputs": [],
   "source": [
    "patient2 = Patient(\"Mr.Z\", \"Male\", \"BP\", 4567890)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "id": "13bc1666",
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'Patient' object has no attribute 'name'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-150-6b6810398a31>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mpatient1\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mname\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m: 'Patient' object has no attribute 'name'"
     ]
    }
   ],
   "source": [
    "patient1.name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "id": "624977d3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Mr.T'"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "patient1.get_name()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "id": "3777d4a1",
   "metadata": {},
   "outputs": [],
   "source": [
    "patient1.set_name(\"Me.J\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "id": "0b51a091",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Me.J'"
      ]
     },
     "execution_count": 153,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "patient1.get_name()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "384f11b9",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "185fc22c",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "Command Mode (press Esc to enable)\n",
    "F\n",
    ": find and replace\n",
    "Ctrl-Shift-F\n",
    ": open the command palette\n",
    "Ctrl-Shift-P\n",
    ": open the command palette\n",
    "Enter\n",
    ": enter edit mode\n",
    "P\n",
    ": open the command palette\n",
    "Shift-Enter\n",
    ": run cell, select below\n",
    "Ctrl-Enter\n",
    ": run selected cells\n",
    "Alt-Enter\n",
    ": run cell and insert below\n",
    "Y\n",
    ": change cell to code\n",
    "M\n",
    ": change cell to markdown\n",
    "R\n",
    ": change cell to raw\n",
    "1\n",
    ": change cell to heading 1\n",
    "2\n",
    ": change cell to heading 2\n",
    "3\n",
    ": change cell to heading 3\n",
    "4\n",
    ": change cell to heading 4\n",
    "5\n",
    ": change cell to heading 5\n",
    "6\n",
    ": change cell to heading 6\n",
    "K\n",
    ": select cell above\n",
    "Up\n",
    ": select cell above\n",
    "Down\n",
    ": select cell below\n",
    "J\n",
    ": select cell below\n",
    "Shift-K\n",
    ": extend selected cells above\n",
    "Shift-Up\n",
    ": extend selected cells above\n",
    "Shift-Down\n",
    ": extend selected cells below\n",
    "Shift-J\n",
    ": extend selected cells below\n",
    "Ctrl-A\n",
    ": select all cells\n",
    "A\n",
    ": insert cell above\n",
    "B\n",
    ": insert cell below\n",
    "X\n",
    ": cut selected cells\n",
    "C\n",
    ": copy selected cells\n",
    "Shift-V\n",
    ": paste cells above\n",
    "V\n",
    ": paste cells below\n",
    "Z\n",
    ": undo cell deletion\n",
    "D,D\n",
    ": delete selected cells\n",
    "Shift-M\n",
    ": merge selected cells, or current cell with cell below if only one cell is selected\n",
    "Ctrl-S\n",
    ": Save and Checkpoint\n",
    "S\n",
    ": Save and Checkpoint\n",
    "L\n",
    ": toggle line numbers\n",
    "O\n",
    ": toggle output of selected cells\n",
    "Shift-O\n",
    ": toggle output scrolling of selected cells\n",
    "H\n",
    ": show keyboard shortcuts\n",
    "I,I\n",
    ": interrupt the kernel\n",
    "0,0\n",
    ": restart the kernel (with dialog)\n",
    "Esc\n",
    ": close the pager\n",
    "Q\n",
    ": close the pager\n",
    "Shift-L\n",
    ": toggles line numbers in all cells, and persist the setting\n",
    "Shift-Space\n",
    ": scroll notebook up\n",
    "Space\n",
    ": scroll notebook down\n",
    "Edit Mode (press Enter to enable)\n",
    "Tab\n",
    ": code completion or indent\n",
    "Shift-Tab\n",
    ": tooltip\n",
    "Ctrl-]\n",
    ": indent\n",
    "Ctrl-[\n",
    ": dedent\n",
    "Ctrl-A\n",
    ": select all\n",
    "Ctrl-Z\n",
    ": undo\n",
    "Ctrl-/\n",
    ": comment\n",
    "Ctrl-D\n",
    ": delete whole line\n",
    "Ctrl-U\n",
    ": undo selection\n",
    "Insert\n",
    ": toggle overwrite flag\n",
    "Ctrl-Home\n",
    ": go to cell start\n",
    "Ctrl-Up\n",
    ": go to cell start\n",
    "Ctrl-End\n",
    ": go to cell end\n",
    "Ctrl-Down\n",
    ": go to cell end\n",
    "Ctrl-Left\n",
    ": go one word left\n",
    "Ctrl-Right\n",
    ": go one word right\n",
    "Ctrl-Backspace\n",
    ": delete word before\n",
    "Ctrl-Delete\n",
    ": delete word after\n",
    "Ctrl-Y\n",
    ": redo\n",
    "Alt-U\n",
    ": redo selection\n",
    "Ctrl-M\n",
    ": enter command mode\n",
    "Ctrl-Shift-F\n",
    ": open the command palette\n",
    "Ctrl-Shift-P\n",
    ": open the command palette\n",
    "Esc\n",
    ": enter command mode\n",
    "Shift-Enter\n",
    ": run cell, select below\n",
    "Ctrl-Enter\n",
    ": run selected cells\n",
    "Alt-Enter\n",
    ": run cell and insert below\n",
    "Ctrl-Shift-Minus\n",
    ": split cell at cursor(s)\n",
    "Ctrl-S\n",
    ": Save and Checkpoint\n",
    "Down\n",
    ": move cursor down\n",
    "Up\n",
    ": move cursor up\n",
    "\"\"\""
   ]
  }
 ],
 "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}