Python_tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python Tutorial\n",
    "\n",
    "from Google python exercises and\n",
    "http://interactivepython.org/runestone/static/pythonds/index.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Utilities\n",
    "File System -- os, os.path, shutil\n",
    "\n",
    "**os**\n",
    "- .system(' ') output\n",
    "- .listdir(/dir) - list of filenames in the directory path (just the names)\n",
    "- .path.join(/dir,filename) - given a filename, puts the directory and filename together to make a path\n",
    "- .path.abspath(path) - given a path, return an absolute form (e.g. /home/user/foo/bar.html)\n",
    "- .path.dirname(path), .path.basename(path) - returns \"/home/user/foo\" and \"bar.html\"\n",
    "- .mkdir(dir_path) - makes one directory\n",
    "- .makedirs(dir_path) - makes all directories needed\n",
    "- .path.exists(dir_path) - checks for existence\n",
    "\n",
    "- shutil.copy(source-path, dest-path) - copy a file (eq to cp in bash)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## OOP: **Classes**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "# we want to print fractions so that it is reduced by the greatest common denominator\n",
    "def gcd(m,n):\n",
    "    while m%n is not 0:\n",
    "        oldm = m\n",
    "        oldn = n\n",
    "        \n",
    "        m = oldn\n",
    "        n = oldm%oldn\n",
    "    return n\n",
    "print gcd(20,10)\n",
    "print gcd(15,9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2/1\n",
      "2/1\n",
      "5/1\n",
      "7/1\n"
     ]
    }
   ],
   "source": [
    "# now we write a class to do fraction operations\n",
    "class Fraction:\n",
    "    def __init__(self,arg1,arg2):\n",
    "        self.num=arg1 #numerator\n",
    "        self.den=arg2 #denominator\n",
    "        self.common = gcd(self.num, self.den)\n",
    "    def show(self):\n",
    "        print '%d/%d' %(self.num//self.common, self.den//self.common)\n",
    "        \n",
    "    # Only with this method written, class Fraction(a,b) will return the string. \n",
    "    def __str__(self):\n",
    "        return str(self.num//self.common)+\"/\"+str(self.den//self.common)\n",
    "    \n",
    "    #some basic operators we can modify as method\n",
    "    def __add__(self,otherfraction):\n",
    "        addnum = self.num*otherfraction.den + otherfraction.num*self.den\n",
    "        addden = self.den*otherfraction.den\n",
    "        return Fraction(addnum//self.common, addden//self.common)\n",
    "    \n",
    "\n",
    "f = Fraction(10,5) #str is returned from __str__ method\n",
    "print f\n",
    "f.show() #also prints the string\n",
    "\n",
    "f2 = Fraction (10,2)\n",
    "print f2\n",
    "print f+f2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "black\n"
     ]
    }
   ],
   "source": [
    "class Car():\n",
    "    def __init__(self):\n",
    "        self.color='black'\n",
    "        self.model='accord'\n",
    "        self.make='honda'\n",
    "new = Car()\n",
    "print new.color"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## OOP: Inheritance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Error handling in data sets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- can use 'set' type to extract all unique values in data columns *(it will also show empty spaces as '')*\n",
    "\n",
    "**dealing with empty values**\n",
    "- remove any row containing missing values\n",
    "- fill in the missing value with a specified value\n",
    "- fill in the missing value with a calculated value\n",
    "\n",
    "**Try/Except blocks**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There was an error\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    int('')\n",
    "except Exception:\n",
    "    print(\"There was an error\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "try:\n",
    "    int('')\n",
    "except Exception:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## List comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "animals = [\"Dog\", \"Tiger\", \"SuperLion\", \"Cow\", \"Panda\"]\n",
    "\n",
    "animals_lengths = []\n",
    "for animal in animals:\n",
    "    animals_lengths.append(len(animal))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**vs**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "animal_lengths = [len(animal) for animal in animals] ##much more compact coding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[200, 202, 204, 210]\n"
     ]
    }
   ],
   "source": [
    "apple_prices = [100, 101, 102, 105]\n",
    "\n",
    "apple_prices_doubled=[ apple*2 for apple in apple_prices ]\n",
    "apple_prices_lowered=[ apple-100 for apple in apple_prices ]\n",
    "print apple_prices_doubled"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using Type None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-50\n"
     ]
    }
   ],
   "source": [
    "values = [-50, -80, -100]\n",
    "max_value = None\n",
    "for i in values:\n",
    "    if max_value is None or i > max_value:  #opposite is 'is not None'\n",
    "        max_value = i\n",
    "print max_value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionary notations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hi bye\n",
      "goodmorning goodnight\n"
     ]
    }
   ],
   "source": [
    "dict= {'hi':'bye', 'goodmorning':'goodnight'}\n",
    "for key, value in dict.items():\n",
    "    print key,value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Datetime"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n"
     ]
    }
   ],
   "source": [
    "import datetime\n",
    "current_datetime = datetime.datetime.now()\n",
    "current_year = current_datetime.year\n",
    "current_month = current_datetime.month\n",
    "print current_month"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "today = datetime.datetime.now()\n",
    "diff = datetime.timedelta(days=1)\n",
    "tomorrow = today + diff\n",
    "yesterday = today - diff"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10:52PM on Tuesday July 26, 2016\n"
     ]
    }
   ],
   "source": [
    "mystery_date = datetime.datetime.now()\n",
    "mystery_date_formatted_string = mystery_date.strftime(\"%I:%M%p on %A %B %d, %Y\")\n",
    "print(mystery_date_formatted_string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2016-07-26 22:52:00\n"
     ]
    }
   ],
   "source": [
    "mystery_date =datetime.datetime.strptime( mystery_date_formatted_string,\"%I:%M%p on %A %B %d, %Y\")\n",
    "print (mystery_date)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n",
      "2016\n",
      "26\n"
     ]
    }
   ],
   "source": [
    "print today.month\n",
    "print today.year\n",
    "print today.day"
   ]
  }
 ],
 "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
}