3-3.5_Mod03_Practice.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Module 3 Practice\n",
    "\n",
    "\n",
    "### Students will be able to:\n",
    "\n",
    "## 3-3.1 Error Handling\n",
    "* Differentiate between exception types and recognize their meaning\n",
    "* Handle a raised exception\n",
    "* Handle different exception types\n",
    "* Use `finally` to perform clean-up actions \n",
    "* Raise a forced exception of a particular type\n",
    "\n",
    "## 3-3.2 Files \n",
    "* Delete files\n",
    "* Check that a file exists\n",
    "* Check if a path is a file or directory\n",
    "* Handle file exceptions\n",
    "* Use `with` statement to ensure an opened file is closed after catching an exception.\n",
    "\n",
    "## 3-3.3 Tuples\n",
    "* Differentiate between tuples and lists\n",
    "* Create tuples\n",
    "* Access tuples elements\n",
    "* Convert a list into tuple and a tuple into a list\n",
    "* Delete tuples\n",
    "* Slice tuples\n",
    "* Unpack tuples\n",
    "* Use basic tuple operations and functions\n",
    "\n",
    "## 3-3.4 Dictionaries\n",
    "* Create dictionaries\n",
    "* Access dictionary values\n",
    "* Change and add dictionary items\n",
    "* Delete dictionary items\n",
    "* Delete a whole dictionary variable\n",
    "* Iterate over the keys of a dictionary \n",
    "* Iterate over the values of a dictionary\n",
    "* Iterate over the items of a dictionary\n",
    "* Use dictionary operations and functions (i.e. containment, sorting...etc.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "<font size=\"6\" color=\"#B24C00\"  face=\"verdana\"> <B>Task 1</B></font>\n",
    "\n",
    "## Exception Types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# [ ] Write an expression to raise a `SyntaxError` exception\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# [ ] Write an expression to raise a `TypeError` exception\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "<font size=\"6\" color=\"#B24C00\"  face=\"verdana\"> <B>Task 2</B></font>\n",
    "\n",
    "## Handling Exceptions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "## [ ] The following program divides the elements of `lst` by a float number `x` specified by the user\n",
    "# Use exception handling to correct for the ALL generated exceptions\n",
    "# When you handle all exceptions correctly, you should see the word \"Done!\" in the program output\n",
    "\n",
    "# HINT: You might need to use 2 `try..except` statements\n",
    "\n",
    "# Test cases:\n",
    "# x = 5\n",
    "# x = 6.3\n",
    "# x = \"number\"\n",
    "# x = 0\n",
    "\n",
    "lst = [8, 85.4, [55, 4], 'word', (59,), {2:43.5}]\n",
    "\n",
    "x = input(\"Enter a number: \")\n",
    "x = float(x)\n",
    "\n",
    "for i in range(7):\n",
    "    print(\"{} / {:.2f} = {:.2f}\".format(lst[i], x, lst[i] / x))\n",
    "\n",
    "print(\"Done!\")    \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Files exception handling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# [ ] The following program asks the user for a file name.\n",
    "# The file is then opened, the first line printed out, then closed.\n",
    "\n",
    "# Use exception handling to show the user a message confirming the file process was completed successfully\n",
    "# your exception handling should also deal with the cases when the file does not exist\n",
    "\n",
    "# test cases:\n",
    "# fname = text_file.txt (should display: File process was completed successfully)\n",
    "# fname = nofilehere.txt (should display: nofilehere.txt was not found)\n",
    "\n",
    "import os\n",
    "\n",
    "# ask user for a file name\n",
    "fname = input(\"Enter file name: \")\n",
    "\n",
    "# the file should be located in `parent_dir`\n",
    "fname = os.path.join(\"parent_dir\", fname)\n",
    "\n",
    "# opening text_file.txt for reading\n",
    "f = open(fname, 'r')\n",
    "print(f.readline())\n",
    "f.close()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# [ ] The following program tries to read from a file opened for writing.\n",
    "# The program will terminate before closing the file, and the file resources will not be released.\n",
    "# Use exception handling with a `finally` to make sure the file is closed\n",
    "\n",
    "# Open a text file for writing\n",
    "f = open(\"parent_dir/text_file_2.txt\", 'w')\n",
    "\n",
    "# trying to read from a file open for writing (will raise an exception)\n",
    "print(f.readline())\n",
    "\n",
    "# closing the file (will not be reached if an exception was raised)\n",
    "f.close()\n",
    "print(\"File closed\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "<font size=\"6\" color=\"#B24C00\"  face=\"verdana\"> <B>Task 3</B></font>\n",
    "\n",
    "## Raising exceptions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### User input"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# [ ] Write a program to keep prompting the user for a number from a predefined numerical tuple `valid_nums`\n",
    "# Your program should raise an exception with an appropriate message if the input is not valid\n",
    "\n",
    "valid_nums = (1, 2, 8, 16, 32, 64)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "<font size=\"6\" color=\"#B24C00\"  face=\"verdana\"> <B>Task 4</B></font>\n",
    "\n",
    "## Files\n",
    "\n",
    "**You _MUST_ run the environment setup code before running your program in every exercise in this task.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Environment setup (no coding required)\n",
    "This code segment creates a `files_exercises` directory then creates 100 text files in it. The files are named sequentially from 0 to 99. The first line of each file is a random number from 1000 to 9999. The script also creates 5 directories inside `files_exercises`, the directories are named `dir_1`, `dir_2`,...`dir_5`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Do not modify or add anything to this code segment.\n",
    "# This code segment must be run before attempting any of the tasks in this lesson.\n",
    "# It prepares the directories and files necessary to complete the tasks.\n",
    "\n",
    "import os, random, shutil\n",
    "\n",
    "# Navigate to `parent_dir` directory (if not already in it)\n",
    "current_path = os.getcwd()\n",
    "if (\"parent_dir\" in current_path):\n",
    "    nb_path = current_path.split(\"parent_dir\")[0]\n",
    "else:\n",
    "    nb_path = current_path\n",
    "print(\"Changing working dir to parent_dir\")\n",
    "os.chdir(os.path.join(nb_path,'parent_dir'))\n",
    "print(\"Current working directory:\", os.getcwd())\n",
    "\n",
    "\n",
    "# Remove the `files_exercises` directory (if it exists)\n",
    "if('files_exercises' in os.listdir()):\n",
    "    print('Removing \"files_exercises\"')\n",
    "    shutil.rmtree('files_exercises')\n",
    "    \n",
    "# Create a new directory called `files_exercises`\n",
    "print('Making \"files_exercises\"')\n",
    "os.mkdir('files_exercises')\n",
    "\n",
    "# Change the working directory to `files_exercises`\n",
    "print('Changing working directory to \"files_exercises\"')\n",
    "os.chdir('files_exercises')\n",
    "\n",
    "# Display the current working directory to verify you are in the correct location\n",
    "print(\"Current working directory:\", os.getcwd())\n",
    "\n",
    "# Create 100 text files, the first line of each file is a random number in the range [1000, 9999]\n",
    "print(\"Creating 100 text files\")\n",
    "random.seed(25000) # to get the same random numbers every time the setup runs\n",
    "for i in range(100):\n",
    "    file_name = str(i) + \".txt\"\n",
    "    f = open(file_name, 'w')\n",
    "    f.write(str(random.randint(1000, 9999)))\n",
    "    f.close()\n",
    "\n",
    "# Create 5 directories\n",
    "print(\"Creating 5 directories\")\n",
    "for i in range(1, 6):\n",
    "    os.mkdir(\"dir_\"+str(i))\n",
    "\n",
    "print(\"Environment setup completed!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Removing files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# [ ] Complete the function `delete_files` so the program deletes all the files in the `files_exercises` directory\n",
    "# Make sure the to run the environment setup code before running your own program.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Handling file exceptions\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# [ ] The following program is designed to remove all files in `files_exercises` that contain a number divisible by 3 on the first line.\n",
    "# To complete the program, you need to:\n",
    "# 1) complete the function `delete_files` as you did in a previous exercise\n",
    "# 2) iterate over all content in `file_exercises`:\n",
    "#    2.1) if an element in the directory is a file open it for reading using `with` statement\n",
    "#    2.2) read the first line in the file\n",
    "#    2.3) if the first line contains a number divisible by 3, add the file name to the `to_be_deleted` list\n",
    "#    2.4) your code should handle exception appropriately (i.e. a blank file or a file containing a string in the first line)\n",
    "# 3) make sure the to run the environment setup code before running your own program.\n",
    "\n",
    "\n",
    "# The output of your program should look like:\n",
    "'''\n",
    "Unexpected error found in 49.txt: invalid literal for int() with base 10: ''\n",
    "\n",
    "Deleting matching files:\n",
    "------------------------------\n",
    "Removing 15.txt\n",
    "Removing 16.txt\n",
    "Removing 18.txt\n",
    "Removing 19.txt\n",
    "Removing 20.txt\n",
    "Removing 23.txt\n",
    "Removing 28.txt\n",
    "Removing 35.txt\n",
    "Removing 39.txt\n",
    "Removing 40.txt\n",
    "Removing 44.txt\n",
    "Removing 46.txt\n",
    "Removing 5.txt\n",
    "Removing 51.txt\n",
    "Removing 52.txt\n",
    "Removing 54.txt\n",
    "Removing 55.txt\n",
    "Removing 58.txt\n",
    "Removing 59.txt\n",
    "Removing 65.txt\n",
    "Removing 67.txt\n",
    "Removing 68.txt\n",
    "Removing 69.txt\n",
    "Removing 71.txt\n",
    "Removing 73.txt\n",
    "Removing 77.txt\n",
    "Removing 80.txt\n",
    "Removing 81.txt\n",
    "Removing 85.txt\n",
    "Removing 87.txt\n",
    "Removing 91.txt\n",
    "Removing 94.txt\n",
    "Removing 95.txt\n",
    "Removing 96.txt\n",
    "'''\n",
    "import os\n",
    "\n",
    "def delete_files(to_be_deleted):\n",
    "    \"\"\"\n",
    "    Remove all the files listed in `to_be_deleted` and leave the directories.\n",
    "    \n",
    "    args:\n",
    "        to_be_deleted: list of paths\n",
    "    \n",
    "    returns:\n",
    "        None\n",
    "    \"\"\"\n",
    "    \n",
    "    #TODO: Copy code from previous exercise\n",
    "    pass\n",
    "\n",
    "# list the content of `files_exercises`\n",
    "print('Content of \"files_exercises\" before removing the files')\n",
    "print(os.listdir()) \n",
    "print(30 * \"-\")\n",
    "\n",
    "# clearing (49.txt) so an exception is raised below as a result of int( )\n",
    "# opening a file without doing anything clears it!\n",
    "with open('49.txt', 'w') as file: pass\n",
    "\n",
    "to_be_deleted = []\n",
    "\n",
    "#TODO: iterate over directory content and store file names containing numbers divisible by 3 in `to_be_deleted` list\n",
    "\n",
    "print()\n",
    "print(\"Deleting matching files:\")\n",
    "print(30 * \"-\")\n",
    "delete_files(to_be_deleted)\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Searching files content"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# [ ] Write a program to:\n",
    "# 1) ask the user for a number between 1000 and 9999\n",
    "# 2) test if the number matches the first line of any file in `files_directory`\n",
    "# 3) if a match was found, print the file name; otherwise, print no match is found\n",
    "# 4) your code should handle exception appropriately (i.e. a blank file or a file containing a string in the first line)\n",
    "# 5) you should use `with` statement for opening/closing files\n",
    "# 6) make sure the to run the environment setup code before running your own program.\n",
    "\n",
    "# test cases:\n",
    "# 3932, should print out: Match found in 74.txt : 3932\n",
    "# 2177, should print out: Match found in 27.txt : 2177\n",
    "# 4932, should print out: No matching files found\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "<font size=\"6\" color=\"#B24C00\"  face=\"verdana\"> <B>Task 5</B></font>\n",
    "\n",
    "## Tuple basics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Coordinates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# [ ] The tuples `x` and `y` contain the (x, y) coordinates of 10 points.\n",
    "# Write a program to create a single tuple `coordinates` that contains 10 sub-tuples of the (x, y) coordinates\n",
    "\n",
    "# The final tuple should look like:\n",
    "# ((75, 57), (77, 6), (55, 64), (93, 36), (41, 63), (62, 53), (70, 26), (30, 71), (74, 88), (97, 66))\n",
    "\n",
    "x = (75, 77, 55, 93, 41, 62, 70, 30, 74, 97)\n",
    "y = (57, 6, 64, 36, 63, 53, 26, 71, 88, 66)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Merge sorted tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# [ ] Write a program to merge the two sorted tuples T1, T2 into a larger (also sorted) tuple T\n",
    "\n",
    "# Output should be:\n",
    "#Merged sorted tuple:\n",
    "#(12, 13, 15, 20, 20, 26, 30, 37, 40, 55, 60, 68, 72, 78, 81, 84, 89, 97, 97, 100)\n",
    "\n",
    "# sorted tuples\n",
    "T1 = (15, 20, 30, 37, 55, 60, 78, 81, 84, 100)\n",
    "T2 = (12, 13, 20, 26, 40, 68, 72, 89, 97, 97)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "<font size=\"6\" color=\"#B24C00\"  face=\"verdana\"> <B>Task 6</B></font>\n",
    "\n",
    "## Tuple operations and functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Multiple function returns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# [ ] Complete the function `simple_stats` so it returns:\n",
    "# 1) The maximum number in the tuple T\n",
    "# 2) The minimum number in the tuple T\n",
    "# 3) The average of the numbers in the tuple T\n",
    "\n",
    "\n",
    "def simple_stats(T):\n",
    "    #TODO: your code goes here\n",
    "    pass\n",
    "\n",
    "T = (257, 462, 18, 369, 415, 994, 541, 752, 78, 895, 0, 576, 40, 552, 438, 605, 54, 296, 433, 986, 685, 651, 523, 855, 777, 437, 65, 360, 265, 858, 260, 819, 586, 358, 860, 250, 531, 7, 801, 259, 155, 376, 374, 828, 475, 62, 52, 184, 186, 283, 643, 86, 472, 267, 692, 750, 948, 683, 452, 770, 322, 492, 871, 360, 88, 883, 764, 288, 383, 411, 679, 90, 857, 802, 974, 403, 798, 990, 475, 260, 289, 438, 873, 779, 895, 939, 462, 469, 183, 520, 366, 267, 896, 732, 303, 754, 195, 949, 546, 180)\n",
    "\n",
    "# unpacking and displaying the returned values\n",
    "largest, smallest, average = simple_stats(T)\n",
    "print(\"Maximum number in T:\", largest)\n",
    "print(\"Minimum number in T:\", smallest)\n",
    "print(\"Average of numbers in T:\", average)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuple length"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# [ ] Complete the function `longer` to compare and return the longest of 2 tuples\n",
    "\n",
    "def longer(T1, T2):\n",
    "    \"\"\"\n",
    "    Return the longer of two tuples\n",
    "    \n",
    "    args:\n",
    "        T1: tuple of arbitrary length\n",
    "        T2: tuple of arbitrary length\n",
    "        \n",
    "    returns:\n",
    "        T1: if T1 is longer than T2\n",
    "        T2: if T2 is longer or the same length as T1\n",
    "    \"\"\"\n",
    "    #TODO: Your code goes here\n",
    "    pass\n",
    "    \n",
    "T1 = (98, 84, 71, 87, 54, 16, 70, 62, 1, 29, 66, 1, 74, 71, 68, 58, 65, 75, 74, 77, 94, 19, 46)\n",
    "T2 = (62, 30, 58, 75, 0, 61, 37, 93, 40, 33, 93, 94, 72, 27, 92, 75, 38, 70, 99, 74, 89, 8, 42, 32, 4, 60, 5)\n",
    "\n",
    "print(\"The longer tuple is:\")\n",
    "print(longer(T1, T2))\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Searching tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# [ ] Complete the function `search` so it looks for the first instance of `num` in `T`\n",
    "# The function should return 2 values:\n",
    "# 1) Boolean value indicating if num was found or not\n",
    "# 2) Index of the first instance of `num` in `T`\n",
    "\n",
    "def search(T, num):\n",
    "    \"\"\"\n",
    "    Search T for num and return the index if found; otherwise return None.\n",
    "    \n",
    "    args:\n",
    "        T: Tuple to be searched\n",
    "        num: number to use for the search\n",
    "        \n",
    "    returns:\n",
    "        found: Boolean value to indicate if the num is contained in T or not\n",
    "        i: If num is found in T return index of the first instance of num in T; otherwise, return the value `None`\n",
    "    \"\"\"\n",
    "    #TODO: Your code goes here\n",
    "    pass\n",
    "\n",
    "T = (257, 462, 18, 369, 415, 994, 541, 752, 78, 895, 0, 576, 40, 552, 438, 605, 54, 296, 433, 986, 685, 651, 523, 855, 777, 437, 65, 360, 265, 858, 260, 819, 586, 358, 860, 250, 531, 7, 801, 259, 155, 376, 374, 828, 475, 62, 52, 184, 186, 283, 643, 86, 472, 267, 692, 750, 948, 683, 452, 770, 322, 492, 871, 360, 88, 883, 764, 288, 383, 411, 679, 90, 857, 802, 974, 403, 798, 990, 475, 260, 289, 438, 873, 779, 895, 939, 462, 469, 183, 520, 366, 267, 896, 732, 303, 754, 195, 949, 546, 180)\n",
    "\n",
    "x = int(input(\"Enter a number to search for in T: \"))\n",
    "\n",
    "# unpacking returned tuple\n",
    "found, i = search(T, x)\n",
    "\n",
    "if found:\n",
    "    print(\"First instance found at index {:}\".format(i))\n",
    "else:\n",
    "    print(\"{} was not found in T\".format(x))\n",
    "    \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Splitting tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# [ ] Complete the functions `search` and `split` to slice a tuple `T` around a number `num`\n",
    "# The function should use the `search` function you developed in a previous exercise to find its index in `T`\n",
    "# If `num` is in T, you discard it and return two tuples:\n",
    "#   1) from the beginning of T till index of num\n",
    "#   2) from index+1 of num till the end of T\n",
    "# If `num` is not in T, you return:\n",
    "#   1) The whole Tuple \n",
    "#   2) The `None` value\n",
    "\n",
    "\n",
    "# Example input/output using T = (15, 20, 30, 37, 55, 60, 78, 81, 84, 100):\n",
    "\n",
    "#Enter a number around which you want to split T: 55\n",
    "#T1 = (15, 20, 30, 37)\n",
    "#T2 = (60, 78, 81, 84, 100)\n",
    "\n",
    "#Enter a number to search for in T: 400\n",
    "#T1 = (15, 20, 30, 37, 55, 60, 78, 81, 84, 100)\n",
    "#T2 = None\n",
    "\n",
    "\n",
    "\n",
    "def search(T, num):\n",
    "    \"\"\"\n",
    "    Search T for num and return the index if found; otherwise return None.\n",
    "    \n",
    "    args:\n",
    "        T: Tuple to be searched\n",
    "        num: number to use for the search\n",
    "        \n",
    "    returns:\n",
    "        found: Boolean value to indicate if the num is contained in T or not\n",
    "        i: If num is found in T return index of the first instance of num in T; otherwise, return the value `None`\n",
    "    \"\"\"\n",
    "    #TODO: Copy code from a previous exercise\n",
    "    pass\n",
    "\n",
    "def split(T, num):\n",
    "    \"\"\"\n",
    "    Split the tuple T around num (num should be discarded).\n",
    "    \n",
    "    args:\n",
    "        T: Tuple to be searched\n",
    "        num: number to use for the split\n",
    "    \n",
    "    returns:\n",
    "        T1: The first half of the tuple, from the beginning till num ( excluded).\n",
    "            If num is not in T, T1 should be the whole tuple T\n",
    "        T2: The second half of the tuple, from num (excluded) till the end.\n",
    "            If num is not in T, T2 should be the value `None`\n",
    "    \"\"\"\n",
    "    #TODO: Your code goes here\n",
    "    \n",
    "\n",
    "T = (15, 20, 30, 37, 55, 60, 78, 81, 84, 100)\n",
    "x = int(input(\"Enter a number around which you want to split T: \"))\n",
    "\n",
    "# unpacking returned tuple\n",
    "T1, T2 = split(T, x)\n",
    "\n",
    "print(\"T1 =\", T1)\n",
    "print(\"T2 =\", T2)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "<font size=\"6\" color=\"#B24C00\"  face=\"verdana\"> <B>Task 7</B></font>\n",
    "\n",
    "## Dictionary\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionary: Creating an inventory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# [ ] The `data` list contains grocery store inventory information, the list is organized into sublists where each of\n",
    "# the sublists contains: [UPC, Description, Unit Price, Quantity in Stock]\n",
    "# Use the `data` list to create an inventory dictionary with the UPC as keys and lists containing [Description, Item Price, Quantity in Stock] as values:\n",
    "# UPC (as keys): [Description, Unit Price, Quantity in Stock] (as values)\n",
    "\n",
    "# NOTE: UPC is short for (Universal Product Code), which is the number found under a barcode and identify different products in a store\n",
    "\n",
    "# The created dictionary should look like:\n",
    "# {847502: ['APPLES 1LB', 1.99, 50], 847283: ['OLIVE OIL', 10.99, 100], 839529: ['TOMATOS 1LB', 1.29, 25], 483946: ['MILK 1/2G', 3.45, 35], 493402: ['FLOUR 5LB', 2.99, 40], 485034: ['BELL PEPPERS 1LB', 1.35, 28], 828391: ['WHITE TUNA', 1.69, 100], 449023: ['CHEESE 1/2LB', 4.99, 15]}\n",
    "\n",
    "data = [[847502, \"APPLES 1LB\", 1.99, 50], [847283, \"OLIVE OIL\", 10.99, 100], [839529, \"TOMATOS 1LB\", 1.29, 25], [483946, \"MILK 1/2G\", 3.45, 35], [493402, \"FLOUR 5LB\", 2.99, 40], [485034, \"BELL PEPPERS 1LB\", 1.35, 28], [828391, \"WHITE TUNA\", 1.69, 100], [449023, \"CHEESE 1/2LB\", 4.99, 15]]\n",
    "\n",
    "#TODO: Your code goes here\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionary: Querying the inventory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter UPC number: 847283\n",
      "\n",
      "  UPC   | Description       |  Unit Price  |  Quantity \n",
      "-------------------------------------------------------\n",
      "847283  | OLIVE OIL         |        10.99 |     100.00\n"
     ]
    }
   ],
   "source": [
    "# [ ] Use the `inventory` dictionary in a program that asks the user for a UPC number then prints the item information\n",
    "# Your program should print an appropriate message if the UPC is not in the inventory\n",
    "\n",
    "# test cases:\n",
    "\n",
    "# input 1: 847283\n",
    "# output:\n",
    "'''\n",
    "  UPC   | Description       |  Unit Price  |  Quantity \n",
    "-------------------------------------------------------\n",
    "847283  | OLIVE OIL         |        10.99 |     100.00\n",
    "'''\n",
    "\n",
    "# input 2: 340344\n",
    "# output: No inventory found for 340344\n",
    "\n",
    "inventory = {847502: ['APPLES 1LB', 1.99, 50], 847283: ['OLIVE OIL', 10.99, 100], 839529: ['TOMATOS 1LB', 1.29, 25], 483946: ['MILK 1/2G', 3.45, 35], 493402: ['FLOUR 5LB', 2.99, 40], 485034: ['BELL PEPPERS 1LB', 1.35, 28], 828391: ['WHITE TUNA', 1.69, 100], 449023: ['CHEESE 1/2LB', 4.99, 15]}\n",
    "#TODO: Your code goes here\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionary: Updating/adding an item  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# [ ] Use the `inventory` dictionary in a program that asks the user for a UPC number, description, unit price, \n",
    "# quantity in stock.\n",
    "# If the item already exists in the inventory, the information is updated, \n",
    "# and your program should display a message that it is updating the entry.\n",
    "# If the item does NOT exists in the inventory, a new dictionary entry is created, \n",
    "# and your program should display a message that it is creating a new entry.\n",
    "# Use try/except in the program.\n",
    "\n",
    "\n",
    "# test cases\n",
    "\n",
    "# For an existing item\n",
    "'''\n",
    "Enter UPC number: 839529\n",
    "Enter item description: TOMATOS 1LB\n",
    "Enter unit price: 1.55\n",
    "Enter item quantity: 21\n",
    "Existing item, updating: ['TOMATOS 1LB', 1.29, 25]\n",
    "\n",
    "  UPC   | Description       |  Unit Price  |  Quantity \n",
    "-------------------------------------------------------\n",
    "839529  | TOMATOS 1LB       |         1.55 |      21.00\n",
    "'''\n",
    "\n",
    "# For a new item\n",
    "'''\n",
    "Enter UPC number: 29430\n",
    "Enter item description: ORANGE 1LB\n",
    "Enter unit price: 0.99\n",
    "Enter item quantity: 40\n",
    "New item, creating ORANGE 1LB\n",
    "\n",
    "  UPC   | Description       |  Unit Price  |  Quantity \n",
    "-------------------------------------------------------\n",
    "29430   | ORANGE 1LB        |         0.99 |      40.00\n",
    "'''\n",
    "\n",
    "inventory = {847502: ['APPLES 1LB', 1.99, 50], 847283: ['OLIVE OIL', 10.99, 100], 839529: ['TOMATOS 1LB', 1.29, 25], 483946: ['MILK 1/2G', 3.45, 35], 493402: ['FLOUR 5LB', 2.99, 40], 485034: ['BELL PEPPERS 1LB', 1.35, 28], 828391: ['WHITE TUNA', 1.69, 100], 449023: ['CHEESE 1/2LB', 4.99, 15]}\n",
    "#TODO: Your code goes here\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Inventory printout"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# [ ] Write a program to display the current inventory information as follow\n",
    "# Note the items are sorted by UPC\n",
    "\n",
    "'''\n",
    "  UPC   | Description       |  Unit Price  |  Quantity \n",
    "-------------------------------------------------------\n",
    "449023  | CHEESE 1/2LB      |         4.99 |      15.00\n",
    "483946  | MILK 1/2G         |         3.45 |      35.00\n",
    "485034  | BELL PEPPERS 1LB  |         1.35 |      28.00\n",
    "493402  | FLOUR 5LB         |         2.99 |      40.00\n",
    "828391  | WHITE TUNA        |         1.69 |     100.00\n",
    "839529  | TOMATOS 1LB       |         1.29 |      25.00\n",
    "847283  | OLIVE OIL         |        10.99 |     100.00\n",
    "847502  | APPLES 1LB        |         1.99 |      50.00\n",
    "'''\n",
    "inventory = {847502: ['APPLES 1LB', 1.99, 50], 847283: ['OLIVE OIL', 10.99, 100], 839529: ['TOMATOS 1LB', 1.29, 25], 483946: ['MILK 1/2G', 3.45, 35], 493402: ['FLOUR 5LB', 2.99, 40], 485034: ['BELL PEPPERS 1LB', 1.35, 28], 828391: ['WHITE TUNA', 1.69, 100], 449023: ['CHEESE 1/2LB', 4.99, 15]}\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Inventory value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# [ ] Write a program to calculate and display the total value and the number of items in an inventory.\n",
    "# The total value can by calculated by multiplying each unit price by the quantity, \n",
    "# then adding up the answers for all items in the inventory.\n",
    "\n",
    "\n",
    "inventory = {847502: ['APPLES 1LB', 1.99, 50], 847283: ['OLIVE OIL', 10.99, 100], 839529: ['TOMATOS 1LB', 1.29, 25], 483946: ['MILK 1/2G', 3.45, 35], 493402: ['FLOUR 5LB', 2.99, 40], 485034: ['BELL PEPPERS 1LB', 1.35, 28], 828391: ['WHITE TUNA', 1.69, 100], 449023: ['CHEESE 1/2LB', 4.99, 15]}\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "<font size=\"6\" color=\"#B24C00\"  face=\"verdana\"> <B>Module 3 Project</B></font>\n",
    "\n",
    "## Seattle weather\n",
    "\n",
    "In this project, you will use real weather data collected by the National Oceanic and Atmospheric Administration (NOAA) at Seattle Tacoma International Airport. The data contains the maximum temperature, minimum temperature, and precipitation for 25561 days from January 1, 1948 till December 24, 2017. The data is in the public domain and can be downloaded from https://www.ncdc.noaa.gov/cdo-web/datasets/GHCND/stations/GHCND%3aUSW00024233/detail.  \n",
    "\n",
    "The values DATE,PRCP,TMAX,TMIN in the data file are defined as below:  \n",
    "- DATE - date of the weather reading  \n",
    "- PRCP - precipitation  \n",
    "- TMAX - Maximum Temperature  \n",
    "- TMIN - Minimum Temperature  \n",
    "\n",
    "**Tip**: read function `# TODO` comments carefully, and use the *HINTS*!\n",
    "\n",
    "**The program can be adapted to weather information of other cities as long as the CSV file format is maintained without change.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# [ ] In this project, you will read a CSV file containing about 25K lines of weather information \n",
    "# and store the information in a Python dictionary. You will then use the dictionary to find out\n",
    "# the hottest, coldest, rainiest years and so on...\n",
    "# You will see that the dictionary's search optimization algorithms will allow you to explore \n",
    "# this large dataset without any noticeable delays.\n",
    "\n",
    "# The logic of the program is in the `main` function, read it before writing any code.\n",
    "\n",
    "# Use the description and examples under each of the following functions to implement them:\n",
    "# 1) convert_file(file_path)\n",
    "# 2) add_rainy(weather)\n",
    "# 3) consolidate(weather)\n",
    "# 4) year_info(year, yearly_weather)\n",
    "# 5) hottest(yearly_weather)\n",
    "# 6) coldest(yearly_weather)\n",
    "# 7) rainiest_days(yearly_weather)\n",
    "# 8) highest_prcp(yearly_weather)\n",
    "\n",
    "\n",
    "from datetime import date, datetime\n",
    "from IPython.display import clear_output #to clear the output (specific to Jupyter notebooks and ipython)\n",
    "\n",
    "def convert_file(file_path):\n",
    "    \"\"\"\n",
    "    Convert CSV file to a Python dictionary.\n",
    "    \n",
    "    The CSV file contains daily weather information arranged in rows,\n",
    "    the rows contain  (date, precipitation (inches), maximum temperature (F), minimum temperature (F)) in order.\n",
    "    First line in CSV file is a header (DATE, PRCP, TMAX, TMIN), the rest contain the weather data.\n",
    "    \n",
    "    The function should read the data in the file and generate a dictionary where:\n",
    "        1) keys are date objects (from the datetime module), using the daily date info in the file\n",
    "        2) values are lists containing [TMAX, TMIN, PRCP] in order\n",
    "        \n",
    "    args:\n",
    "        file_path: path to the CSV file\n",
    "    \n",
    "    returns:\n",
    "        weather: the generated dictionary using date objects as keys and lists of weather info as values\n",
    "        \n",
    "    examples:\n",
    "    Input CSV file:\n",
    "    DATE,PRCP,TMAX,TMIN\n",
    "    12/10/2017,0,49,34\n",
    "    12/11/2017,0,49,29\n",
    "    12/12/2017,0,46,32\n",
    "    12/13/2017,0,48,34\n",
    "    12/14/2017,0,50,36\n",
    "    12/15/2017,0.06,43,37\n",
    "    12/16/2017,0.14,45,37\n",
    "    12/17/2017,0.03,50,42\n",
    "    12/18/2017,0.7,49,41\n",
    "    12/19/2017,1,50,40\n",
    "    12/20/2017,0.13,49,32\n",
    "    12/21/2017,0.01,41,29\n",
    "    12/22/2017,0.09,40,35\n",
    "    12/23/2017,0,38,29\n",
    "    12/24/2017,0.12,38,28\n",
    "\n",
    "    Output dictionary (weather):\n",
    "    {datetime.date(2017, 12, 10): [49, 34, 0.0],\n",
    "     datetime.date(2017, 12, 11): [49, 29, 0.0],\n",
    "     datetime.date(2017, 12, 12): [46, 32, 0.0],\n",
    "     datetime.date(2017, 12, 13): [48, 34, 0.0],\n",
    "     datetime.date(2017, 12, 14): [50, 36, 0.0],\n",
    "     datetime.date(2017, 12, 15): [43, 37, 0.06],\n",
    "     datetime.date(2017, 12, 16): [45, 37, 0.14],\n",
    "     datetime.date(2017, 12, 17): [50, 42, 0.03],\n",
    "     datetime.date(2017, 12, 18): [49, 41, 0.7],\n",
    "     datetime.date(2017, 12, 19): [50, 40, 1.0],\n",
    "     datetime.date(2017, 12, 20): [49, 32, 0.13],\n",
    "     datetime.date(2017, 12, 21): [41, 29, 0.01],\n",
    "     datetime.date(2017, 12, 22): [40, 35, 0.09],\n",
    "     datetime.date(2017, 12, 23): [38, 29, 0.0],\n",
    "     datetime.date(2017, 12, 24): [38, 28, 0.12]}\n",
    "    \"\"\"\n",
    "    #TODO: Your code goes here, see hints below\n",
    "    \n",
    "    # open the file for reading (HINT: use `with` statement)\n",
    "\n",
    "    # ignore the first header line (DATE, PRCP, TMAX, TMIN)\n",
    "\n",
    "    # remove newline characters from end of each line (HINT: use str.rstrip())\n",
    "\n",
    "    # split line into a list (HINT: use str.split(','))\n",
    "\n",
    "    # create the date object from the first list element \n",
    "    # HINT: use the date_creater(date_string) function provided below\n",
    "\n",
    "    # read the weather related variables\n",
    "    # precipitation\n",
    "    # maximum temperature\n",
    "    # minimum temperature\n",
    "    \n",
    "    # create dictionary key:value pair\n",
    "    pass\n",
    "\n",
    "def add_rainy(weather):\n",
    "    \"\"\"\n",
    "    Emphasize rainy days using Boolean values.\n",
    "    \n",
    "    Modify the weather dictionary by adding another Boolean element to the values' lists. \n",
    "    If precipitation is observed on a day (more than 0\"), the associated list is appended by True.\n",
    "    If precipitation is not observed (0\"), the associated list is appended by False.\n",
    "    \n",
    "    args:\n",
    "        weather: dictionary, keys are date objects and values are lists [TMAX, TMIN, PRCP]\n",
    "        \n",
    "    returns:\n",
    "        None: the weather dictionary is modified directly, keys are date objects and values are lists [TMAX, TMIN, PRCP, RAINY_DAY]\n",
    "        \n",
    "    examples:\n",
    "    Input weather dictionary:\n",
    "    {datetime.date(2017, 12, 10): [49, 34, 0.0],\n",
    "     datetime.date(2017, 12, 11): [49, 29, 0.0],\n",
    "     datetime.date(2017, 12, 12): [46, 32, 0.0],\n",
    "     datetime.date(2017, 12, 13): [48, 34, 0.0],\n",
    "     datetime.date(2017, 12, 14): [50, 36, 0.0],\n",
    "     datetime.date(2017, 12, 15): [43, 37, 0.06],\n",
    "     datetime.date(2017, 12, 16): [45, 37, 0.14],\n",
    "     datetime.date(2017, 12, 17): [50, 42, 0.03],\n",
    "     datetime.date(2017, 12, 18): [49, 41, 0.7],\n",
    "     datetime.date(2017, 12, 19): [50, 40, 1.0],\n",
    "     datetime.date(2017, 12, 20): [49, 32, 0.13],\n",
    "     datetime.date(2017, 12, 21): [41, 29, 0.01],\n",
    "     datetime.date(2017, 12, 22): [40, 35, 0.09],\n",
    "     datetime.date(2017, 12, 23): [38, 29, 0.0],\n",
    "     datetime.date(2017, 12, 24): [38, 28, 0.12]}\n",
    "    \n",
    "    Updated weather dictionary with Boolean values\n",
    "    {datetime.date(2017, 12, 10): [49, 34, 0.0, False],\n",
    "     datetime.date(2017, 12, 11): [49, 29, 0.0, False],\n",
    "     datetime.date(2017, 12, 12): [46, 32, 0.0, False],\n",
    "     datetime.date(2017, 12, 13): [48, 34, 0.0, False],\n",
    "     datetime.date(2017, 12, 14): [50, 36, 0.0, False],\n",
    "     datetime.date(2017, 12, 15): [43, 37, 0.06, True],\n",
    "     datetime.date(2017, 12, 16): [45, 37, 0.14, True],\n",
    "     datetime.date(2017, 12, 17): [50, 42, 0.03, True],\n",
    "     datetime.date(2017, 12, 18): [49, 41, 0.7, True],\n",
    "     datetime.date(2017, 12, 19): [50, 40, 1.0, True],\n",
    "     datetime.date(2017, 12, 20): [49, 32, 0.13, True],\n",
    "     datetime.date(2017, 12, 21): [41, 29, 0.01, True],\n",
    "     datetime.date(2017, 12, 22): [40, 35, 0.09, True],\n",
    "     datetime.date(2017, 12, 23): [38, 29, 0.0, False],\n",
    "     datetime.date(2017, 12, 24): [38, 28, 0.12, True]}\n",
    "    \"\"\"\n",
    "    #TODO: Your code goes here\n",
    "    pass\n",
    "\n",
    "def consolidate(weather):\n",
    "    \"\"\"\n",
    "    Consolidate the daily weather information by year.\n",
    "    \n",
    "    Use the weather dictionary to generate a new consolidated dictionary (yearly_weather). \n",
    "    The new dictionary uses years as keys, and the associated values are lists containing (in order):\n",
    "        1) The average of the highest recorded temperatures in the year (AVG_TMAX)\n",
    "        2) The average of the lowest recorded temperatures in the year (AVG_TMIN)\n",
    "        3) The total recorded precipitation in the year (TOTAL_PRCP)\n",
    "        4) The total number of rainy days in the year (TOTAL_RAINY_DAYS)\n",
    "        5) The number of recorded days (TOTAL_DAYS). \n",
    "           This element is necessary to account for days where the station breaks (missing recordings),\n",
    "           or if the year hasn't finished yet.\n",
    "           \n",
    "    args: \n",
    "        weather: dictionary, keys are date objects and values are lists [TMAX, TMIN, PRCP, RAINY_DAY]\n",
    "    \n",
    "    returns:\n",
    "        yearly_weather: consolidated dictionary, keys are years (int), values are lists \n",
    "                        [AVG_TMAX, AVG_TMIN, TOTAL_PRCP, TOTAL_RAINY_DAYS, TOTAL_DAYS]\n",
    "                        \n",
    "    examples:\n",
    "    Input weather dictionary:\n",
    "    {datetime.date(2017, 12, 10): [49, 34, 0.0, False],\n",
    "     datetime.date(2017, 12, 11): [49, 29, 0.0, False],\n",
    "     datetime.date(2017, 12, 12): [46, 32, 0.0, False],\n",
    "     datetime.date(2017, 12, 13): [48, 34, 0.0, False],\n",
    "     datetime.date(2017, 12, 14): [50, 36, 0.0, False],\n",
    "     datetime.date(2017, 12, 15): [43, 37, 0.06, True],\n",
    "     datetime.date(2017, 12, 16): [45, 37, 0.14, True],\n",
    "     datetime.date(2017, 12, 17): [50, 42, 0.03, True],\n",
    "     datetime.date(2017, 12, 18): [49, 41, 0.7, True],\n",
    "     datetime.date(2017, 12, 19): [50, 40, 1.0, True],\n",
    "     datetime.date(2017, 12, 20): [49, 32, 0.13, True],\n",
    "     datetime.date(2017, 12, 21): [41, 29, 0.01, True],\n",
    "     datetime.date(2017, 12, 22): [40, 35, 0.09, True],\n",
    "     datetime.date(2017, 12, 23): [38, 29, 0.0, False],\n",
    "     datetime.date(2017, 12, 24): [38, 28, 0.12, True]}\n",
    "     \n",
    "     Output yearly_weather dictionary:\n",
    "     {2017: [45.666666666666664, 34.333333333333336, 2.28, 9, 15]}\n",
    "    \"\"\"    \n",
    "    #TODO: Your code goes here\n",
    "    pass\n",
    "\n",
    "def year_info(year, yearly_weather):\n",
    "    \"\"\"\n",
    "    Convert the year's weather information to a formatted string.\n",
    "    \n",
    "    Look for the weather information of `year` in the `yearly_weather` dictionary.\n",
    "    If it exists, convert the information list into a formatted string:\n",
    "            YEAR | AVG_TMAX | AVG_TMIN | TOTAL_PRCP | TOTAL_RAINY_DAYS | TOTAL_DAYS\n",
    "    If it does not exist, the formatted string should be:\n",
    "            N/A  |    N/A   |    N/A   |     N/A    |        N/A       |    N/A   \n",
    "    \n",
    "    args:\n",
    "        year: int value to look for in the yearly_weather dictionary\n",
    "        \n",
    "        yearly_weather: consolidated dictionary, keys are years (int), values are lists \n",
    "                        [AVG_TMAX, AVG_TMIN, TOTAL_PRCP, TOTAL_RAINY_DAYS, TOTAL_DAYS] \n",
    "    \n",
    "    returns:\n",
    "        formatted_string: containing the year's weather information\n",
    "                          \n",
    "    examples:\n",
    "    Input yearly weather dictionary:\n",
    "    {2017: [45.666666666666664, 34.333333333333336, 2.28, 9, 15]}\n",
    "    \n",
    "    Output formatted string:\n",
    "    == year_info(2017, yearly_weather) == (contained in the dictionary)\n",
    "    ' 2017 |         45.67 |        34.33 |   2.28\" |            9 |             15 '\n",
    "    \n",
    "    == year_info(2055, yearly_weather) == (not contained in the dictionary)\n",
    "    ' N/A  |      N/A      |     N/A      |   N/A   |     N/A      |      N/A       '\n",
    "    \"\"\"\n",
    "    #TODO: Your code goes here\n",
    "    pass\n",
    "\n",
    "def hottest(yearly_weather):\n",
    "    \"\"\"\n",
    "    Find the hottest year in yearly_weather.\n",
    "    \n",
    "    Look through all the years in the yearly_weather dictionary and return the year with \n",
    "    the highest average maximum temperature (highest AVG_TMAX)\n",
    "    \n",
    "    args:\n",
    "        yearly_weather: consolidated dictionary, keys are years (int), values are lists \n",
    "                        [AVG_TMAX, AVG_TMIN, TOTAL_PRCP, TOTAL_RAINY_DAYS, TOTAL_DAYS] \n",
    "    \n",
    "    returns:\n",
    "        hottest_year: the year with the highest maximum temperature average (AVG_TMAX)\n",
    "    \"\"\"\n",
    "    #TODO: Your code goes here\n",
    "    pass\n",
    "\n",
    "def coldest(yearly_weather):\n",
    "    \"\"\"\n",
    "    Find the coldest year in yearly_weather.\n",
    "    \n",
    "    Look through all the years in the yearly_weather dictionary and return the year with \n",
    "    the lowest average minimum temperature (lowest AVG_TMIN)\n",
    "    \n",
    "    args:\n",
    "        yearly_weather: consolidated dictionary, keys are years (int), values are lists \n",
    "                        [AVG_TMAX, AVG_TMIN, TOTAL_PRCP, TOTAL_RAINY_DAYS, TOTAL_DAYS] \n",
    "    \n",
    "    returns:\n",
    "        coldest_year: the year with the lowest minimum temperature average (AVG_TMIN)\n",
    "    \"\"\"\n",
    "    #TODO: Your code goes here\n",
    "    pass\n",
    "\n",
    "def rainiest_days(yearly_weather):\n",
    "    \"\"\"\n",
    "    Find the year with the largest number of rainy days in yearly_weather.\n",
    "    \n",
    "    Look through all the years in the yearly_weather dictionary and return the year with \n",
    "    the largest TOTAL_RAINY_DAYS\n",
    "    \n",
    "    args:\n",
    "        yearly_weather: consolidated dictionary, keys are years (int), values are lists \n",
    "                        [AVG_TMAX, AVG_TMIN, TOTAL_PRCP, TOTAL_RAINY_DAYS, TOTAL_DAYS] \n",
    "    \n",
    "    returns:\n",
    "        rainiest_year: the year with the largest number of rainy days\n",
    "    \"\"\"\n",
    "    #TODO: Your code goes here\n",
    "    pass\n",
    "\n",
    "def highest_prcp(yearly_weather):\n",
    "    \"\"\"\n",
    "    Find the year with the highest total precipitation in yearly_weather.\n",
    "    \n",
    "    Look through all the years in the yearly_weather dictionary and return the year with \n",
    "    the largest TOTAL_PRCP\n",
    "    \n",
    "    args:\n",
    "        yearly_weather: consolidated dictionary, keys are years (int), values are lists \n",
    "                        [AVG_TMAX, AVG_TMIN, TOTAL_PRCP, TOTAL_RAINY_DAYS, TOTAL_DAYS] \n",
    "    \n",
    "    returns:\n",
    "        rainiest_year: the year with the highest total precipitation\n",
    "    \"\"\"\n",
    "    #TODO: Your code goes here\n",
    "    pass\n",
    "\n",
    "def date_creater(date_string):\n",
    "    \"\"\"Convert the date_string (formatted as m/d/yyyy) to a date object.\"\"\"\n",
    "    d = datetime.strptime(date_string, \"%m/%d/%Y\")\n",
    "    return d.date()\n",
    "\n",
    "def dashes(count):\n",
    "    \"\"\"Print a fancy line of `count` dashes\"\"\"\n",
    "    print(\"o\" + count *'-' + \"o\")\n",
    "\n",
    "def page_header(title):\n",
    "    \"\"\"Print a page header with a title surrounded by dashes\"\"\"\n",
    "    dashes(78)\n",
    "    print(\"|{:^78s}|\".format(title))\n",
    "    dashes(78)\n",
    "\n",
    "def table_header():\n",
    "    \"\"\"Print the first row in a table  (header row)\"\"\"\n",
    "    print()\n",
    "    print(' {0:^4s} | {1:^13s} | {2:^12s} | {3:^7s} | {4:^12s} | {5:^14s} '.format(\"Year\", \"Avg High Temp\", \"Avg Low Temp\", \"Percip\", \"# Rainy days\", \"# Recorded days\"))\n",
    "    dashes(78)\n",
    "    \n",
    "def display(title, years, yearly_weather):\n",
    "    \"\"\"Print a page with a header, title, and the weather information of all years as found in yearly_weather\"\"\"\n",
    "    clear_output()\n",
    "    page_header(title)\n",
    "    table_header()\n",
    "    \n",
    "    # if years contain a single int, convert to a single item list\n",
    "    if type(years) is not list: years = [years]\n",
    "    \n",
    "    # print weather information for all years\n",
    "    for year in years:\n",
    "        print(year_info(year, yearly_weather)) \n",
    "        \n",
    "    # display this page till you go back to the main menu\n",
    "    while True:\n",
    "        m = input(\"Return to main menu [y/n]?\")\n",
    "        if m in 'yesYesYES':\n",
    "            break\n",
    "            \n",
    "\n",
    "def main():\n",
    "    # convert the data in the (csv) file into a Python dictionary\n",
    "    weather = convert_file(\"data/seattle_weather.csv\")\n",
    "    \n",
    "    # highlight rainy days by adding a Boolean entry to the dictionary's values\n",
    "    add_rainy(weather)\n",
    "    \n",
    "    # consolidate the weather data by year then store the result in a new dictionary\n",
    "    yearly_weather = consolidate(weather)\n",
    "    \n",
    "    # earliest and latest years on record\n",
    "    min_year = min(yearly_weather)\n",
    "    max_year = max(yearly_weather)\n",
    "    \n",
    "    # menus functionality\n",
    "    while True:\n",
    "        clear_output()\n",
    "\n",
    "        # display header\n",
    "        page_header(\"Weather Records\")\n",
    "\n",
    "        # display main menu\n",
    "        print()\n",
    "        print(\"Main Menu (choose an option to display):\\n\")\n",
    "        print(\"1. Summary of a certain year\")\n",
    "        print(\"2. All years summary table\")\n",
    "        print(\"3. Hottest year on record\")\n",
    "        print(\"4. Coldest year on record\")\n",
    "        print(\"5. Year with most rainy days\")\n",
    "        print(\"6. Year with the highest precipitation\")\n",
    "        print(\"7. Quit\")\n",
    "        print()\n",
    "\n",
    "        # display footer with user input message\n",
    "        dashes(78)\n",
    "        while True:\n",
    "            try:\n",
    "                option = input(\"Select an option (1, 7): \")\n",
    "                option = int(option)\n",
    "                if 1 <= option <= 7:\n",
    "                    break # break the user input loop only, main loop does NOT break\n",
    "            except ValueError:\n",
    "                print(\"Cannot convert {:} to int\".format(type(option)))\n",
    "        \n",
    "        \n",
    "        # execute relevant function\n",
    "        # 1. Summary of a certain year\n",
    "        if option == 1:\n",
    "            # ask the user for a valid year\n",
    "            while True:\n",
    "                try:\n",
    "                    year = input(\"Enter a year ({} - {})\".format(min_year, max_year))\n",
    "                    year = int(year)\n",
    "                    if min_year <= year <= max_year:\n",
    "                        break\n",
    "                except ValueError:\n",
    "                    print(\"Cannot convert {:} to int\".format(type(option)))\n",
    "            display(\"Year Summary\", year, yearly_weather)\n",
    "\n",
    "        # 2. All years summary table \n",
    "        elif option == 2:\n",
    "            years = list(sorted(yearly_weather))\n",
    "            display(\"Tabular Summary\", years, yearly_weather)\n",
    "       \n",
    "        # 3. Hottest year on record\n",
    "        elif option == 3:\n",
    "            year = hottest(yearly_weather)\n",
    "            display(\"Hottest year on record\", year, yearly_weather)\n",
    "            \n",
    "        # 4. Coldest year on record   \n",
    "        elif option == 4:\n",
    "            year = coldest(yearly_weather)\n",
    "            display(\"Coldest year on record\", year, yearly_weather)\n",
    "            \n",
    "        # 5. Year with most rainy days    \n",
    "        elif option == 5:\n",
    "            year = rainiest_days(yearly_weather)\n",
    "            display(\"Year with most rainy days\", year, yearly_weather)\n",
    "        \n",
    "        # 6. Year with the highest precipitation\n",
    "        elif option == 6:\n",
    "            year = highest_prcp(yearly_weather)\n",
    "            display(\"Year with the highest precipitation\", year, yearly_weather)\n",
    "            \n",
    "        # 7. Quit    \n",
    "        elif option == 7:\n",
    "            clear_output()\n",
    "            break\n",
    "    \n",
    "\n",
    "# Run the program    \n",
    "main()\n",
    "\n",
    "\n"
   ]
  }
 ],
 "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.5.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}