python_1.5_builtin_functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python: Important built-in functions\n",
    "While we'll discuss functions in detail in the next module, but there are a number of important built-in functions to be aware of. A full list of Python's built in functions can be found on the [official Python website](https://docs.python.org/3.6/library/functions.html#func-list). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `print()` and `format()`\n",
    "Of all of the built in functions in Python, `print()` is likely to be the one you use by far the most. It's helpful as part of the debugging process as well as to provide output from your programs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First\n",
      "42\n",
      "First 42 Third\n"
     ]
    }
   ],
   "source": [
    "a = 'First'\n",
    "b = 42\n",
    "c = 'Third'\n",
    "print('First') # You can print strings\n",
    "print(42)      # You can print numbers\n",
    "print(a,b,c)   # Separating arguments with commas "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's often useful to mix text and data from variables. Suppose you were building program to make [Mad Libs](https://en.wikipedia.org/wiki/Mad_Libs) where the user provided two words and you wanted to insert them into your Mad Lib. One way we can do this is to break up a string into parts and concatenate them together"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You can't be serious!\n",
      "That shiny dog ate all that broccoli?\n"
     ]
    }
   ],
   "source": [
    "adjective = 'shiny'\n",
    "noun      = 'broccoli'\n",
    "madlib    = 'You can\\'t be serious!\\nThat ' + adjective + ' dog ate all that ' + noun + '?'\n",
    "print(madlib)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You'll notice that there are a few backslashes before apostrophes. These are known as escape sequences since they prevent the Python interpreter from incorrectly evaluating them as part of the code rather than as part of the string. Escape sequences you’ll commonly encounter:\n",
    "\n",
    "|Escape Sequence| Produces |\n",
    "|---------------|----------|\n",
    "| `\\\\`            | `\\`        |\n",
    "| `\\'`            | `'`        |\n",
    "| `\\\"`            | `\"`        |\n",
    "| `\\t`            | a tab    |\n",
    "| `\\n`            | newline  |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Mad Lib example above requires typing multiple strings and concatenating them together. This can all be merged into one string with the use of the `format()` method for strings (we'll talk more about methods when we discuss classes later). Let's rewrite the Mad Lib example using this method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You can't be serious!\n",
      "That shiny dog ate all that broccoli?\n"
     ]
    }
   ],
   "source": [
    "madlib    = 'You can\\'t be serious!\\nThat {} dog ate all that {}?'.format(adjective,noun)\n",
    "print(madlib)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using these format strings and leaving spaces for the variables we want to insert allows us to more easily modify the strings without entirely rewriting that line of code (and adding in concatenation operators and apostrophes all over the place).\n",
    "\n",
    "But this method can also shine through with numerical values and allow us to format these in custom ways. This is a tool that will also come in handy when making legends, titles, and axes for plots later on."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Height = 0.234573534197, weight = 23.789325129594\n"
     ]
    }
   ],
   "source": [
    "height = 0.234573534197\n",
    "weight = 23.789325129594\n",
    "summary = 'Height = {}, weight = {}'.format(height,weight)\n",
    "print(summary)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This contains far too many decimal places, though. So we can provide formatting instructions. You can find the full documentation on how this works in the [Python documentation](https://docs.python.org/3.4/library/string.html#formatstrings). Let's say we wanted the weight to be formatted as an integer and the height to have 3 digits after the decimal place. We can easily do this as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Height =   0.235, weight =   24\n"
     ]
    }
   ],
   "source": [
    "summary = 'Height = {0:7.3f}, weight = {1:4.0f}'.format(height,weight)\n",
    "print(summary)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `format()` method has its own mini language that is quite powerful, but you really just need the basics to get the most value out of it. The template string (in the brackets) is what defines how the text is presented. Let's break down that example a bit more:\n",
    "<img src=\"img/format.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also replace the argument numbers with variable names, (below we use `h` for height and `w` for weight) which you then use in the argument of the `format()` method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Height =   0.235, weight =   24\n"
     ]
    }
   ],
   "source": [
    "summary = 'Height = {h:7.3f}, weight = {w:4.0f}'.format(h=height,w=weight)\n",
    "print(summary)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you leave off the position identifiers, `format()` inserts the variables into the string in the order that they appear from left to right"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Height =   0.235, weight =   24\n"
     ]
    }
   ],
   "source": [
    "summary = 'Height = {:7.3f}, weight = {:4.0f}'.format(height,weight)\n",
    "print(summary)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Other helpful built-in functions\n",
    "\n",
    "### `input()`\n",
    "Get input from the user at the command line."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number: 5\n",
      "Your number is 5\n"
     ]
    }
   ],
   "source": [
    "x = input('Enter a number: ')\n",
    "print('Your number is ' + x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### core math functions: `abs()`, `min()`, `max()`, `pow()`, `round()`, `sum()`\n",
    "Each of these core functions do precisely what their names indicate...\n",
    "\n",
    "They can take the absolute value of a number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n"
     ]
    }
   ],
   "source": [
    "print(abs(-7))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "They can calculate the minimum or maximum value from a collection of numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-8\n",
      "44.67\n"
     ]
    }
   ],
   "source": [
    "print(min(4,7,-3,2,-8,44.67))\n",
    "print(max(4,7,-3,2,-8,44.67))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This also works with lists and tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-8\n",
      "44.67\n"
     ]
    }
   ],
   "source": [
    "values_list = [4,7,-3,2,-8,44.67]\n",
    "print(min(values_list))\n",
    "print(max(values_list))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-8\n",
      "44.67\n"
     ]
    }
   ],
   "source": [
    "values_tuple = (4,7,-3,2,-8,44.67)\n",
    "print(min(values_tuple))\n",
    "print(max(values_tuple))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can even use these for text analysis for calculating the first string in a sequence alphabetically"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "alphazero\n",
      "zelda\n"
     ]
    }
   ],
   "source": [
    "values_text = ['bitcoin','alphazero','crazy horse','zelda','d is for doctor']\n",
    "print(min(values_text))\n",
    "print(max(values_text))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `pow(x,y)` function returns $x^y$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16\n",
      "8.0\n"
     ]
    }
   ],
   "source": [
    "print(pow(4,2))\n",
    "print(pow(64,0.5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `round()` function rounds to the nearest whole number by default"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "25\n"
     ]
    }
   ],
   "source": [
    "print(round(2.34363))\n",
    "print(round(24.6473))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also specify the level of precision you'd prefer it to round to instead. For example, if you'd like to round to the nearest 2-decimal places: `round(<number to round>,<decimal places to round to>)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.34\n",
      "24.65\n"
     ]
    }
   ],
   "source": [
    "print(round(2.34363,2))\n",
    "print(round(24.6473,2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Of course, you can take the sum over numerical values in containers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "values_list = [4,7,-3,2]\n",
    "values_tuple = (4,7,-3,2)\n",
    "print(sum(values_list))\n",
    "print(sum(values_tuple))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `len()`\n",
    "Calculates the length (or number of items in) a container"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "6\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "values_list  = [4,7,-3,2,-8,44.67]\n",
    "values_tuple = (4,7,-3,2,-8,44.67)\n",
    "values_text  = ['bitcoin','alphazero','crazy horse','zelda','d is for doctor']\n",
    "print(len(values_list))\n",
    "print(len(values_tuple))\n",
    "print(len(values_text))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `type()`\n",
    "Returns the type of object (recall that we used this extensively when introducing the various Python data types)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "<class 'float'>\n",
      "<class 'str'>\n",
      "<class 'list'>\n",
      "<class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "print(type(4))\n",
    "print(type(4.4))\n",
    "print(type('this'))\n",
    "print(type([2,3,4]))\n",
    "print(type((2,3,4)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `any()`, `all()`\n",
    "These logical functions are helpful tools to check whether any or all elements in a container are true."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "mylist = [True,False,False,False]\n",
    "print(any(mylist))\n",
    "print(all(mylist))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Practical example**: How do I determine if any or all of the numbers in a list are odd?\n",
    "\n",
    "First, how do we test if a number is odd or even?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "even\n"
     ]
    }
   ],
   "source": [
    "# Test whether the number is odd or even\n",
    "number = 8\n",
    "if number % 2 == 0:\n",
    "    print('even')\n",
    "else:\n",
    "    print('odd')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll start with our list and we'll first create a new list where we test whether or not each item in this list is a multiple of 2. We can check whether or not each member of the list is odd or even using the modulus (`%`) operator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[True, True, False, True, True, True]\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "numbers = [2,4,5,8,10,200]\n",
    "isodd   = [] # Start with an empty list and append to it\n",
    "for i in numbers:\n",
    "    isodd.append(i % 2 == 0)\n",
    "print(isodd)\n",
    "print(any(isodd))\n",
    "print(all(isodd))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Type casting: `int()`, `float()`, `bool()`, `str()`, `list()`, `tuple()`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes we find ourselves in a situation when programming that the data type that a variable is in is not appropriate for how we want to use it. For example. Let's say that we have a number but we want to combine it into a string. We could use the `format` function we discussed earlier, or we could convert our number to a string then combine it with another string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My favorite number is 8\n"
     ]
    }
   ],
   "source": [
    "num = 8\n",
    "mytext = 'My favorite number is '\n",
    "\n",
    "# We can combine the two by converting num into a string then concatenating the two pieces together\n",
    "merged_text = mytext + str(num)\n",
    "print(merged_text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similarly there may be times when we want to convert integers to floats or vice versa for different data analysis problems. We can easily convert between the two, but going from a float to an integer cuts off any decimals on the end:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int(7.666)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7.0"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "float(7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`bool` converts the input to its logical value (`True` or `False`) by the rules we discussed in the data types section."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool(7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also convert tuples to lists and vice versa"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 4]"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list((1,3,4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(7, 8, 9)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tuple([7,8,9])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Cleaning: For loops with `enumerate()`, `range()`, and `zip()`\n",
    "Let's say our goal is to check whether some weather data we have on wind speed is valid, or if the sensor has failed. The wind speed has three classes, each corresponding to a different range. If the wind speed is negative, the sensor collected an invalid reading, and we should replace the corresponding value of `wind_class` with the value 'invalid'.\n",
    "\n",
    "As with everything in this course, please follow along with these steps in Spyder. Create a new file and build up a script as we go along. This example introduces some advanced Python built-in functions such as `enumerate()` and `zip` and their use in `for` loops. We combine this with some of the looping functionality introduced in the last section."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "wind_speed = [-2,       3,        -0.7,     24,         -3,        -4,        9         ]\n",
    "wind_class = ['Class I','Class I','Class I','Class III','Class II','Class II','Class II']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To do this, we could loop through the index of each array. The `range()` function enables this and when transformed to a list, produces a sequential list of values from 0 to the argument minus one, by increments of 1:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3]"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We use the `list()` function here to produce a list from `range()` since it doesn't produce a list directly. Why it doesn't is relevant important here, but the reason is that it is what is known as an iterator. You don't need to know that for this course, just providing that information for those who may be curious."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(7))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before we begin assigning new variables to help us analyze our dataset, let's make a copy of our list so we don't destroy any of the original in the process. Remember from the readings that we have to be careful when assigning one variable to the other and make a copy when we don't want them to refer to the same data. In the simple example below, the variables `a` and `b` end up pointing to the same data so that when we change one value in `b` the same entry in the list `a` is also changed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['flamingo', 2, 3, 4]\n",
      "['flamingo', 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "a    = [1,2,3,4]\n",
    "b    = a\n",
    "b[0] = 'flamingo'\n",
    "print(b)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Therefore, we copy our list first before we begin processing the data to ensure it's preserved in case we need to go back and analyze it differently later."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Class I', 'Class I', 'Class I', 'Class III', 'Class II', 'Class II', 'Class II']\n"
     ]
    }
   ],
   "source": [
    "corrected_class = wind_class.copy()\n",
    "print(corrected_class)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So here we could write the loop to clean the data above:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['invalid', 'Class I', 'invalid', 'Class III', 'invalid', 'invalid', 'Class II']\n"
     ]
    }
   ],
   "source": [
    "for i in range(len(wind_speed)):\n",
    "    if wind_speed[i] < 0:\n",
    "        corrected_class[i] = 'invalid'\n",
    "print(corrected_class)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The handy `enumerate()` function, which is built in to Python is helpful if your program needs to iterate through a list while also using the index of the current value from that list. For example if I had a list `thislist = [2,4,6]` and when the for loop iterates, I want to know that the entry `2` corresponds to an index of `0` (i.e. 2 corresponds to thislist[0]). Enumerate adds the ability to have an index that corresponds to each value in a collection and iterate over both. It makes a sequence of tuples that contain the index and the corresponding value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(0, 'Class I'),\n",
       " (1, 'Class I'),\n",
       " (2, 'Class I'),\n",
       " (3, 'Class III'),\n",
       " (4, 'Class II'),\n",
       " (5, 'Class II'),\n",
       " (6, 'Class II')]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(enumerate(wind_class))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's take this concept and apply it to our problem:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['invalid', 'Class I', 'invalid', 'Class III', 'invalid', 'invalid', 'Class II']\n"
     ]
    }
   ],
   "source": [
    "for (i, speed) in enumerate(wind_speed):\n",
    "    if speed < 0:\n",
    "        corrected_class[i] = 'invalid'\n",
    "print(corrected_class)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While we've solved the problem at hand, this example also gives us the opportunity to introduce another helpful built in Python function, `zip()` which aggregates elements from two containers. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "# Get the indices\n",
    "index = list(range(len(wind_class)))\n",
    "print(index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Class I', 'Class I', 'Class I', 'Class III', 'Class II', 'Class II', 'Class II']\n"
     ]
    }
   ],
   "source": [
    "# Get the values that correspond to each index\n",
    "print(wind_class)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What we want is to be able to create pairs of index and wind_class so that as we iterate, we have both the value 'Class I', the first entry in `wind_class` available at the same time as the corresponding entry in the list `index` which happens to be 0. We can do this with the `zip()` function as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(0, 'Class I'), (1, 'Class I'), (2, 'Class I'), (3, 'Class III'), (4, 'Class II'), (5, 'Class II'), (6, 'Class II')]\n"
     ]
    }
   ],
   "source": [
    "# \"zip\" the two together\n",
    "zipped = zip(index,wind_class)\n",
    "print(list(zipped))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see it \"zips\" the two together making tuples of the two input arrays. Let's reproduce the functionality we just saw with enumerate with zip:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['invalid', 'Class I', 'invalid', 'Class III', 'invalid', 'invalid', 'Class II']\n"
     ]
    }
   ],
   "source": [
    "for (i, speed) in zip(index,wind_speed):\n",
    "    if speed < 0:\n",
    "        corrected_class[i] = 'invalid'\n",
    "print(corrected_class)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comments\n",
    "While comments are not built-in functions, they are core to the language as tools for conveying information to others who work on your code about how it works and what it does. Additionally, comments are critical for remembering what you did a few days or months ago. If we don't comment it's very easy to forget what the code does. \n",
    "\n",
    "Comments are lines in a program that are not executed and used to enhance program readability and explain how it's used. There are two types of comments: block comments and inline comments. Both can be used at any point in a script, but there are some conventions around how they are used in practice.\n",
    "\n",
    "Longer block comments, indicated with `'''` are used most often at the top of a function to describe what it does, list the inputs and outputs, and mention who the author of it was."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "'''\n",
    "This is a longer block comment\n",
    "It can be multiple lines if you want\n",
    "'''\n",
    "\n",
    "'''The block comment can also be one line if its short'''"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Inline comments are often used just before some code to explain what it does or why it does it. Alternatively, inline comments are use at the end of a line (hence the name 'inline') to give some explanation of that line."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# There are also inline comments\n",
    "x = 7 # They can also go at the end of a line of code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generally, you want to comment enough to give the reader a clear idea of what you're accomplishing with your code. You don't want to provide a line by line description of the code, but enough that someone else could look at it and quickly figure out how to use it and how it works."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Next\n",
    "Now you've walked through a good amount of Python programming, you have everything you need to start putting these fantastic tools to use! Take a deep breadth and pat yourself on the back, because that was a lot of material. If you're feeling lost at all, take a minute to review the readings and go back through the content. If a particular section of material was unclear, ask questions on Piazza or search for other resources on the concept that may present an alternative explanation that resonates with you more.\n",
    "\n",
    "In the next unit, we'll be discussing functions and classes, which are tools of packaging segments of code that accomplish specific tasks that you'll use over and over again. This will significantly increase what you can accomplish with Python. "
   ]
  }
 ],
 "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.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}