Tutorial 5 - Functions and Modules.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <span style=\"color: #B40486\">BASIC PYTHON FOR RESEARCHERS</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_by_ [**_Megat Harun Al Rashid bin Megat Ahmad_**](https://www.researchgate.net/profile/Megat_Harun_Megat_Ahmad)  \n",
    "last updated: April 14, 2016"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-------\n",
    "## _<span style=\"color: #29088A\">5. Functions and Modules</span>_\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "### **_5.1 Functions_**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$Python$ has many built-in functions, _e.g._, <span style=\"color: #0000FF\">$print$</span> format is a built-in $python$ function, so are the <span style=\"color: #0000FF\">$sqrt$&#40;&#41;</span> function and the <span style=\"color: #0000FF\">$\\pi$</span> value which can be used by importing the <span style=\"color: #0000FF\">$math$</span> library."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Available $python$ function can be used by importing its library usually at the start of the program."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.79583152331\n",
      "3.46410161514\n",
      "6.7082039325\n"
     ]
    }
   ],
   "source": [
    "# Find the square root of integer in a list\n",
    "\n",
    "from math import *\n",
    "\n",
    "x1 = [23,12,45]\n",
    "for m,k in enumerate(x1):\n",
    "    Ex1 = sqrt(k)\n",
    "    print Ex1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the above example, all functions in the <span style=\"color: #0000FF\">$math$</span> library are imported and these functions can be used directly with their original names. The library can also be imported as it is or by assigning it a different name. In these cases the function can only be used by writing the original library name or the assigned name followed by a dot (`.`) and the name of the function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.79583152331\n",
      "3.46410161514\n",
      "6.7082039325\n"
     ]
    }
   ],
   "source": [
    "# Import just the original library name\n",
    "\n",
    "import math\n",
    "\n",
    "x1 = [23,12,45]\n",
    "for m,k in enumerate(x1):\n",
    "    Ex1 = math.sqrt(k)\n",
    "    print Ex1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.79583152331\n",
      "3.46410161514\n",
      "6.7082039325\n"
     ]
    }
   ],
   "source": [
    "# Import and reassign the library name\n",
    "\n",
    "import math as mt\n",
    "\n",
    "x1 = [23,12,45]\n",
    "for m,k in enumerate(x1):\n",
    "    Ex1 = mt.sqrt(k)\n",
    "    print Ex1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes, it is not necessary to import all available functions in a library as this  increases memory usage. For instance to import just the <span style=\"color: #0000FF\">$sqrt$&#40;&#41;</span> function from the <span style=\"color: #0000FF\">$math$</span> library:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.79583152331\n",
      "3.46410161514\n",
      "6.7082039325\n"
     ]
    }
   ],
   "source": [
    "from math import sqrt\n",
    "\n",
    "x1 = [23,12,45]\n",
    "for z in range(0,len(x1),1):\n",
    "    Ex1 = sqrt(x1[z])\n",
    "    print Ex1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The <span style=\"color: #0000FF\">$sqrt$&#40;&#41;</span> function can also be assigned a different name, _e.g._ as <span style=\"color: #0000FF\">$pkd$&#40;&#41;</span>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.79583152331\n",
      "3.46410161514\n",
      "6.7082039325\n"
     ]
    }
   ],
   "source": [
    "from math import sqrt as pkd\n",
    "\n",
    "x1 = [23,12,45]\n",
    "for z in range(0,len(x1),1):\n",
    "    Ex1 = pkd(x1[z])\n",
    "    print Ex1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$Python$ user can also build their own functions and libraries. Function is defined by using the syntax <span style=\"color: #0000FF\">$def$</span> followed by a space and the function name. A pair of round brackets must follow the function name. Function must be defined first before being called. If the function is to receive a variable pass by the caller then this variable must be named inside the pair of the round brackets (if more than one variable then for these variables, each must be separated by a comma). The function can return a value (if more than one value, each value needs to be separated by a comma) that resulted from the function process with syntax <span style=\"color: #0000FF\">$return$</span> _value_ back to the caller. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let us built our own square root function with a specific name such as <span style=\"color: #0000FF\">$pk$</span>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.79583152331\n",
      "3.46410161514\n",
      "6.7082039325\n"
     ]
    }
   ],
   "source": [
    "# Find the square root of integer in a list\n",
    "# using own defined function\n",
    "\n",
    "def pk(arg1):\n",
    "    result_pk = arg1**0.5\n",
    "    return result_pk\n",
    "    \n",
    "x1 = [23,12,45]\n",
    "\n",
    "for z in range(0,len(x1),1):\n",
    "    Ex1 = pk(x1[z])\n",
    "    print Ex1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, the function <span style=\"color: #0000FF\">$pk$</span> was first defined in the program in which it can accept a value (assigned to variable $arg1$). This value was later operated to produce the square root value (assigned to variable $result_pk$) and this was returned back to the caller. The function was called in the <span style=\"color: #0000FF\">$for$</span> control structure with the elements of the list $x1$ passed to the function sequentially."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"Tutorial5/Function_flow.png\" width=\"300\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is another example on function that converts temperature value in Celcius to Fahreinheit:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Give the temperature Celcius: 38\n",
      "The 38.00°C is equivalent to 100.40°F\n"
     ]
    }
   ],
   "source": [
    "# Celcius to Fahreinheit\n",
    "\n",
    "def Fahreinheit(temp):\n",
    "    temp = float(temp)\n",
    "    temp = (temp*9/5)+32\n",
    "    return temp\n",
    "\n",
    "deg = u\"\\u00B0\"\n",
    "\n",
    "valC = input(\"Give the temperature Celcius: \")\n",
    "valF = Fahreinheit(valC)\n",
    "print (\"The %3.2f%sC is equivalent to %3.2f%sF\" % (valC,deg,valF,deg))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "### **_5.2 Modules_**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function definition can be written on different $python$ file and can be imported _i.e._ just like a library. This is called a module. Let us create two files, one contains the function (\"Temp.py\") and the other is the main program that will call the function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting Temp.py\n"
     ]
    }
   ],
   "source": [
    "%%file Temp.py\n",
    "\n",
    "#Temp.py\n",
    "#Celcius to Fahreinheit\n",
    "\n",
    "def Fahreinheit(temp):\n",
    "    temp = float(temp)\n",
    "    temp = (temp*9/5)+32\n",
    "    return temp "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A text can be written to file in a <span style=\"color: #F88017\">_**Jupyter Notebook**_</span> input cell. This can be done by writing <span style=\"color: #8A0886\">&#37;&#37;</span> <span style=\"color: #21610B\">$file$</span> at the start of the cell followed by the file name. Upon executing the cell, this file will be created and all written texts after the line <span style=\"color: #8A0886\">&#37;&#37;</span> <span style=\"color: #21610B\">$file$</span> _filename_ will be appended to the file."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To call the function <span style=\"color: #0000FF\">$Fahreinheit$</span>, we need to import the function into the main program from the module <span style=\"color: #0000FF\">$Temp$</span>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Give the temperature in Celcius: 38\n",
      "The 38.00°C is equivalent to 100.40°F\n"
     ]
    }
   ],
   "source": [
    "from Temp import Fahreinheit as Fh\n",
    "\n",
    "deg = u\"\\u00B0\"\n",
    "\n",
    "valC = input(\"Give the temperature in Celcius: \")\n",
    "valF = Fh(valC)\n",
    "print (\"The %3.2f%sC is equivalent to %3.2f%sF\" % (valC,deg,valF,deg))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <span style=\"color: #F5DA81; background-color: #610B4B\">Example 5.1</span>: Write a program that can receive input value in Celcius or Fahreinheit and transform the value into Fahreinheit and Celcius respectively. Create the calculating functions as import module."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting TempConv.py\n"
     ]
    }
   ],
   "source": [
    "%%file TempConv.py\n",
    "\n",
    "# TempConv.py\n",
    "\n",
    "# Celcius to Fahreinheit\n",
    "\n",
    "def Fahreinheit(temp):\n",
    "    temp = float(temp)\n",
    "    temp = (temp*9/5)+32\n",
    "    return temp\n",
    "\n",
    "# Fahreinheit to Celcius\n",
    "\n",
    "def Celcius(temp):\n",
    "    temp = float(temp)\n",
    "    temp = (temp-32)*5/9\n",
    "    return temp\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A variable in a function is a local variable, which means that it cannot be used outside the function. It also means that identical variable name can be used in other functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Give the temperature in Celcius: 31\n",
      "The 31.0°C is equivalent to 87.8°F\n",
      "Give the temperature in Fahreinheit: 77\n",
      "The 77.0°F is equivalent to 25.0°C\n"
     ]
    }
   ],
   "source": [
    "from TempConv import *\n",
    "\n",
    "deg = u\"\\u00B0\"\n",
    "\n",
    "valC = input(\"Give the temperature in Celcius: \")\n",
    "valF = Fahreinheit(valC)\n",
    "print (\"The %3.1f%sC is equivalent to %3.1f%sF\" % (valC,deg,valF,deg))\n",
    "\n",
    "valF = input(\"Give the temperature in Fahreinheit: \")\n",
    "valC = Celcius(valF)\n",
    "print (\"The %3.1f%sF is equivalent to %3.1f%sC\" % (valF,deg,valC,deg))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Which temperature you want to convert, Celcius or Fahreinheit (C or F) C\n",
      "Give the temperature in Celcius: 28\n",
      "The 28.0°C is equivalent to 82.4°F\n"
     ]
    }
   ],
   "source": [
    "from TempConv import *\n",
    "\n",
    "deg = u\"\\u00B0\" # assigning a variable to a unicode for degree symbol\n",
    "\n",
    "TempType = raw_input(\"Which temperature you want to convert, \\\n",
    "Celcius or Fahreinheit (C or F) \")\n",
    "\n",
    "TempType = TempType.upper()\n",
    "\n",
    "if TempType == 'C':\n",
    "    valC = input(\"Give the temperature in Celcius: \")\n",
    "    valF = Fahreinheit(valC)\n",
    "    print (\"The %3.1f%sC is equivalent to %3.1f%sF\" % (valC,deg,valF,deg))\n",
    "\n",
    "elif TempType == 'F':\n",
    "    valF = input(\"Give the temperature in Fahreinheit: \")\n",
    "    valC = Celcius(valF)\n",
    "    print (\"The %3.1f%sF is equivalent to %3.1f%sC\" % (valF,deg,valC,deg))\n",
    "    \n",
    "else:\n",
    "    print \"No or wrong type is given.\"\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we need to cyclically run the above program to get results from different inputs, for example to know the temperature values with different units for several towns in Malaysia."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is however a different and better programming approach (but not necessarily true for all cases). This is called object-oriented programming."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "### **_5.3 Object-Oriented Programming_**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is no straight-forward definition of object-oriented programming (OOP). In this tutorial, OOP can be viewed as a different ways of building functions with group of data built using it. It involves the usage of <span style=\"color: #0000FF\">$class$</span> and interacting variables which are usually called <span style=\"color: #0000FF\">$objects$</span>. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: #0000FF\">$Class$</span> is similar to function <span style=\"color: #0000FF\">$def$</span>, but inside a defined <span style=\"color: #0000FF\">$class$</span>, functions can be defined (these functions are usually called methods). Let us create similar library <span style=\"color: #0000FF\">$TempConv$</span> but this time in object oriented mode (the file is called \"TempConvOO.py\"):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting TempConvOO.py\n"
     ]
    }
   ],
   "source": [
    "%%file TempConvOO.py\n",
    "\n",
    "# TempConvOO.py\n",
    "\n",
    "\"\"\"Convert temperature to Celcius or Fahreinheit\n",
    "\n",
    "    Attributes:\n",
    "        temp: integer/floating value of input temperature\n",
    "\"\"\"\n",
    "\n",
    "class Convert(object):\n",
    "    \n",
    "    def __init__(self,temp):\n",
    "        \n",
    "        self.temp = float(temp)\n",
    "    \n",
    "    # Celcius to Fahreinheit\n",
    "    def toFahreinheit(self):\n",
    "        print \"%.1f F\" % ((self.temp*9/5)+32)\n",
    "\n",
    "    # Fahreinheit to Celcius\n",
    "    def toCelcius(self):\n",
    "        print \"%.1f C\" % ((self.temp-32)*5/9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this library a class named <span style=\"color: #0000FF\">$Convert$</span> (that can create object) is declared with three methods: `__init__()`, `toFahreinheit()` and `toCelcius()`. The `__init__()` is a special method that initializes a newly construct object when the <span style=\"color: #0000FF\">$class$</span> is called. The first argument of `__init__()` is a must (here conventionally named as <span style=\"color: #0000FF\">$self$</span>) and function as a reference to instances or attributes of the object which can later be used by all the other methods (Instances or attributes are variables that can be used inside methods). These methods therefore must also have <span style=\"color: #0000FF\">$self$</span> as first argument.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, `__init__()` constructor must receive an input (the temperature value that is assigned to <span style=\"color: #0000FF\">$temp$</span>, the second variable or attribute). The <span style=\"color: #0000FF\">$temp$</span> value is assigned to <span style=\"color: #0000FF\">$self.temp$</span> and this instance can be used by all the methods. If it is not assigned to <span style=\"color: #0000FF\">$self$.\\_$attribute$\\_</span> than it is just a local attribute which means it can only be used inside the method similar like local variable declared inside a function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The TempConvOO file or library can now be imported:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from TempConvOO import Convert"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The class <span style=\"color: #0000FF\">$Convert$</span> was imported as it is, with all its methods. We now pass an argument (the value of temperature that needs to be converted) to the class <span style=\"color: #0000FF\">$Convert$</span> that will convert it to Fahreinheit value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "86.0 F\n"
     ]
    }
   ],
   "source": [
    "Convert(30).toFahreinheit()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Logically the passing of the integer '30' above represents the temperature value of unit Celcius and this was converted to Fahreinheit '86.0'. This is indicated by the method `toFahreinheit()` of the class Convert. Syntactically, in one line, the invoking of this method can be done by passing the integer value to the class followed by a dot '`.`' and the name of the method. This can be pass to an object:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "Klang = Convert(87)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Object of the class can be created by assigning the invoked class to it. In the above line, the object is the name of the city of Klang and the integer '87' was passed as temperature value in Fahreinheit. Any method from the class Convert can now be called by the name of this object followed by a dot '`.`' and the name of the method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30.6 C\n"
     ]
    }
   ],
   "source": [
    "Klang.toCelcius()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "188.6 F\n"
     ]
    }
   ],
   "source": [
    "Klang.toFahreinheit()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This seems incorrect as trying to convert back to Fahreinheit gives a different value from '87' as input. The library is therefore needs to be refined and it may be better when creating objects, apart from the value of the temperature, the unit of the temperature can also be passed to the class."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This issue is addressed in the example below with a new library. Here the library will be called from a folder named 'Tutorial5' and to call the library from this folder an empty file named as `'__init__.py'` needs to be created inside the folder."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting Tutorial5/__init__.py\n"
     ]
    }
   ],
   "source": [
    "%%file Tutorial5/__init__.py\n",
    "\n",
    "#This an empty file "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting Tutorial5/TempConvO1.py\n"
     ]
    }
   ],
   "source": [
    "%%file Tutorial5/TempConvO1.py\n",
    "\n",
    "# TempConvOO.py\n",
    "\n",
    "\"\"\"Convert temperature to Celcius or Fahreinheit\n",
    "\n",
    "    Attributes:\n",
    "        temp: integer/floating value of input temperature\n",
    "        unit: string of the temperature unit\n",
    "\"\"\"\n",
    "\n",
    "class Convert(object):\n",
    "    \n",
    "    def __init__(self,temp,unit):\n",
    "        \n",
    "        self.temp = float(temp)\n",
    "        self.unit = unit\n",
    "    \n",
    "    # Celcius to Fahreinheit\n",
    "    def toFahreinheit(self):\n",
    "        \n",
    "        if self.unit == 'Fahreinheit':\n",
    "            print \"%.1f F\" % self.temp\n",
    "        else:\n",
    "            print \"%.1f F\" % ((self.temp*9/5)+32)\n",
    "\n",
    "    # Fahreinheit to Celcius\n",
    "    def toCelcius(self):\n",
    "        \n",
    "        if self.unit == 'Celcius':\n",
    "            print \"%.1f C\" % self.temp\n",
    "        else:\n",
    "            print \"%.1f C\" % ((self.temp-32)*5/9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this new library, the class Convert will now receives two attributes: temperature value and unit. Methods can now be called with this instance and produce correct outputs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from Tutorial5.TempConvO1 import Convert\n",
    "Klang = Convert(87, 'Fahreinheit')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Importing a library from folder requires writing the name of the folder followed by a `'.'` and the name of the library."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30.6 C\n"
     ]
    }
   ],
   "source": [
    "Klang.toCelcius()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "87.0 F\n"
     ]
    }
   ],
   "source": [
    "Klang.toFahreinheit()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now build a group of data with this class. For instance the temperatures in Celcius for selected cities in Selangor, Malaysia. These group of data can be accessed and processed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "Rawang = Convert(77, 'Fahreinheit'); Bangi = Convert(32, 'Celcius'); \n",
    "Kapar = Convert(28, 'Celcius')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25.0 C\n"
     ]
    }
   ],
   "source": [
    "Rawang.toCelcius()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "82.4 F\n"
     ]
    }
   ],
   "source": [
    "Kapar.toFahreinheit()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "32.0 C\n"
     ]
    }
   ],
   "source": [
    "Bangi.toCelcius()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now easily access and process these objects after creating them without cyclically having to create and destroy the assigned value like in the last example of subtopic 5.2."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <span style=\"color: #F5DA81; background-color: #610B4B\">Example 5.2</span>: Write a program that read a given file (_WeatherData.txt_) that contains the basic weather data of few selected towns in Selangor, Malaysia and create objects that contain all these data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Reading line data from file and pass it to a list\n",
    "\n",
    "filehandle = open(\"Tutorial5/WeatherData.txt\",\"r\")\n",
    "townWeather = filehandle.readlines()\n",
    "filehandle.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['\\n',\n",
       " 'Town Temperature(C) Condition Wind(km/hr) Precipitation(%)\\n',\n",
       " '\\n',\n",
       " 'Klang 33.6 Clear 5 55\\n',\n",
       " 'Rawang 35.5 Haze 2 77\\n',\n",
       " 'Bangi 27.0 Rain 10 95\\n',\n",
       " 'Kapar 30.8 Cloudy 7 80']"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Check the content of the list\n",
    "\n",
    "townWeather"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting Tutorial5/Weather.py\n"
     ]
    }
   ],
   "source": [
    "%%file Tutorial5/Weather.py\n",
    "\n",
    "# Weather.py\n",
    "\n",
    "\"\"\"Weather conditions of selected towns in Selangor, Malaysia\n",
    "\n",
    "    Attributes:\n",
    "        temp: integer/floating value of temperature\n",
    "        cond: string of weather condition\n",
    "        wcond: integer/floating value of wind speed\n",
    "        prep: integer/floating value of humidity\n",
    "\"\"\"\n",
    "\n",
    "class Weather(object):\n",
    "    \n",
    "    def __init__(self, datalist):\n",
    "        \n",
    "        self.temp = float(datalist[0])\n",
    "        self.cond = datalist[1]\n",
    "        self.wcond = int(datalist[2])\n",
    "        self.prep = int(datalist[3])\n",
    "    \n",
    "    def changetemperature(self, temp):\n",
    "\n",
    "        self.temp = float(temp)\n",
    "        print \"The temperature is %.1f%sC\" % (self.temp,u\"\\u00B0\")\n",
    "\n",
    "    # New condition\n",
    "    def changecondition(self, cond):\n",
    "        self.cond = cond\n",
    "        print \"The condition is %s\" % self.cond\n",
    "\n",
    "    # New wind speed\n",
    "    def changewindspeed(self, wcond):\n",
    "        self.wcond = wcond\n",
    "        print \"The wind speed is %d km/hr\" % self.wcond\n",
    "        \n",
    "    # New humidity\n",
    "    def changehumidity(self, prep):\n",
    "        self.prep = prep\n",
    "        print \"The humidity is %d%s\" % (self.prep,u\"\\u0025\")\n",
    "\n",
    "    # Temperature\n",
    "    def temperature(self):\n",
    "\n",
    "        print \"The temperature is %.1f%sC\" % (self.temp,u\"\\u00B0\")\n",
    "\n",
    "    # Condition\n",
    "    def condition(self):\n",
    "\n",
    "        print \"The condition is %s\" % self.cond\n",
    "\n",
    "    # Wind speed\n",
    "    def windspeed(self):\n",
    "\n",
    "        print \"The wind speed is %d km/hr\" % self.wcond\n",
    "        \n",
    "    # Humidity\n",
    "    def humidity(self):\n",
    "\n",
    "        print \"The humidity is %d%s\" % (self.prep,u\"\\u0025\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Importing the Weather class as wt\n",
    "\n",
    "from Tutorial5.Weather import Weather as wt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Klang 33.6 Clear 5 55\\n',\n",
       " 'Rawang 35.5 Haze 2 77\\n',\n",
       " 'Bangi 27.0 Rain 10 95\\n',\n",
       " 'Kapar 30.8 Cloudy 7 80']"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Slicing the list\n",
    "\n",
    "townWeather[3:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Creating a two dimensional list\n",
    "\n",
    "townWeather1 = []\n",
    "\n",
    "for i,j in enumerate(townWeather[3:]):\n",
    "    \n",
    "    townWeather1 = townWeather1 + [j.replace('\\n','').split()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['Klang', '33.6', 'Clear', '5', '55'],\n",
       " ['Rawang', '35.5', 'Haze', '2', '77'],\n",
       " ['Bangi', '27.0', 'Rain', '10', '95'],\n",
       " ['Kapar', '30.8', 'Cloudy', '7', '80']]"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Checking the content of the two dimensional list\n",
    "\n",
    "townWeather1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Create a dictionary with keys as objects\n",
    "\n",
    "town = {}\n",
    "for i,j in enumerate(townWeather1):\n",
    "    passobject = wt([j[1],j[2],j[3],j[4]])\n",
    "    town[j[0]] = passobject\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Bangi': <Tutorial5.Weather.Weather at 0x7f2ed4096d90>,\n",
       " 'Kapar': <Tutorial5.Weather.Weather at 0x7f2ed4096dd0>,\n",
       " 'Klang': <Tutorial5.Weather.Weather at 0x7f2ed4096d10>,\n",
       " 'Rawang': <Tutorial5.Weather.Weather at 0x7f2ed4096d50>}"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "town"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The temperature is 33.6°C\n"
     ]
    }
   ],
   "source": [
    "town['Klang'].temperature()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The humidity is 77%\n"
     ]
    }
   ],
   "source": [
    "town['Rawang'].humidity()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The humidity is 98%\n"
     ]
    }
   ],
   "source": [
    "town['Rawang'].changehumidity(98)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The humidity is 98%\n"
     ]
    }
   ],
   "source": [
    "town['Rawang'].humidity()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "More on functions and modules can be found on https://docs.python.org/2/tutorial/modules.html"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}