OOPS in Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# OOPS Introduction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python has been an object-oriented language since it existed. Because of this, creating and using classes and objects are downright easy."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Understanding OOPS will help you to understand how modules are used in data science. For example, understanding how a model and its functions are called in python scripts. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Understanding Class Paradigm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-23T07:09:55.198927Z",
     "start_time": "2020-02-23T07:09:55.186392Z"
    }
   },
   "source": [
    "Example of a Class in real life:\n",
    "\n",
    "- Class in real life is your: Mother\n",
    "- Initialization in real life is your: Birth Process\n",
    "- We can say you and your sister are instances of the class, in real life means: You and your sister are the children of your mother\n",
    "- Class Constructor in real life would be: What makes your genes\n",
    "- Class Methods in real life are: What your mother teach you to do, like [eat, clean your bed, take a bathe etc…]\n",
    "- Object in real life is: You\n",
    "- Another object in real life is: Your sister\n",
    "- Object Attributes in real life are: What differ you from others people, like [your name, eye color, skin, your fingerprint, your accent]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T20:01:44.808573Z",
     "start_time": "2020-02-25T20:01:44.802970Z"
    }
   },
   "outputs": [],
   "source": [
    "class Mother():\n",
    "    \n",
    "    # Class Constructor\n",
    "    def __init__(self, name, eye_color, skin):\n",
    "        self.name = name\n",
    "        self.eye_color = eye_color\n",
    "        self.skin = skin\n",
    "        \n",
    "    # Class Methods\n",
    "    def eat(self):\n",
    "        print(self.name, ': Mommy, Im Hungry')\n",
    "    \n",
    "    def clean_bed(self):\n",
    "        print('Mommy : ', self.name,  ', first clean your bed.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T20:01:45.162891Z",
     "start_time": "2020-02-25T20:01:45.158862Z"
    }
   },
   "outputs": [],
   "source": [
    "you = Mother('Aayush','Black','Wheatish')\n",
    "your_sister = Mother('Ankita', 'Brown', 'Wheatish')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T20:01:45.501974Z",
     "start_time": "2020-02-25T20:01:45.494993Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Aayush\n",
      "Black\n",
      "Wheatish\n"
     ]
    }
   ],
   "source": [
    "print(you.name)\n",
    "print(you.eye_color)\n",
    "print(you.skin)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T20:01:45.973081Z",
     "start_time": "2020-02-25T20:01:45.969093Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ankita\n",
      "Brown\n",
      "Wheatish\n"
     ]
    }
   ],
   "source": [
    "print(your_sister.name)\n",
    "print(your_sister.eye_color)\n",
    "print(your_sister.skin)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T20:01:46.672391Z",
     "start_time": "2020-02-25T20:01:46.668403Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Aayush : Mommy, Im Hungry\n"
     ]
    }
   ],
   "source": [
    "you.eat()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T20:01:47.028182Z",
     "start_time": "2020-02-25T20:01:47.023193Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mommy :  Aayush , first clean your bed.\n"
     ]
    }
   ],
   "source": [
    "you.clean_bed()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T20:01:47.259929Z",
     "start_time": "2020-02-25T20:01:47.256901Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ankita : Mommy, Im Hungry\n"
     ]
    }
   ],
   "source": [
    "your_sister.eat()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T20:01:50.144722Z",
     "start_time": "2020-02-25T20:01:50.140772Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mommy :  Ankita , first clean your bed.\n"
     ]
    }
   ],
   "source": [
    "your_sister.clean_bed()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Class"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A user-defined prototype for an object that defines a set of attributes that characterize any object of the class. The attributes are data members (class variables and instance variables) and methods, accessed via dot notation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T20:01:54.205891Z",
     "start_time": "2020-02-25T20:01:54.201903Z"
    }
   },
   "outputs": [],
   "source": [
    "## Declaration of class\n",
    "\n",
    "class ClassName:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Member"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A class variable or instance variable that holds data associated with a class and its objects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T20:01:58.495524Z",
     "start_time": "2020-02-25T20:01:58.493054Z"
    }
   },
   "outputs": [],
   "source": [
    "## todo add all the other documentations\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Definining a Class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T20:02:00.407407Z",
     "start_time": "2020-02-25T20:02:00.403419Z"
    }
   },
   "outputs": [],
   "source": [
    "class sample():\n",
    "    value = 0\n",
    "    \n",
    "    def get_val(self):\n",
    "        self.value = input(\"Enter a value: \")\n",
    "    \n",
    "    def disp(self):\n",
    "        print(self.value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T20:02:10.325401Z",
     "start_time": "2020-02-25T20:02:10.321413Z"
    }
   },
   "outputs": [],
   "source": [
    "# Creating a object of class sample. Which inturn allocates memory\n",
    "s = sample()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T20:02:11.191967Z",
     "start_time": "2020-02-25T20:02:10.920485Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a value: \n"
     ]
    }
   ],
   "source": [
    "# Calling a function in \n",
    "s.get_val()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T20:02:13.641083Z",
     "start_time": "2020-02-25T20:02:13.637094Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "s.disp()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Constructors in Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T20:02:21.099070Z",
     "start_time": "2020-02-25T20:02:21.094085Z"
    }
   },
   "outputs": [],
   "source": [
    "class sample():\n",
    "    def __init__(self,value):\n",
    "        self.value = value\n",
    "    def disp(self):\n",
    "        print(self.value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T20:02:21.586457Z",
     "start_time": "2020-02-25T20:02:21.535782Z"
    }
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "__init__() missing 1 required positional argument: 'value'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-16-13d86c35fd54>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0ms\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0msample\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: __init__() missing 1 required positional argument: 'value'"
     ]
    }
   ],
   "source": [
    "s = sample()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T20:02:25.977676Z",
     "start_time": "2020-02-25T20:02:25.974651Z"
    }
   },
   "outputs": [],
   "source": [
    "s = sample(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T20:02:26.437474Z",
     "start_time": "2020-02-25T20:02:26.433533Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "s.disp()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T20:02:28.459023Z",
     "start_time": "2020-02-25T20:02:28.455028Z"
    }
   },
   "outputs": [],
   "source": [
    "class Employee:\n",
    "    'Common base class for all employees'\n",
    "    empCount = 0\n",
    "    def __init__(self, name, salary):\n",
    "        self.name = name\n",
    "        self.salary = salary\n",
    "        Employee.empCount += 1\n",
    "    \n",
    "    def displayCount(self):\n",
    "        print (\"Total Employee %d\" % Employee.empCount)\n",
    "        \n",
    "    def displayEmployee(self):\n",
    "        print (\"Name : \", self.name,  \", Salary: \", self.salary)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T20:02:28.711166Z",
     "start_time": "2020-02-25T20:02:28.702663Z"
    }
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "__init__() missing 2 required positional arguments: 'name' and 'salary'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-20-1b9bbc958439>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0memp\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mEmployee\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: __init__() missing 2 required positional arguments: 'name' and 'salary'"
     ]
    }
   ],
   "source": [
    "emp = Employee()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T20:02:28.894838Z",
     "start_time": "2020-02-25T20:02:28.890891Z"
    }
   },
   "outputs": [],
   "source": [
    "# Instantiating an object\n",
    "\n",
    "emp = Employee(\"Sid\",200)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T20:02:30.665157Z",
     "start_time": "2020-02-25T20:02:30.661131Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total Employee 1\n"
     ]
    }
   ],
   "source": [
    "emp.displayCount()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T20:02:32.050607Z",
     "start_time": "2020-02-25T20:02:32.046617Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name :  Sid , Salary:  200\n"
     ]
    }
   ],
   "source": [
    "emp.displayEmployee()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All members in a Python class are public by default. Any member can be accessed from outside the class environment.You can even access the variables as shown in the example below"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T20:02:35.512767Z",
     "start_time": "2020-02-25T20:02:35.500292Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "200"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "emp.salary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T20:02:35.996172Z",
     "start_time": "2020-02-25T20:02:35.991147Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Sid'"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "emp.name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T19:46:11.772484Z",
     "start_time": "2020-02-25T19:46:11.769452Z"
    }
   },
   "outputs": [],
   "source": [
    "# How oops is used in Data science"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets try to understand from the following illustration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calling the RandomForestReggresson which is present in sklearn \n",
    "\n",
    "from sklearn.ensemble import RandomForestRegressor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T19:45:52.291076Z",
     "start_time": "2020-02-25T19:45:52.226234Z"
    }
   },
   "outputs": [],
   "source": [
    "RFE = RandomForestRegressor() # Creating an object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "RFE."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Now once the object of RFE is created you can call the available functions of RFE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Question"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a Circle class and intialize it with radius. Make two methods getArea and getCircumference inside this class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "# Method 1 \n",
    "\n",
    "class Circle:\n",
    "    radius = 0 \n",
    "    \n",
    "    def __init__(self):\n",
    "        self.radius = int(input(\"Enter the radius: \"))\n",
    "    \n",
    "    def getArea(self):\n",
    "        print(3.14*self.radius**2)\n",
    "    \n",
    "    def getCircumference(self):\n",
    "        print(2*3.14*self.radius)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "# Method 2 Which is an example of independant functions \n",
    "\n",
    "class Circle:\n",
    "        \n",
    "    def getArea(self,radius):\n",
    "        print(3.14*radius**2)\n",
    "    \n",
    "    def getCircumference(self,radius):\n",
    "        print(2*3.14*radius)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cc = Circle()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cc.getArea()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cc.getCircumference()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# OOPS - Example with DF"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating Dataframe in Pandas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T20:05:02.879997Z",
     "start_time": "2020-02-25T20:05:02.395831Z"
    }
   },
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T20:05:10.955376Z",
     "start_time": "2020-02-25T20:05:10.949420Z"
    }
   },
   "outputs": [],
   "source": [
    "car_name = pd.Series(['Maruti','Honda','Hyundai'])\n",
    "speed = pd.Series([120,170,130])\n",
    "weight = pd.Series([750, 1200, 950])\n",
    "gears = pd.Series([5,6,6])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T20:05:20.086531Z",
     "start_time": "2020-02-25T20:05:20.081984Z"
    }
   },
   "outputs": [],
   "source": [
    "df = pd.DataFrame({'car_name': car_name,\n",
    "                  'speed':speed,\n",
    "                  'weight':weight,\n",
    "                  'gears':gears})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T20:06:00.782266Z",
     "start_time": "2020-02-25T20:06:00.763277Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>car_name</th>\n",
       "      <th>speed</th>\n",
       "      <th>weight</th>\n",
       "      <th>gears</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Maruti</td>\n",
       "      <td>120</td>\n",
       "      <td>750</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Honda</td>\n",
       "      <td>170</td>\n",
       "      <td>1200</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Hyundai</td>\n",
       "      <td>130</td>\n",
       "      <td>950</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  car_name  speed  weight  gears\n",
       "0   Maruti    120     750      5\n",
       "1    Honda    170    1200      6\n",
       "2  Hyundai    130     950      6"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating a Class - Cars"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T20:22:43.363297Z",
     "start_time": "2020-02-25T20:22:43.357739Z"
    }
   },
   "outputs": [],
   "source": [
    "class Cars():\n",
    "        \n",
    "    # Class Constructor\n",
    "    def __init__(self, car_name, max_speed, weight, number_of_gear):\n",
    "        \n",
    "        self.car_name = car_name\n",
    "        self.max_speed = max_speed\n",
    "        self.weight = weight\n",
    "        self.number_of_gear = number_of_gear\n",
    "        \n",
    "    # Class Methods\n",
    "    def speed_weight_ratio(self):\n",
    "        print(\"My Car\", self.car_name, 'has speed_weight_ratio of', round(self.weight/self.max_speed,2))\n",
    "        return round(self.weight/self.max_speed,2)\n",
    "        \n",
    "    def average_speed_per_gear(self):\n",
    "        print(\"My Car\", self.car_name, 'has average speed per gear of', round(self.max_speed/self.number_of_gear,2))\n",
    "        return round(self.max_speed/self.number_of_gear,2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Passing Class Parameters as Tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T20:22:44.255014Z",
     "start_time": "2020-02-25T20:22:44.251026Z"
    }
   },
   "outputs": [],
   "source": [
    "para = tuple(df.loc[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T20:22:44.498442Z",
     "start_time": "2020-02-25T20:22:44.495633Z"
    }
   },
   "outputs": [],
   "source": [
    "object_1 = Cars(*para)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T20:22:44.746698Z",
     "start_time": "2020-02-25T20:22:44.741713Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My Car Maruti has speed_weight_ratio of 6.25\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "6.25"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "object_1.speed_weight_ratio()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T20:22:44.958874Z",
     "start_time": "2020-02-25T20:22:44.954375Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My Car Maruti has average speed per gear of 24.0\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "24.0"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "object_1.average_speed_per_gear()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iterating it on full dataframe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T20:22:57.765166Z",
     "start_time": "2020-02-25T20:22:57.761137Z"
    }
   },
   "outputs": [],
   "source": [
    "para_list = []\n",
    "for i in range(len(df)):\n",
    "    para_list.append(tuple(df.loc[i]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T20:22:57.970315Z",
     "start_time": "2020-02-25T20:22:57.966332Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('Maruti', 120, 750, 5), ('Honda', 170, 1200, 6), ('Hyundai', 130, 950, 6)]"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "para_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T20:22:58.135899Z",
     "start_time": "2020-02-25T20:22:58.131906Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My Car Maruti has speed_weight_ratio of 6.25\n",
      "My Car Honda has speed_weight_ratio of 7.06\n",
      "My Car Hyundai has speed_weight_ratio of 7.31\n"
     ]
    }
   ],
   "source": [
    "car_speed_weight_ratio = []\n",
    "\n",
    "for i in para_list:\n",
    "    obj = Cars(*i)\n",
    "    tup = (obj.car_name, obj.speed_weight_ratio())\n",
    "    car_speed_weight_ratio.append(tup)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T20:22:58.403255Z",
     "start_time": "2020-02-25T20:22:58.399225Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('Maruti', 6.25), ('Honda', 7.06), ('Hyundai', 7.31)]"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "car_speed_weight_ratio"
   ]
  }
 ],
 "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.6.8"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "279.273px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}