3-FunctionAndClass.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions and Classes\n",
    "\n",
    "Function and Class are required for object oriented programming. Functions, once created, can be implemented multiple times while Class is more useful for both data encaptulation and functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import random as random"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Class Circle"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Define a function which will take radious as input and provides area as output for a circle."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "def area(r):\n",
    "    A = np.pi*r**2\n",
    "    return A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Claculate the area of a sample circle of radius 10."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "314.1592653589793"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "area(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Define a function which will take radious as input and provides circumference as output for a circle."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "def circumference(r):\n",
    "    C = 2*np.pi*r\n",
    "    return C"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Claculate the circumference of a sample circle of radius 10."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "62.83185307179586"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "circumference(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Lets build a class implementing above constants and functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Circle():\n",
    "    def __init__(self, r):\n",
    "        self.r = r\n",
    "          \n",
    "    def area(self):\n",
    "        A = np.pi*self.r**2\n",
    "        return A\n",
    "    \n",
    "    def circumference(self):\n",
    "        C = 2*np.pi*self.r\n",
    "        return C"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Test using examples. Circle object can be created by calling ```Circle(5)``` and function ```area()``` can be applied later ot together."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "78.53981633974483"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Circle(5).area()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(78.53981633974483, 31.41592653589793)"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "CC = Circle(5)\n",
    "CC.area(),CC.circumference()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Sililar to the functions, a data can be called from class object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "CC.r"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- To use class and function object multiple time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "radius:  2 area :  12.566370614359172 circumf :  12.566370614359172\n",
      "radius:  3 area :  28.274333882308138 circumf :  18.84955592153876\n",
      "radius:  6 area :  113.09733552923255 circumf :  37.69911184307752\n",
      "radius:  24 area :  1809.5573684677208 circumf :  150.79644737231007\n",
      "radius:  25 area :  1963.4954084936207 circumf :  157.07963267948966\n",
      "radius:  46 area :  6647.610054996002 circumf :  289.02652413026095\n",
      "radius:  567 area :  1009987.480609929 circumf :  3562.5660691708254\n"
     ]
    }
   ],
   "source": [
    "for r in [2,3,6,24,25,46,567]:\n",
    "    CC = Circle(r)\n",
    "    print(\"radius: \" , r,\\\n",
    "          \"area : \" , CC.area(),\\\n",
    "          \"circumf : \" , CC.circumference())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Class Gravity"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- To create a function Gravity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gravity(m1,m2,d):\n",
    "    F = (m1*m2)/d**2\n",
    "    return F"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.2"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gravity(5,4,10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Lets create a class ```Newton``` for Gravity calculation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Newton():\n",
    "    \n",
    "    def __init__(self,value_of_G, value_of_g, supplied_info):\n",
    "        self.G = value_of_G\n",
    "        self.info = supplied_info\n",
    "        self.g = value_of_g\n",
    "        \n",
    "    def gravity(self,m1,m2,d):\n",
    "        F = self.G*(m1*m2)/d**2\n",
    "        print(self.info)\n",
    "        return F  \n",
    "    \n",
    "    def gravity_pot(self,m1):\n",
    "        F = m1*self.g\n",
    "        return F      "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- To create a object by calling a class with define inputs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "N1 = Newton(value_of_G =6.7, value_of_g= 9.8,\\\n",
    "            supplied_info = \"great job\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- To find constants and output of functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "great job\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(6.7, 9.8, 0.2378698224852071, 117.60000000000001)"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N1.G, N1.g,N1.gravity(2,3,13),N1.gravity_pot(12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "great job\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "98.26666666666667"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N1.gravity(m1=11,m2=12,d=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Class Dice"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Lets create a Class called ```Dice``` for fun"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dice(object):\n",
    "    \n",
    "    def __init__(self,A_value,B_value,C_value):\n",
    "        self.pi = 3.14\n",
    "        self.A = A_value\n",
    "        self.B = B_value\n",
    "        self.C = C_value \n",
    "    \n",
    "    def find_sum(self,n1,n2):\n",
    "        S = n1+n2\n",
    "        return S\n",
    "    \n",
    "    def find_product(self,n1,n2):\n",
    "        P = n1*n2\n",
    "        return P\n",
    "    \n",
    "    def poly(self,x):\n",
    "        pl = self.A*self.find_product(x,x) + self.B*x + self.C\n",
    "        return pl\n",
    "    \n",
    "    def roll_dice(self):\n",
    "        side = random.choice([1,2,3,4,5,6])\n",
    "        return side\n",
    "    \n",
    "    def roll_two_dices(self):\n",
    "        d1 = self.roll_dice()\n",
    "        d2 = self.roll_dice()\n",
    "        p = self.find_product(d1,d2)\n",
    "        s = self.find_sum(d1,d2)\n",
    "        return d1,d2,p,s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- To implement object created by class with predefined input"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = 2.3; B=4.5; C =8.9\n",
    "D = Dice(A,B,C)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Can I ask this object for value of A, B and C?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2.3, 4.5, 8.9)"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "D.A, D.B, D.C"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- To roll a dice to get randum side"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "D.roll_dice()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- To roll two dice for two randum side. The ```roll_two_dices``` function implements ```find_sum()``` and ```find_product``` functions inside it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 4, 8, 6)"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "D.roll_two_dices()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- To roll a single dice and supply the output of single roll of dice to calculate polynomial function  by implementing ```poly``` function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "43.1"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = D.roll_dice()\n",
    "D.poly(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### References:\n",
    "1. https://docs.python.org/3/tutorial/index.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}