Exercise-4-problem-3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "5eaafb6fc0d8c380c4b03558601a807f",
     "grade": false,
     "grade_id": "cell-db10a919018a5c73",
     "locked": true,
     "schema_version": 3,
     "solution": false
    }
   },
   "source": [
    "## Problem 3 - Applying the classifier (*4 points*)\n",
    "\n",
    "Finally, we can bring together the pieces that we have created in problems 1 and 2. Here, your aim is to take\n",
    "advantage of your new functions and sort a dataset of temperatures in Fahrenheit into four different classes.\n",
    "\n",
    "**Notice**: Closely follow the instructions! For example, you should be sure to use **exactly** the same variable, function, and parameter names as stated in the instructions because your answers will be automatically graded, and the tests that grade your answers rely on following the same formatting or variable naming as in the instructions. Also, please do not copy/paste existing code cells. You can add cells if you like, but copying and pasting can also cause the automatic tests to fail.\n",
    "\n",
    "**Your score on this problem will be based on following criteria:**\n",
    "\n",
    "- Creating a new **script** file called `temp_functions.py` with the functions that you wrote in Problems 1 and 2\n",
    "- Add a docstring to the script file\n",
    "- Converting and classifying the list of temperatures in Part 2\n",
    "- Storing the number of temperatures in each class in the specified variables\n",
    "- Answering some questions at the end of this problem\n",
    "- Uploading your notebook to your GitHub repository for this week's exercise"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "4c048eaf5c1dd24a14204d3032eae961",
     "grade": false,
     "grade_id": "cell-6a4973fcfb50801a",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### Part 1: Creating a script file (1 point)\n",
    "\n",
    "For this part you should\n",
    "\n",
    "- Create a new **script** file called `temp_functions.py` in your `exercise-4-username` directory as we saw in the Lesson 4 materials. Copy and paste the functions that you wrote in Problems 1 and 2 into that script file (i.e., the `fahr_to_celsius` and `temp_classifier` functions)\n",
    "- Add a docstring to the script file (in addition to the separate docstrings in the functions)\n",
    "- Save the script file (CTRL + S) and continue working in **this** Notebook (i.e., `Exercise-4-problem-3.ipynb`)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "60d0a4147b49e62e90a617c207861002",
     "grade": false,
     "grade_id": "cell-4f1cb14312eab537",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### Part 2: Convert Fahrenheit temperatures to Celsius (3 points)\n",
    "\n",
    "For this part you should\n",
    "\n",
    "1. Store the Fahrenheit temperatures below into the list `temp_data` (just execute the existing code cell below)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "527c7a80fc38eb978791e1087bb92b3a",
     "grade": false,
     "grade_id": "data",
     "locked": true,
     "schema_version": 3,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "# List of half-hourly temperature values (in degrees Fahrenheit) for one week\n",
    "temp_data =  [19, 21, 21, 21, 23, 23, 23, 21, 19, 21, 19, 21, 23, 27, 27, 28, 30, 30, 32, 32, 32, 32, \n",
    "              34, 34, 34, 36, 36, 36, 36, 36, 36, 34, 34, 34, 34, 34, 34, 32, 30, 30, 30, 28, 28, 27,\n",
    "              27, 27, 23, 23, 21, 21, 21, 19, 19, 19, 18, 18, 21, 27, 28, 30, 32, 34, 36, 37, 37, 37, \n",
    "              39, 39, 39, 39, 39, 39, 41, 41, 41, 41, 41, 39, 39, 37, 37, 36, 36, 34, 34, 32, 30, 30,\n",
    "              28, 27, 27, 25, 23, 23, 21, 21, 19, 19, 19, 18, 18, 18, 21, 25, 27, 28, 34, 34, 41, 37, \n",
    "              37, 39, 39, 39, 39, 41, 41, 39, 39, 39, 39, 39, 41, 39, 39, 39, 37, 36, 34, 32, 28, 28,\n",
    "              27, 25, 25, 25, 23, 23, 23, 23, 21, 21, 21, 21, 19, 21, 19, 21, 21, 19, 21, 27, 28, 32,\n",
    "              36, 36, 37, 39, 39, 39, 39, 39, 41, 41, 41, 41, 41, 41, 41, 41, 41, 39, 37, 36, 36, 34,\n",
    "              32, 30, 28, 28, 27, 27, 25, 25, 23, 23, 23, 21, 21, 21, 19, 19, 19, 19, 19, 19, 21, 23,\n",
    "              23, 23, 25, 27, 30, 36, 37, 37, 39, 39, 41, 41, 41, 39, 39, 41, 43, 43, 43, 43, 43, 43,\n",
    "              43, 43, 43, 39, 37, 37, 37, 36, 36, 36, 36, 34, 32, 32, 32, 32, 30, 30, 28, 28, 28, 27,\n",
    "              27, 27, 27, 25, 27, 27, 27, 28, 28, 28, 30, 32, 32, 32, 34, 34, 36, 36, 36, 37, 37, 37,\n",
    "              37, 37, 37, 37, 37, 37, 36, 34, 30, 30, 27, 27, 25, 25, 23, 21, 21, 21, 21, 19, 19, 19,\n",
    "              19, 19, 18, 18, 18, 18, 18, 19, 23, 27, 30, 32, 32, 32, 32, 32, 32, 34, 34, 34, 34, 34,\n",
    "              36, 36, 36, 36, 36, 32, 32, 32, 32, 32, 32, 32, 32, 30, 30, 30, 30, 30, 30, 30, 30, 30,\n",
    "              30, 30, 30, 30, 28, 28]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "29b8a0fd698f24a4eeb2fa97f9067c61",
     "grade": false,
     "grade_id": "cell-2affd0ad8ec6bc82",
     "locked": true,
     "schema_version": 3,
     "solution": false
    }
   },
   "source": [
    "#### Part 2 (continues)\n",
    "\n",
    "2. Import the `fahr_to_celsius` and `temp_classifier` functions from your `temp_functions.py` \n",
    "3. Create an empty list called `temp_classes` (which will be filled with temperature class numbers later)\n",
    "4. **Convert the Fahrenheit temperatures** in the `temp_data` list into Celsius and **classify the Celsius temperatures** using the importend functions. The output should be stored in the `temp_classes` list\n",
    " \n",
    "   **You can do the temperature conversion and classification inside one for loop:**\n",
    "\n",
    "    - Iterate over the list of Fahrenheit temperatures (create a `for` loop), and inside the loop:\n",
    "\n",
    "        1. Create a new variable called `temp_celsius` in which you should assign the temperature in Celsius using the `fahr_to_celsius` function to convert the Fahrenheit temperature into Celsius.\n",
    "        2. Create a new variable called `temp_class` in which you should assign the temperature class number (0, 1, 2, or 3) using the `temp_classifier` function\n",
    "        3. Add the `temp_class` value to the `temp_classes` list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "8133a38c76a2027a71051d147731fa9a",
     "grade": false,
     "grade_id": "problem_3_ag_p2_functions_usage",
     "locked": false,
     "schema_version": 3,
     "solution": true
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0]\n"
     ]
    }
   ],
   "source": [
    "# YOUR CODE HERE\n",
    "from temp_functions import fahr_to_celsius\n",
    "from temp_functions import temp_classifier \n",
    "\n",
    "temp_classes = []\n",
    "\n",
    "for temp in temp_data:\n",
    "    temp_celsius = fahr_to_celsius(temp)\n",
    "    temp_class = temp_classifier(temp_celsius)\n",
    "    temp_classes.append(temp_class)\n",
    "    \n",
    "print(temp_classes)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "fe04316a33798cc0a0ecb1427b6dd93d",
     "grade": false,
     "grade_id": "cell-aac56115e51f1ecd",
     "locked": true,
     "schema_version": 3,
     "solution": false
    }
   },
   "source": [
    "#### Part 2 (continues)\n",
    "\n",
    "6. Calculate how many temperatures there are in each temperature class:\n",
    "\n",
    "    1. Create four variables called `zeros`, `ones`, `twos`, and `threes` \n",
    "    2. Count and assign to each variable how many times values 0, 1, 2, and 3 are present in the `temp_classes` list and print out the results below. In other words, assign the value of how many time `0` is in the list to the variable `zeros`, and so on. \n",
    "  \n",
    "**TIP**: You might want to consider using a [**count()** function](https://www.tutorialspoint.com/python3/list_count.htm) OR a for loop for this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "137\n",
      "114\n"
     ]
    }
   ],
   "source": [
    "# 1. How many 0 values exist in the temp_classes list?\n",
    "zeros = temp_classes.count(0)\n",
    "print(zeros)\n",
    "# 2. How many 1 values exist in the temp_classes list?\n",
    "ones = temp_classes.count(1)\n",
    "# 3. How many 2 values exist in the temp_classes list?\n",
    "twos = temp_classes.count(2)\n",
    "# 4. How many 3 values exist in the temp_classes list?\n",
    "threes = temp_classes.count(3)\n",
    "print(twos)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "ddd25e715a7fbfc0d6b963598591c849",
     "grade": false,
     "grade_id": "cell-79b5c140053f3880",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "### Problem 3 tests\n",
    "\n",
    "Run the code cells below to check your answer. Note that you are not able to modify the test cells. Your solution is on the right track if you don't see any errors when running these code cells."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "118544a6b7b7cdcf717650653a093169",
     "grade": true,
     "grade_id": "problem_3_ag_p2_functions_usage_test1",
     "locked": true,
     "points": 0.5,
     "schema_version": 3,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "import inspect\n",
    "\n",
    "# Check that functions are in the namespace\n",
    "assert inspect.isfunction(fahr_to_celsius)\n",
    "assert inspect.isfunction(temp_classifier)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "e3130bde97d086a2c7918087b274234c",
     "grade": true,
     "grade_id": "problem_3_ag_p2_functions_usage_test2",
     "locked": true,
     "points": 0.5,
     "schema_version": 3,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "# Check that variable has been created\n",
    "assert 'temp_celsius' in locals()\n",
    "assert 'temp_class' in locals()\n",
    "assert 'temp_classes' in locals()\n",
    "\n",
    "# Check that temp_classes is a list\n",
    "assert type(temp_classes) == list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "a768a73d41e0c9fcbd5a6d99b63cb381",
     "grade": true,
     "grade_id": "problem_3_ag_p2_functions_usage_test3",
     "locked": true,
     "points": 0.5,
     "schema_version": 3,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "# Check that the functions have a single parameter\n",
    "t_params = list(inspect.signature(temp_classifier).parameters.keys())\n",
    "f_params = list(inspect.signature(fahr_to_celsius).parameters.keys())\n",
    "assert len(t_params) == 1\n",
    "assert len(f_params) == 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Check that required variables exists and print their value (check manually that the answers make sense!):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "ff916942e233175aa7f97f9d22aae0a0",
     "grade": true,
     "grade_id": "problem_3_ag_p2_functions_usage_test4",
     "locked": true,
     "points": 0.5,
     "schema_version": 3,
     "solution": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "137\n"
     ]
    }
   ],
   "source": [
    "# Check the variable \"zeros\" \n",
    "assert 'zeros' in locals()\n",
    "print(zeros)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "add9916c2128b2aeb765a43ba87d6b01",
     "grade": true,
     "grade_id": "problem_3_ag_p2_functions_usage_test5",
     "locked": true,
     "points": 0.5,
     "schema_version": 3,
     "solution": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "85\n"
     ]
    }
   ],
   "source": [
    "# Check the variable \"ones\" \n",
    "assert 'ones' in locals()\n",
    "print(ones)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "f9be951cfe27eb0dd77653e2820d73a1",
     "grade": true,
     "grade_id": "problem_3_ag_p2_functions_usage_test6",
     "locked": true,
     "points": 0.5,
     "schema_version": 3,
     "solution": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "114\n"
     ]
    }
   ],
   "source": [
    "# Checkthe variable \"twos\" \n",
    "assert 'twos' in locals()\n",
    "print(twos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "49e371af5d127d9f95a6dd702a31ad8c",
     "grade": true,
     "grade_id": "problem_3_ag_p2_functions_usage_test7",
     "locked": true,
     "points": 0.5,
     "schema_version": 3,
     "solution": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    }
   ],
   "source": [
    "# Check the variable \"threes\" \n",
    "assert 'threes' in locals()\n",
    "print(threes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "9e7397b86876c8dce7d1c4ae2f0d0d8f",
     "grade": false,
     "grade_id": "cell-b4a6387bf95866ff",
     "locked": true,
     "schema_version": 3,
     "solution": false
    }
   },
   "source": [
    "### Check your code\n",
    " \n",
    "- Remeber to check that your have commented your code and used the required variable names. \n",
    "- Make sure to commit and push also your `temp_functions.py` script to your own GitHub repository for Exercise 4!\n",
    "- If you have any comments and concerns at this point, you can write them below:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "d245343c9f091b8810bee99b896f8db9",
     "grade": true,
     "grade_id": "problem_3_mg_p3_check_your_code",
     "locked": false,
     "points": 0.5,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "source": [
    "YOUR ANSWER HERE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "markdown",
     "checksum": "2b18aad071a6845344672b756461ac18",
     "grade": false,
     "grade_id": "cell-4f684d1504712a9d",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "source": [
    "#### All done!\n",
    "\n",
    "That's it! Now you have finished all the problems for Exercise 4! Remember to push all your changes to your personal GitHub Exercise 4 repository (including the `temp_functions.py` script)."
   ]
  }
 ],
 "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}