Practice_Final.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Unix\n",
    "\n",
    "Find the total file size in bytes by extension for all files under the `./tree` directory (include files in sub directories, sub sub directories, etc).  Store your results in a dictionary from extension -> total size and print your directory as a 2 column tab delimited table like so:\n",
    "\n",
    "> EXTENSION (tab) SIZE\n",
    "> .ps (tab) 3000\n",
    "> .pdf (tab) 5400\n",
    "\n",
    "\n",
    "**Hint:** Use the [os.walk](https://docs.python.org/2/library/os.html) function to find all files below a directory."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import os\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Unix Shell Commands\n",
    "\n",
    "Your solution to each of the two following problems should be a single command line which defines a sequence of unix commands connected by pipes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Unix question 1\n",
    "Print the number of times each character appears as the first character of a line in the file `word_list/canadian-words.95`.  \n",
    "\n",
    "Your output should appear like this:\n",
    "\n",
    "`\n",
    " 224 a\n",
    "  54 b\n",
    " 251 c\n",
    " 156 d\n",
    "  99 e\n",
    "  85 f\n",
    "  62 g\n",
    " 168 h\n",
    "  83 i\n",
    "   8 j\n",
    "   7 k\n",
    "  81 l\n",
    "...`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Unix question 2\n",
    "\n",
    "Find all lines of the file `word_list/canadian-words.95` which contain a repeated letter.  IE 'Sneeze' contains a repeated e while 'Sneze' does not.  Count the number of words this occurs in.\n",
    "\n",
    "The correct output is 351\n",
    "\n",
    "**Hint:** Grep backreferences may be useful."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##Python Programming\n",
    "\n",
    "Write a list comprehension that creates a list containing all of the numbers that are both exact squares and odd in the range 1 to 100."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a function expand which takes a word and repeats each character one more time than the previous character.\n",
    "\n",
    "For example \"BANG!\" becomes \"BAANNNGGGG!!!!!\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def expand(word):\n",
    "    raise \"Todo\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a function \"string_value\" which takes a string, converts each letter to its ascii code (*hint: the ord function returns a characters ascii value*) and returns the sum of the strings ascii values.  For example cat -> [99, 97, 116] -> 312.  \n",
    "\n",
    "Then load the file `word_list/canadian-words.95` into a list and sort the list by the value returned by string_value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##Git/iPython Magics\n",
    "Load your repositories .gitignore file using ipython magics.  Modify the file so that it ignores files with the extension .ignoreme.  Write the file using ipython magics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pandas and Matplot Lib\n",
    "The CSV file called `temps.csv` contains the daily temperature recorded for a particular year at a particular meteorological station. Also given is the country and state where each \n",
    "station is located.\n",
    "\n",
    "Some of the entries are empty, which indicates \"undefined\"\n",
    "\n",
    "Create a data frame that summarizes the data by country and by state (IE a temperature for California should be included in both the California and the United States of America row).\n",
    "\n",
    "The summary data frame should have the following 7 columns:\n",
    "  * Country\n",
    "  * State (The word \"ALL\" for a country wide sumamry)\n",
    "  * Number of years recorded for this region\n",
    "  * The maximum temperature recorded in this region\n",
    "  * The minimum temperature recorded in this region\n",
    "  * The mean temperature for this region\n",
    "  * The number of undefined measurements \n",
    "  \n",
    "Sort the table by decreasing value of the mean temperature and print the first 10 rows.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import matplotlib.pyplot  as plt\n",
    "import numpy as np\n",
    "raw_data = pd.read_csv(\"temps.csv\")\n",
    "%pylab inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using the summary data frame produced before, make a bar plot showing the mean temperature of each state in the USA.  Label each bar with the state name.  Then put a line across all bars showing the mean temperature of the US.\n",
    "\n",
    "An example of the kind of plot we want is [here](http://static1.businessinsider.com/image/52e7cfeaecad04b858356443/here-are-the-states-with-the-highest-and-lowest-unemployment-rates.jpg).  You can make the plot either vertical or horizontal, whichever you think displays the data better."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using the raw data frame, pick the state with the highest mean and the lowest mean.  Plot the temperature on the first day of the year vs year for these two states as a line plot.  Make line for the highest mean state be red and the lowest mean state be blue.  Add a legend mapping from line color -> state name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## MatplotLib\n",
    "The shape of a Limaçon (https://en.wikipedia.org/wiki/Lima%C3%A7on) can be defined parametrically as\n",
    "\n",
    "1. r = r0 + cos θ\n",
    "2. x = r cos θ\n",
    "3. y = r sin θ\n",
    "\n",
    "When r0 = 1, this curve is called a cardioid. Write a function using this definition which will take r0 values and plot the shape of a Limaçon. Cal the function for r0 = 0.8, r0 = 1.0, and r0 = 1.2. \n",
    "\n",
    "Be sure to use enough points that the curve is closed and appears smooth (except for\n",
    "the cusp in the cardioid). Use a legend to identify which curve is which."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def plotLimacon(r):\n",
    "    raise\"TODO\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##Object Oriented Programming\n",
    "Assume you are working for a bank and have been tasked with implimenting objects to manage their accounts.  The architecht has given you this class to inherit from and wants you to impliment a number of unique account types."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "class Account:\n",
    "    def __init__(self, amount, rate):\n",
    "        \"\"\"Initializes the account, all account types have a starting amount and a rate\"\"\"\n",
    "        self.amount = amount\n",
    "        self.rate = rate\n",
    "        self.day = 0\n",
    "        \n",
    "    def balance(self):\n",
    "        \"\"\"Returns the balance of the account\"\"\"\n",
    "        return self.amount\n",
    "    \n",
    "    def deposit(self, amount):\n",
    "        \"\"\"Deposits money into the account depending on specific rules.\n",
    "           Returns true if the deposit is accepted and false if it is not\"\"\"\n",
    "        raise \"This is an abstract class\" \n",
    "    \n",
    "    def withdraw(self, amount):\n",
    "        \"\"\"Withdraws money from the account.\n",
    "           Returns true if the deposit is accepted and false if it is not\"\"\"\n",
    "        raise \"This is an abstract class\"\n",
    "        \n",
    "    def tick(self):\n",
    "        \"\"\"Called once a day, used to compute interest or any other logic that must occur every day\"\"\"\n",
    "        self.day = self.day + 1\n",
    "        self._tick_action()\n",
    "        \n",
    "    def _tick_action(self):\n",
    "        \"\"\"Logic that should happen on tick goes here\"\"\"\n",
    "        raise \"This is an abstract class\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As an example the architecht gives you the basic account class.  A basic account always accepts deposits but only accepts withdraws if customer withdraws less money than the current balance.  Additionally the interest is accumulated every day."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "class BasicAccount(Account):\n",
    "    def deposit(self, amount):\n",
    "        self.amount = self.amount + amount\n",
    "        return True\n",
    "    \n",
    "    def withdraw(self, amount):\n",
    "        \"\"\"Withdraws money from the account.\n",
    "           Returns true if the deposit is accepted and false if it is not\"\"\"\n",
    "        if( amount <= self.amount ):\n",
    "            self.amount = self.amount - amount\n",
    "            return True\n",
    "        else:\n",
    "            return False\n",
    "        \n",
    "    def _tick_action(self):\n",
    "        self.amount = self.amount + self.rate*self.amount"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Your first task is to impliment the SuperSaverAccount class which is the same as the basic account except that it only accrues interest once every 30 days."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "class SuperSaverAccount(Account):\n",
    "    def deposit(self, amount):\n",
    "        raise \"Todo\"\n",
    "    \n",
    "    def withdraw(self, amount):\n",
    "        raise \"Todo\"\n",
    "        \n",
    "    def _tick_action(self):\n",
    "        raise \"Todo\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now impliment the PlatinumAccount class.  The platinum account allows any withdraw or deposit; however, they don't go through until the end of the day.  At the end of the day all withdraws are processed and then all deposits are processed.  If the balance ever goes below 0, the balance is reduced by \\$100 as a penalty.  If the amount is above 0 at the end of the day, interest is added the same as a standard account.\n",
    "\n",
    "When inquiring about the balance, it should return the current amount of the account + pending deposits - pending withdraws but no any penalty"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "class PlatinumAccount(Account):\n",
    "    def __init__(self, amount, rate):\n",
    "        Account.__init__(self,amount, rate) \n",
    "        raise \"Todo\"\n",
    "\n",
    "    def deposit(self, amount):\n",
    "        raise \"Todo\"\n",
    "    \n",
    "    def withdraw(self, amount):\n",
    "        raise \"Todo\"\n",
    "        \n",
    "    def balance(self):\n",
    "        raise \"Todo\"\n",
    "        \n",
    "    def _tick_action(self):\n",
    "        raise \"Todo\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After you implemented the account classes, you are now tasked with implementing the bank class.  This class is responsible for managing a group of accounts.\n",
    "\n",
    "When an account is created, it is assigned a seiral number (the first account is 0, second 1, etc) and stored at the bank, this number is returned by create_account.  The customer then gives the account number whenever they want to perform an acction on the account."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "class Bank:\n",
    "    def __init__(self):\n",
    "        raise \"Todo\"\n",
    "    \n",
    "    def create_account(self,account):\n",
    "        \"\"\"Registers the `account` object with the bank.  Returns the account number assigned to this account\"\"\"\n",
    "        raise \"Todo\"\n",
    "        \n",
    "    def deposit(self, account_number, amount):\n",
    "        \"\"\"Looks up the account corrsponding to `account_number` and deposits `amount` into it\"\"\"\n",
    "        raise \"Todo\"\n",
    "\n",
    "    def withdraw(self, account_number, amount):\n",
    "        \"\"\"Looks up the account corrsponding to `account_number` and withdraws `amount` into it\"\"\"\n",
    "        raise \"Todo\"\n",
    "\n",
    "    def balance(self, account_number):\n",
    "        \"\"\"Looks up the account corrsponding to `account_number` and returns the balance\"\"\"\n",
    "        raise \"Todo\"\n",
    "        \n",
    "    def tick(self):\n",
    "        \"\"\"Called once per day, used to ensure all accounts get their interest and such computed\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#After everythign is done this should only print True a bunch of times:\n",
    "\n",
    "bank = Bank()\n",
    "a = bank.create_account(BasicAccount(0,0.1))\n",
    "print bank.balance(a) == 0\n",
    "print bank.deposit(a,100) == True\n",
    "print bank.balance(a) == 100\n",
    "print bank.withdraw(a,1000) == False\n",
    "print bank.balance(a) == 100\n",
    "\n",
    "bank.tick()\n",
    "b = bank.create_account(PlatinumAccount(0,0.1))\n",
    "print bank.balance(b) == 0\n",
    "print bank.deposit(b,1000) == True\n",
    "print bank.withdraw(b,100) == True\n",
    "print bank.balance(b) == 900\n",
    "bank.tick()\n",
    "print bank.balance(b) == 880\n",
    "\n",
    "c = bank.create_account(SuperSaverAccount(0,0.1))\n",
    "print bank.deposit(c,100)\n",
    "for i in range(29):\n",
    "    bank.tick()\n",
    "    print bank.balance(c) == 100\n",
    "bank.tick()\n",
    "print bank.balance(c) == 110"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "#Scraping Exercise"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Scraping Exercise 2 is part of the practice final. You are nonetheless expected to solve and submit scraping exercise 2 while rest of the practice final questions need not be submitted"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}