Python Language/02–OOP.ipynb

{
 "nbformat": 4,
 "nbformat_minor": 0,
 "metadata": {
  "colab": {
   "provenance": [],
   "authorship_tag": "ABX9TyPC80toiv5VP9BlfiTHpd0u"
  },
  "kernelspec": {
   "name": "python3",
   "display_name": "Python 3 (ipykernel)",
   "language": "python"
  },
  "language_info": {
   "name": "python"
  }
 },
 "cells": [
  {
   "cell_type": "markdown",
   "source": [
    "## Functions\n",
    "\n",
    "Before moving forward, it would be useful to revise functions. In Maths, a function takes an input – say $x$ – and returns an output – say $y$.\n",
    "\n",
    "$$y = f(x)$$\n",
    "\n",
    "We can also have **multivariate functions**, like:\n",
    "\n",
    "$$b = f(x,y,z)$$\n",
    "\n",
    "For example, first equation of motion takes 3 variables:\n",
    "\n",
    "$$v_f = v_i +at$$\n",
    "\n",
    "On the other hand, Newton's 2nd law takes 2 variables:\n",
    "\n",
    "$$F = ma$$\n",
    "\n",
    "---\n",
    "\n",
    "Functions in programming are similar to the mathematical functions which take an (or some) input(s) and return an output.\n",
    "\n",
    "A function is defined as:\n",
    "\n",
    "```\n",
    "def Func(<input variables>):\n",
    "  <Function Body>\n",
    "  return <output variable>\n",
    "```\n",
    "\n",
    "Let's see some examples.\n",
    "\n",
    "> **Note:** Contrary to mathematical functions, a programming function can even have no output.\n"
   ],
   "metadata": {
    "id": "oz8kN1J4eMxa"
   }
  },
  {
   "cell_type": "code",
   "source": [
    "import math\n",
    "\n",
    "def Circumference(radius):\n",
    "  C = 2*math.pi*radius\n",
    "  return C"
   ],
   "metadata": {
    "id": "Bzxlr-fagKhR",
    "ExecuteTime": {
     "end_time": "2024-10-22T12:13:36.132022Z",
     "start_time": "2024-10-22T12:13:36.127502Z"
    }
   },
   "outputs": [],
   "execution_count": 1
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Calling Functions\n",
    "\n",
    "So far, we have just defined it. That's similar to a function already defined in the **`math`** library we have already seen in the previous notebook.\n",
    "\n",
    "In order to use a function, we just have to call it with the given input variable and it will work. We can also evaluate a function by directly inputting the numeric value there."
   ],
   "metadata": {
    "id": "8zNZBNyxgmZG"
   }
  },
  {
   "cell_type": "code",
   "source": [
    "y = Circumference(3)\n",
    "print(\"Circumference of circle having radius 3 is: \",y)"
   ],
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "umoC2kFxhEEQ",
    "outputId": "805464d4-7f30-4612-9b27-4517f3ba3218",
    "ExecuteTime": {
     "end_time": "2024-10-22T12:13:37.795977Z",
     "start_time": "2024-10-22T12:13:37.793260Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Circumference of circle having radius 3 is:  18.84955592153876\n"
     ]
    }
   ],
   "execution_count": 2
  },
  {
   "cell_type": "markdown",
   "source": [
    "Let's try some other examples. Umm.. for example, projectile motion.\n",
    "\n",
    "A projectile's motion is defined in a quite sleek way using a set of equations:\n",
    "\n",
    "$$T = \\frac{2 v_0 \\sin\\theta}{g}$$\n",
    "\n",
    "$$H = \\frac{{v_0}^2 \\sin^2 \\theta}{2g}$$\n",
    "\n",
    "$$R = \\frac{{v_0}^2 \\sin 2\\theta}{g}$$\n",
    "\n",
    "Lets define (and use) them in Python:"
   ],
   "metadata": {
    "id": "r7l0qxw0iqsp"
   }
  },
  {
   "cell_type": "code",
   "source": [
    "def Projectile_Time(v0,𝜃):\n",
    "  t = 2*v0*math.sin(𝜃*math.pi/180)/9.8\n",
    "  return t"
   ],
   "metadata": {
    "id": "CcBPs-uGivNt",
    "ExecuteTime": {
     "end_time": "2024-10-22T12:13:39.485905Z",
     "start_time": "2024-10-22T12:13:39.483872Z"
    }
   },
   "outputs": [],
   "execution_count": 3
  },
  {
   "cell_type": "markdown",
   "source": [
    "As you would have seen, Python is much closer to Mathematics than other languages. We can **even define our variables using the Greek alphabets**. Let's test it for some values of different angles and initial velocity."
   ],
   "metadata": {
    "id": "_DOHH-7Lk8TU"
   }
  },
  {
   "cell_type": "code",
   "source": [
    "print(\"Time taken by projectile for 30m/s at 45º is:\", Projectile_Time(30,45))\n",
    "print(\"Time taken by projectile for 30m/s at 60º is:\", Projectile_Time(30,60))\n",
    "print(\"Time taken by projectile for 30m/s at 30º is:\", Projectile_Time(30,30))"
   ],
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "h__8uLK8lMQ8",
    "outputId": "25d75f4c-5e1a-48d9-b695-1e9eca53a568",
    "ExecuteTime": {
     "end_time": "2024-10-22T12:13:41.294822Z",
     "start_time": "2024-10-22T12:13:41.292202Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time taken by projectile for 30m/s at 45º is: 4.329225190938045\n",
      "Time taken by projectile for 30m/s at 60º is: 5.302196349700644\n",
      "Time taken by projectile for 30m/s at 30º is: 3.0612244897959178\n"
     ]
    }
   ],
   "execution_count": 4
  },
  {
   "cell_type": "markdown",
   "source": [
    "As we can see, the higher the angle, the longer it stays in the air. Similarly, the other two."
   ],
   "metadata": {
    "id": "li9tVM6ul3PN"
   }
  },
  {
   "cell_type": "code",
   "source": [
    "def Projectile_Height(v0,𝜃):\n",
    "  h = (v0**2)*(math.sin(𝜃*math.pi/180))**2/2*9.8\n",
    "  return h\n",
    "\n",
    "def Projectile_Range(v0,𝜃):\n",
    "  r = (v0**2)*(math.sin(2*𝜃*math.pi/180))/9.8\n",
    "  return r"
   ],
   "metadata": {
    "id": "_ORVz5jbnETB",
    "ExecuteTime": {
     "end_time": "2024-10-22T12:13:42.988460Z",
     "start_time": "2024-10-22T12:13:42.986267Z"
    }
   },
   "outputs": [],
   "execution_count": 5
  },
  {
   "cell_type": "code",
   "source": [
    "print(\"Range of a projectile for 30m/s at 45º is:\", Projectile_Range(30,45))\n",
    "print(\"Range of a projectile for 30m/s at 60º is:\", Projectile_Range(30,60))\n",
    "print(\"Range of a projectile for 30m/s at 30º is:\", Projectile_Range(30,30))"
   ],
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "eksokmG8nsTX",
    "outputId": "b97663ab-94a0-4a4e-ee1a-de7546572f61",
    "ExecuteTime": {
     "end_time": "2024-10-22T12:13:44.540567Z",
     "start_time": "2024-10-22T12:13:44.538091Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Range of a projectile for 30m/s at 45º is: 91.83673469387755\n",
      "Range of a projectile for 30m/s at 60º is: 79.53294524550967\n",
      "Range of a projectile for 30m/s at 30º is: 79.53294524550965\n"
     ]
    }
   ],
   "execution_count": 6
  },
  {
   "cell_type": "markdown",
   "source": [
    "Inevitably, the max range is at 45º and starts decreasing either side of it.\n",
    "\n",
    "Now, we can see that all the projectiles have these common attributes:\n",
    "\n",
    "- $v_0$\n",
    "- $\\theta$\n",
    "and $H$, $R$ and $T$ too.\n",
    "\n",
    "Similarly, the constant **`g`** is common across the functions as well. To simplify them, we can combine them together in a class."
   ],
   "metadata": {
    "id": "UvdfsMQJoBOs"
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "---\n",
    "\n",
    "# Object-Oriented Programming\n",
    "\n",
    "OOP deals with classes and objects and improves the code reusability. A class has attributes (variables) and functionalities."
   ],
   "metadata": {
    "id": "AJMBbsGxdGs2"
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Classes\n",
    "\n",
    "A class can be defined using the **`class`** keyword as:\n",
    "\n",
    "```\n",
    "class <Class name>:\n",
    "  <Class Members>\n",
    "```\n",
    "\n",
    "Class members can be attributes, functions (and some other things, as we will see later on).\n",
    "\n",
    "As a starter, we can simply define a Projectile class as:"
   ],
   "metadata": {
    "id": "p3BhvJC8dZ_o"
   }
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "4_lCA9f1Rn9i",
    "ExecuteTime": {
     "end_time": "2024-10-22T12:13:47.300684Z",
     "start_time": "2024-10-22T12:13:47.299016Z"
    }
   },
   "source": [
    "class Projectile:\n",
    "  None"
   ],
   "outputs": [],
   "execution_count": 7
  },
  {
   "cell_type": "markdown",
   "source": [
    "**`None`** is a handy keyword here specifying there is nothing here. We can add some attributes too."
   ],
   "metadata": {
    "id": "Gkpb7zD0yUV2"
   }
  },
  {
   "cell_type": "code",
   "source": [
    "class Projectile:\n",
    "    def __init__(self, initial_speed, angle):\n",
    "        self.v0=initial_speed,\n",
    "        self.𝜃=angle"
   ],
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 309
    },
    "id": "Y24JiEJkyeP6",
    "outputId": "b0858baf-dafc-4ffa-a82d-61400b880b73",
    "ExecuteTime": {
     "end_time": "2024-10-22T12:13:48.519160Z",
     "start_time": "2024-10-22T12:13:48.516844Z"
    }
   },
   "outputs": [],
   "execution_count": 8
  },
  {
   "cell_type": "markdown",
   "source": [
    "Here, **`__init__()`** is a function which is known as constructor (more on that in a min).\n",
    "If you are coming from traditional languages like C++,Java or C#, you are more likely to find it weird as attributes are defined on the class-level there, while Python requires attributes to be defined **within the constructor**. "
   ],
   "metadata": {
    "id": "oRYYUavhymtb"
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "> \"*The reasonable man adapts himself to the world; the unreasonable one persists in trying to adapt the world to himself. **Therefore all progress depends on the unreasonable man**.* \" – George Bernard Shaw, Man and Superman (1903)\n",
    "\n",
    "Weird doesn't always mean wrong. Python has its own way."
   ],
   "metadata": {
    "id": "I3Qs9Wruzkm4"
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Objects\n",
    "\n",
    "A class is just a concept. In order to use it, we require objects. An object can be instantiated simply as:\n",
    "\n",
    "**`a = <ClassName>()`**\n",
    "\n",
    "As we just talked about constructor. As its name depicts, this is the function which is called whenever we create an object (we don't need to explicitly specify its name)."
   ],
   "metadata": {
    "id": "XjkdX3up0dky"
   }
  },
  {
   "cell_type": "code",
   "source": "projectile1 = Projectile()",
   "metadata": {
    "id": "48EHdSr9zM-f",
    "ExecuteTime": {
     "end_time": "2024-10-22T12:13:55.579481Z",
     "start_time": "2024-10-22T12:13:55.386155Z"
    }
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "Projectile.__init__() missing 2 required positional arguments: 'initial_speed' and 'angle'",
     "output_type": "error",
     "traceback": [
      "\u001B[0;31m---------------------------------------------------------------------------\u001B[0m",
      "\u001B[0;31mTypeError\u001B[0m                                 Traceback (most recent call last)",
      "Cell \u001B[0;32mIn[9], line 1\u001B[0m\n\u001B[0;32m----> 1\u001B[0m projectile1 \u001B[38;5;241m=\u001B[39m Projectile()\n",
      "\u001B[0;31mTypeError\u001B[0m: Projectile.__init__() missing 2 required positional arguments: 'initial_speed' and 'angle'"
     ]
    }
   ],
   "execution_count": 9
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "As you can see, its throwing an error as its expecting us to provide the initial speed and angle. If we provide them, it will create the object without any qualms."
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-10-22T12:13:56.899997Z",
     "start_time": "2024-10-22T12:13:56.898395Z"
    }
   },
   "cell_type": "code",
   "source": "projectile1 = Projectile(110,31.76)",
   "outputs": [],
   "execution_count": 10
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Accessing Class Members\n",
    "\n",
    "We have made the projectile object to show the [world-record throw](https://www.youtube.com/watch?v=-Er8PXFCkLc&t=1686s). But how to access its specific members (speed or angle) individually? For that, we use **`.`** operator as:\n",
    "\n",
    "**`a = <objectname>.<membername>`**\n",
    "\n"
   ],
   "metadata": {
    "id": "BTWsFiP101ZL"
   }
  },
  {
   "cell_type": "code",
   "source": [
    "print(projectile1.v0)"
   ],
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "Om8pCFQS01zW",
    "outputId": "3b4e8c8a-9055-479e-e46c-06efc468c6d8",
    "ExecuteTime": {
     "end_time": "2024-10-22T12:13:58.653660Z",
     "start_time": "2024-10-22T12:13:58.651448Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(110,)\n"
     ]
    }
   ],
   "execution_count": 11
  },
  {
   "cell_type": "markdown",
   "source": [
    "We can also override the existing values later on. For example, we make an object and change its attributes values soon afterwards.\n",
    "\n",
    "**Point to ponder:** What does **,** after the 0 means in the above output?"
   ],
   "metadata": {
    "id": "EGxyvzKI1ppo"
   }
  },
  {
   "cell_type": "code",
   "source": [
    "projectile2 = Projectile(0,0)\n",
    "projectile2.v0 = 30\n",
    "projectile2.θ = 45\n",
    "\n",
    "print(\"Projectile 2's initial velocity is: \",projectile2.v0, \" and its angle is: \",projectile2.θ,\" \")"
   ],
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "Jn0UzWF-14Rn",
    "outputId": "f9a7d820-ac18-4625-946d-a562b65093cf",
    "ExecuteTime": {
     "end_time": "2024-10-22T12:14:00.300521Z",
     "start_time": "2024-10-22T12:14:00.298081Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Projectile 2's initial velocity is:  30  and its angle is:  45  \n"
     ]
    }
   ],
   "execution_count": 12
  },
  {
   "cell_type": "markdown",
   "source": [
    "Now **`v0`** and **`θ`** don't exist individually. Their existence is linked with existence of an object."
   ],
   "metadata": {
    "id": "Xgxi8pGP2TI1"
   }
  },
  {
   "cell_type": "code",
   "source": [
    "print(θ)\n",
    "print(v0)"
   ],
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 199
    },
    "id": "L9yGdX122e2p",
    "outputId": "86da4674-d188-47c5-9bfe-8564b44a0d5c",
    "ExecuteTime": {
     "end_time": "2024-10-22T12:14:02.042831Z",
     "start_time": "2024-10-22T12:14:02.034333Z"
    }
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'θ' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001B[0;31m---------------------------------------------------------------------------\u001B[0m",
      "\u001B[0;31mNameError\u001B[0m                                 Traceback (most recent call last)",
      "Cell \u001B[0;32mIn[13], line 1\u001B[0m\n\u001B[0;32m----> 1\u001B[0m \u001B[38;5;28mprint\u001B[39m(θ)\n\u001B[1;32m      2\u001B[0m \u001B[38;5;28mprint\u001B[39m(v0)\n",
      "\u001B[0;31mNameError\u001B[0m: name 'θ' is not defined"
     ]
    }
   ],
   "execution_count": 13
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "### Default Values\n",
    "As we saw above that we initialized a projectile object with 0 values and set the attributes later on. We can do it directly in the constructor too by specifying the default values."
   ]
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-10-22T12:14:03.431406Z",
     "start_time": "2024-10-22T12:14:03.427146Z"
    }
   },
   "cell_type": "code",
   "source": [
    "class Projectile:\n",
    "    def __init__(self, initial_speed=0, angle=0):\n",
    "        self.v0=initial_speed,\n",
    "        self.𝜃=angle\n",
    "        \n",
    "projectile1 = Projectile()\n",
    "projectile1.v0"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0,)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 14
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Methods\n",
    "\n",
    "So far, our class has a couple of attributes. But we are yet to add the respective functions as well. A class can have functions inside it and they are known as **Methods**.\n",
    "\n",
    "Coming back to the `Projectile` class, we can add methods as:"
   ],
   "metadata": {
    "id": "NTNJUg4l2qF4"
   }
  },
  {
   "cell_type": "code",
   "source": [
    "class Projectile:\n",
    "  def __init__(self, initial_speed=0, angle=0):\n",
    "        self.v0=initial_speed,\n",
    "        self.𝜃=angle\n",
    "\n",
    "  def Projectile_Time(v0,𝜃):\n",
    "    t = 2*v0*math.sin(𝜃*math.pi/180)/9.8\n",
    "    return t\n",
    "\n",
    "  def Projectile_Height(v0,𝜃):\n",
    "    h = (v0**2)*(math.sin(𝜃*math.pi/180))**2/2*9.8\n",
    "    return h\n",
    "\n",
    "  def Projectile_Range(v0,𝜃):\n",
    "    r = (v0**2)*(math.sin(2*𝜃*math.pi/180))/9.8\n",
    "    return r"
   ],
   "metadata": {
    "id": "EF4jMHbKT74i",
    "ExecuteTime": {
     "end_time": "2024-10-22T12:14:05.234082Z",
     "start_time": "2024-10-22T12:14:05.231008Z"
    }
   },
   "outputs": [],
   "execution_count": 15
  },
  {
   "cell_type": "markdown",
   "source": [
    "Now we can check it by making an object (or two)."
   ],
   "metadata": {
    "id": "KA603e7xUZJK"
   }
  },
  {
   "cell_type": "code",
   "source": [
    "projectile3 = Projectile()\n",
    "\n",
    "projectile3.v0 = 30\n",
    "projectile3.θ = 60\n",
    "\n",
    "r = projectile3.Projectile_Range(30,60)\n",
    "\n",
    "print(r)"
   ],
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 254
    },
    "id": "6kjstVovUgZE",
    "outputId": "a8f3fd2f-dae1-4e16-f9d8-6811f946d890",
    "ExecuteTime": {
     "end_time": "2024-10-22T12:14:09.295650Z",
     "start_time": "2024-10-22T12:14:09.287327Z"
    }
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "Projectile.Projectile_Range() takes 2 positional arguments but 3 were given",
     "output_type": "error",
     "traceback": [
      "\u001B[0;31m---------------------------------------------------------------------------\u001B[0m",
      "\u001B[0;31mTypeError\u001B[0m                                 Traceback (most recent call last)",
      "Cell \u001B[0;32mIn[16], line 6\u001B[0m\n\u001B[1;32m      3\u001B[0m projectile3\u001B[38;5;241m.\u001B[39mv0 \u001B[38;5;241m=\u001B[39m \u001B[38;5;241m30\u001B[39m\n\u001B[1;32m      4\u001B[0m projectile3\u001B[38;5;241m.\u001B[39mθ \u001B[38;5;241m=\u001B[39m \u001B[38;5;241m60\u001B[39m\n\u001B[0;32m----> 6\u001B[0m r \u001B[38;5;241m=\u001B[39m projectile3\u001B[38;5;241m.\u001B[39mProjectile_Range(\u001B[38;5;241m30\u001B[39m,\u001B[38;5;241m60\u001B[39m)\n\u001B[1;32m      8\u001B[0m \u001B[38;5;28mprint\u001B[39m(r)\n",
      "\u001B[0;31mTypeError\u001B[0m: Projectile.Projectile_Range() takes 2 positional arguments but 3 were given"
     ]
    }
   ],
   "execution_count": 16
  },
  {
   "cell_type": "markdown",
   "source": [
    "Wait a min! How come this method has three arguments/parameters when we have given only two?\n",
    "\n",
    "**Method parameters should come from the attributes themselves**\n",
    "\n",
    "Before going into the answer of the above question, we need to realize another thing. There's no point in having **`v0`** or **`𝜃`** as parameters anymore as we already have them as the class attributes.\n",
    "\n",
    "So instead we should take these attributes from the respective objects themselves.\n",
    "\n",
    "### Object Reference in the Class\n",
    "\n",
    "An object can be referred in a class by the keyword **`self`**. Let's update the methods accordingly."
   ],
   "metadata": {
    "id": "tJB_SRffVUdY"
   }
  },
  {
   "cell_type": "code",
   "source": [
    "class Projectile:\n",
    "  v0 = 0,\n",
    "  𝜃 = 0\n",
    "\n",
    "  def Projectile_Time():\n",
    "    t = 2*self.v0*math.sin(self.𝜃*math.pi/180)/9.8\n",
    "    return t\n",
    "\n",
    "  def Projectile_Height():\n",
    "    h = (self.v0**2)*(math.sin(self.𝜃*math.pi/180))**2/2*9.8\n",
    "    return h\n",
    "\n",
    "  def Projectile_Range():\n",
    "    r = (self.v0**2)*(math.sin(2*self.𝜃*math.pi/180))/9.8\n",
    "    return r"
   ],
   "metadata": {
    "id": "F6Ttfoh0W_VJ",
    "ExecuteTime": {
     "end_time": "2024-10-22T12:14:11.985466Z",
     "start_time": "2024-10-22T12:14:11.982995Z"
    }
   },
   "outputs": [],
   "execution_count": 17
  },
  {
   "cell_type": "markdown",
   "source": [
    "And lets try the above example again:"
   ],
   "metadata": {
    "id": "axCozI8ZXR70"
   }
  },
  {
   "cell_type": "code",
   "source": [
    "projectile3 = Projectile()\n",
    "\n",
    "projectile3.v0 = 30\n",
    "projectile3.θ = 60\n",
    "\n",
    "r = projectile3.Projectile_Range() #No point in inputting the parameters as they are already attributes of the projectile3 object.\n",
    "\n",
    "print(r)"
   ],
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 254
    },
    "id": "iBcU9CM9XUF6",
    "outputId": "4ebd7273-e34f-47d7-d562-7c12b8469b0c",
    "ExecuteTime": {
     "end_time": "2024-10-22T12:14:16.302130Z",
     "start_time": "2024-10-22T12:14:16.293823Z"
    }
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "Projectile.Projectile_Range() takes 0 positional arguments but 1 was given",
     "output_type": "error",
     "traceback": [
      "\u001B[0;31m---------------------------------------------------------------------------\u001B[0m",
      "\u001B[0;31mTypeError\u001B[0m                                 Traceback (most recent call last)",
      "Cell \u001B[0;32mIn[18], line 6\u001B[0m\n\u001B[1;32m      3\u001B[0m projectile3\u001B[38;5;241m.\u001B[39mv0 \u001B[38;5;241m=\u001B[39m \u001B[38;5;241m30\u001B[39m\n\u001B[1;32m      4\u001B[0m projectile3\u001B[38;5;241m.\u001B[39mθ \u001B[38;5;241m=\u001B[39m \u001B[38;5;241m60\u001B[39m\n\u001B[0;32m----> 6\u001B[0m r \u001B[38;5;241m=\u001B[39m projectile3\u001B[38;5;241m.\u001B[39mProjectile_Range() \u001B[38;5;66;03m#No point in inputting the parameters as they are already attributes of the projectile3 object.\u001B[39;00m\n\u001B[1;32m      8\u001B[0m \u001B[38;5;28mprint\u001B[39m(r)\n",
      "\u001B[0;31mTypeError\u001B[0m: Projectile.Projectile_Range() takes 0 positional arguments but 1 was given"
     ]
    }
   ],
   "execution_count": 18
  },
  {
   "cell_type": "markdown",
   "source": [
    "Apparently, the former error is having none of it. The *hidden* variable keeps coming (wearing some magic hat).\n",
    "\n",
    "**Whenever a method is called, `self` is automatically its first/hidden argument.**\n",
    "\n",
    "So Python has this interesting feature where `self` is implicitly the first argument (whenever an object calls a method).\n",
    "\n",
    ">*See also: [Relevant StackOverflow Post](https://stackoverflow.com/questions/23944657/typeerror-method-takes-1-positional-argument-but-2-were-given-but-i-only-pa)*\n",
    "\n",
    "And the easy solution is to add **`self`** as the first argument of the methods definitions as well. It would ensure that the implicity `self` would also be counted as an argument and everything would start making some sense (before its too late for some of you).\n",
    "\n",
    "Finally, we update the `Projectile` class as:"
   ],
   "metadata": {
    "id": "GvaAQOW_XlTL"
   }
  },
  {
   "cell_type": "code",
   "source": [
    "class Projectile:\n",
    "  v0 = 0,\n",
    "  𝜃 = 0\n",
    "\n",
    "  def Projectile_Time(self):\n",
    "    t = 2*self.v0*math.sin(self.𝜃*math.pi/180)/9.8\n",
    "    return t\n",
    "\n",
    "  def Projectile_Height(self):\n",
    "    h = (self.v0**2)*(math.sin(self.𝜃*math.pi/180))**2/2*9.8\n",
    "    return h\n",
    "\n",
    "  def Projectile_Range(self):\n",
    "    r = (self.v0**2)*(math.sin(2*self.𝜃*math.pi/180))/9.8\n",
    "    return r"
   ],
   "metadata": {
    "id": "NdI-Ji96ZCeJ",
    "ExecuteTime": {
     "end_time": "2024-10-22T12:14:30.091092Z",
     "start_time": "2024-10-22T12:14:30.088123Z"
    }
   },
   "outputs": [],
   "execution_count": 19
  },
  {
   "cell_type": "markdown",
   "source": [
    "Let's try to call the method again:"
   ],
   "metadata": {
    "id": "MaOyhZK_ZIKn"
   }
  },
  {
   "cell_type": "code",
   "source": [
    "projectile3 = Projectile()\n",
    "\n",
    "projectile3.v0 = 30\n",
    "projectile3.θ = 60\n",
    "\n",
    "r = projectile3.Projectile_Range() #No point in inputting the parameters as they are already attributes of the projectile3 object.\n",
    "\n",
    "print(r)"
   ],
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "p_McBT7PZMCi",
    "outputId": "07f62234-cdeb-4b5b-9cbf-4d634fee23d1",
    "ExecuteTime": {
     "end_time": "2024-10-22T12:14:51.417921Z",
     "start_time": "2024-10-22T12:14:51.415583Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "79.53294524550967\n"
     ]
    }
   ],
   "execution_count": 20
  },
  {
   "cell_type": "markdown",
   "source": [
    "Life is back to normal. Someone can hear the seagulls in the background.\n",
    "\n",
    "> **Note:** We can define the attributes on class-level, but they will be class attributes, not instance attributes.\n",
    "\n",
    "---"
   ],
   "metadata": {
    "id": "WGk3-IduZTmj"
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Inheritance\n",
    "\n",
    "Whenever two classes have some common attributes/functionalities, they can be inherited from a common/parent class. This phenomenon is known as **inheritance** and can be defined as an ***is-a*** relationship between the two classes. Like history book is a book, iPhone is a phone, student is a person, etc.\n",
    "\n",
    "Enough of talking, lets start it by making a base/parent class first:"
   ],
   "metadata": {
    "id": "-P8RCvBtZrlH"
   }
  },
  {
   "cell_type": "code",
   "source": [
    "class MobilePhone:\n",
    "    def __init__(self, make=\"\", model=\"\", batteryCapacity=5000, networkCapacity=\"3G\"):\n",
    "        self.make = make\n",
    "        self.model = model\n",
    "        self.batteryCapacity = batteryCapacity\n",
    "        self.networkCapacity = networkCapacity\n",
    "\n",
    "    def Call(self):\n",
    "      print(\"Dummy function to show that we are calling using the phone object\")\n",
    "\n",
    "    def ReceiveCall(self):\n",
    "      print(\"Dummy function to show that we are receiving the call using the phone object\")"
   ],
   "metadata": {
    "id": "YVfUB0SVc5HZ",
    "ExecuteTime": {
     "end_time": "2024-10-22T12:16:58.931509Z",
     "start_time": "2024-10-22T12:16:58.929323Z"
    }
   },
   "outputs": [],
   "execution_count": 21
  },
  {
   "cell_type": "markdown",
   "source": [
    "The purpose of dummy functions here is just to show an abstraction. How phones make or receive a call is a telecome engineer's job, we are just modelling it. If a class has some functionality, which we can understand and implement, we will definitely implement it (like ML models).\n",
    "\n",
    "Lets try to make a couple of phones (i.e, above class' objects):"
   ],
   "metadata": {
    "id": "QHXFcflndaoz"
   }
  },
  {
   "cell_type": "code",
   "source": [
    "phone1 = MobilePhone()\n",
    "phone1.make = \"Samsung\"\n",
    "phone1.model = \"S3\""
   ],
   "metadata": {
    "id": "Yn8GSMi9eGIb",
    "ExecuteTime": {
     "end_time": "2024-10-22T12:17:45.349606Z",
     "start_time": "2024-10-22T12:17:45.347837Z"
    }
   },
   "outputs": [],
   "execution_count": 22
  },
  {
   "cell_type": "markdown",
   "source": [
    "Since we had initialized battery and network capacity with the default values, we can override their values to ones for the given object:"
   ],
   "metadata": {
    "id": "ZrHAPxTSeQ6-"
   }
  },
  {
   "cell_type": "code",
   "source": [
    "phone1.batteryCapacity = 20000\n",
    "phone1.networkCapacity = \"5G\"\n",
    "\n",
    "print(\"Phone1 has \",phone1.networkCapacity,\" capacity.\")"
   ],
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "KWNej9FoeaXk",
    "outputId": "fde35c33-1c51-48a7-88b0-4f6fc2468ae3",
    "ExecuteTime": {
     "end_time": "2024-10-22T12:17:46.699895Z",
     "start_time": "2024-10-22T12:17:46.697870Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Phone1 has  5G  capacity.\n"
     ]
    }
   ],
   "execution_count": 23
  },
  {
   "cell_type": "markdown",
   "source": [
    "So we have defined a base class. We can use it to inherit any class. For inheritance, we use a ridiculously simple syntax of:\n",
    "\n",
    "**`class <child class>(<parent class>)`**\n",
    "\n",
    "For example, we make an **`iPhone`** class as:"
   ],
   "metadata": {
    "id": "fPlLi1-YesyC"
   }
  },
  {
   "cell_type": "code",
   "source": [
    "class iPhone(MobilePhone):\n",
    "  None"
   ],
   "metadata": {
    "id": "r9WZytplfAlA",
    "ExecuteTime": {
     "end_time": "2024-10-22T12:18:46.604898Z",
     "start_time": "2024-10-22T12:18:46.602802Z"
    }
   },
   "outputs": [],
   "execution_count": 24
  },
  {
   "cell_type": "markdown",
   "source": [
    "**Note:** Those coming from C++ or Java would find it new as those languages use **`:`** for the inheritance. But inevitably, we can't use it here (since `:` is used in Python for other purposes).\n",
    "\n",
    "Since `iPhone` has inherited from `MobilePhone`, so it has inherited all the class members as well. We can verify it:"
   ],
   "metadata": {
    "id": "zzVvbhwaffrB"
   }
  },
  {
   "cell_type": "code",
   "source": [
    "i1 = iPhone()\n",
    "\n",
    "print(i1.networkCapacity)"
   ],
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "t4oUMwvMgf2Y",
    "outputId": "493db656-8f3b-4285-8441-c981bb25b3d9",
    "ExecuteTime": {
     "end_time": "2024-10-22T12:18:48.554491Z",
     "start_time": "2024-10-22T12:18:48.552178Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3G\n"
     ]
    }
   ],
   "execution_count": 25
  },
  {
   "cell_type": "markdown",
   "source": [
    "Assuming that all the iPhones have 4G or more capacity, we can obviously update the **`iPhone`** class's definition to reflect that:"
   ],
   "metadata": {
    "id": "CxWE4GQ2gnZB"
   }
  },
  {
   "cell_type": "code",
   "source": [
    "class iPhone(MobilePhone):\n",
    "  networkCapacity = \"4G\""
   ],
   "metadata": {
    "id": "3A4LxfudgxTw",
    "ExecuteTime": {
     "end_time": "2024-10-22T12:18:56.105841Z",
     "start_time": "2024-10-22T12:18:56.103663Z"
    }
   },
   "outputs": [],
   "execution_count": 26
  },
  {
   "cell_type": "markdown",
   "source": [
    "Now it will show 4G for all the respective objects"
   ],
   "metadata": {
    "id": "BSAHouIsg2n2"
   }
  },
  {
   "cell_type": "code",
   "source": [
    "i1 = iPhone()\n",
    "\n",
    "print(i1.networkCapacity)"
   ],
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "txSjLIkeg5-a",
    "outputId": "ae2598a3-42cc-42ce-cd7f-53e5c63bbc75",
    "ExecuteTime": {
     "end_time": "2024-10-22T12:18:58.142948Z",
     "start_time": "2024-10-22T12:18:58.140665Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3G\n"
     ]
    }
   ],
   "execution_count": 27
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "I guess that's it for now. I didn't want it to conclude like a French movie, but here we go."
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": ""
  }
 ]
}