02-lists.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python Lists\n",
    "\n",
    "In the previous lesson, you created variables to store single data values such as the average precipitation value for January in Boulder, CO. You define these variables by assigning a data value to a variable name using `=` (e.g. `jan = 0.70`). \n",
    "\n",
    "You can create a list of multiple values by using brackets (`[]`) to contain the values and then assigning that bracketed list of values to a variablename (e.g. `variablename = [1, 2, 3]` or `[variablename = [\"text1\", \"text2\"]`). \n",
    "\n",
    "An interesting feature of `Python` lists is that they can be used to store data using any combination of values, including a mix of integers, decimals, text strings, and even other existing variables. \n",
    "\n",
    "For example, you can create lists that store multiple integers or text strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.7, 0.75, 1.85]\n",
      "['January', 'February', 'March']\n"
     ]
    }
   ],
   "source": [
    "precip = [0.70, 0.75, 1.85]\n",
    "\n",
    "months = [\"January\", \"February\", \"March\"]\n",
    "\n",
    "print(precip)\n",
    "\n",
    "print(months)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also create a list that contains different types of data (e.g. integers, decimals, text strings), including existing variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 17.7799, 'January']\n"
     ]
    }
   ],
   "source": [
    "jan = 17.7799\n",
    "\n",
    "alldata = [1, jan, \"January\"]\n",
    "\n",
    "print(alldata)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also create lists that contain text strings of names of files and directories on your computer, or the names of other data structures such as other lists. \n",
    "\n",
    "**Data Tip:** If you create a list using the names of files or variables, the list will only store the text strings of the name of the file, directory, or data structure but not the actual values contained in that variable. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['precip.txt', 'months.txt']\n"
     ]
    }
   ],
   "source": [
    "filenames = [\"precip.txt\", \"months.txt\"]\n",
    "\n",
    "print(filenames)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Indexing For Python Lists\n",
    "\n",
    "In `Python`, indexing is used by many data structures such as lists to organize data and manage the order of the items or elements within the data structure. \n",
    "\n",
    "Each item in a `Python` list has an index, or a specified location in the collection of values. \n",
    "\n",
    "By default, `Python` will always begin indexing with `[0]`. Thus, the first item in a list has an index `[0]`, the second item in a list has an index `[1]`, and so on. \n",
    "\n",
    "This means that you can use the index of an item to query its value. In the example below, you can use `preciplist[2]` to get the 3rd item in the list (`1.85`). \n",
    "\n",
    "```python\n",
    "preciplist = [0.70, 0.75, 1.85]\n",
    "```\n",
    "In this lesson, you will create new lists and use indexing to update, add, and remove items in lists.\n",
    "\n",
    "You will again use data on average monthly precipitation for <a href=\"https://www.esrl.noaa.gov/psd/boulder/Boulder.mm.precip.html\" target=\"_blank\">Boulder, Colorado provided by the U.S. National Oceanic and Atmospheric Administration (NOAA)</a>, so you can see learn how to work with lists using a familiar dataset.  \n",
    "\n",
    "Month  | Precipitation (inches) \n",
    "--- | --- \n",
    "Jan | 0.70\n",
    "Feb | 0.75\n",
    "Mar | 1.85\n",
    "Apr | 2.93\n",
    "May | 3.05\n",
    "June | 2.02\n",
    "July | 1.93\n",
    "Aug | 1.62\n",
    "Sept | 1.84\n",
    "Oct | 1.31\n",
    "Nov | 1.39\n",
    "Dec | 0.84"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Begin Writing Your Code\n",
    "\n",
    "Remember that adding `Python` comments before each code block can help you to document and explain what is being accomplished with that code.\n",
    "\n",
    "Begin by creating variables for average monthly precipitation that you can compile into a list. Create variables for January through October that convert the values from inches to millimeters (1 inch = 25.4 mm)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create variables for January through October and convert the values from inches to millimeters (1 inch = 25.4 mm)\n",
    "jan = 0.70 * 25.4\n",
    "feb = 0.75 * 25.4\n",
    "mar = 1.85 * 25.4\n",
    "apr = 2.93 * 25.4\n",
    "may = 3.05 * 25.4\n",
    "june = 2.02 * 25.4\n",
    "july = 1.93 * 25.4\n",
    "aug = 1.62 * 25.4\n",
    "sept = 1.84 * 25.4\n",
    "oct = 1.31 * 25.4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create Lists\n",
    "\n",
    "Recall that you can create a list of multiple values by using brackets (`[]`) to contain the values and then assigning that bracketed list of values to a variablename (e.g. `variablename = [1, 2, 3]` or `[variablename = [\"text1\", \"text2\"]`). \n",
    "\n",
    "For example, you can create a list that contains the variables you created for January through October."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[17.779999999999998, 19.049999999999997, 46.99, 74.422, 77.46999999999998, 51.308, 49.022, 41.148, 46.736, 33.274]\n"
     ]
    }
   ],
   "source": [
    "# create list `precip` from these variables\n",
    "precip = [jan, feb, mar, apr, may, june, july, aug, sept, oct]\n",
    "\n",
    "# print the data in `precip`\n",
    "print(precip)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also create a list that contains text strings of the month names."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Jan', 'Feb', 'Mar', 'Apr', 'May', 'June', 'July', 'Aug', 'Sept', 'Oct']\n"
     ]
    }
   ],
   "source": [
    "# create list `months` to store the monthly names from January to October only\n",
    "months = [\"Jan\", \"Feb\", \"Mar\", \"Apr\", \"May\", \"June\", \"July\", \"Aug\", \"Sept\", \"Oct\"]\n",
    "\n",
    "# print the data in `months`\n",
    "print(months)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Print the Length of a List\n",
    " \n",
    "To work efficiently with indexing, it is very helpful to know how long the list is, meaning how many items are stored in the list. \n",
    "\n",
    "You can use the function `len()` to query this information by including the name of the list as a parameter, or input, to the function (e.g. `len(listname)`). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# print the length of list `months`\n",
    "len(months)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can see that `months` contains 10 items because it only includes January through October. \n",
    "\n",
    "## Query Items in Lists\n",
    "\n",
    "Since you know that `Python` indexing begins with `[0]`, you can use indexing to query the value of the 10th item with `month[index]`, where index is equal to `10-1` or `9`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Oct'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# check the value at index = [9]\n",
    "months[9]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using an index value that is larger than `number of items - 1` will result in an error because the index does not exist. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Oct'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# change the index value in this cell from 9 to 10 to check what happens when you query for an index location that does not exist\n",
    "months[9]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Update Items in Lists\n",
    "\n",
    "In addition to querying values, you can also use indexing to update items in a list by assigning a new value to that index location. \n",
    "\n",
    "For example, if you want to update the value stored at `months[index]`, you can assign a new value with:\n",
    "`months[index]` = \"New Text Value\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Jan', 'Feb', 'Mar', 'Apr', 'May', 'June', 'July', 'Aug', 'Sept', 'October']\n"
     ]
    }
   ],
   "source": [
    "# update the value at index = [9] to `October`\n",
    "months[9] = \"October\"\n",
    "\n",
    "# print the data in `months`\n",
    "print(months)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Jan', 'Feb', 'Mar', 'Apr', 'May', 'June', 'July', 'Aug', 'Sept', 'Oct']\n"
     ]
    }
   ],
   "source": [
    "# update the value at index = [9] back to `Oct`\n",
    "months[9] = \"Oct\"\n",
    "\n",
    "# print the data in `months`\n",
    "print(months)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Add Items to an Existing List\n",
    "\n",
    "To add new items to the end of an existing list, you can use the combined operator `+=` , which adds (`+`) the listed values after the `=` to the end of an existing list. \n",
    "\n",
    "For example, you can add new text strings using `listname += [\"New text 1\", \"New text 2\"]` and new numberic values using `listname += [9999.9999, 0.0]`.\n",
    "\n",
    "You can also items to the beginning of an existing list using the following syntax: \n",
    "`listname = [\"New Value 1\", \"New Value 2\"] + listname`.\n",
    "\n",
    "Expand your code to add a new item for `Nov` to the end of `months`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Jan', 'Feb', 'Mar', 'Apr', 'May', 'June', 'July', 'Aug', 'Sept', 'Oct', 'Nov']\n"
     ]
    }
   ],
   "source": [
    "# add new item for `Nov` to the end of `months`\n",
    "months += [\"Nov\"]\n",
    "\n",
    "# print the data in `months`\n",
    "print(months)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, add a new item to the end of `precip` for the average precipitation value for November. Notice that you will have to create a variable for `nov` first. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[17.779999999999998, 19.049999999999997, 46.99, 74.422, 77.46999999999998, 51.308, 49.022, 41.148, 46.736, 33.274, 35.306]\n"
     ]
    }
   ],
   "source": [
    "# create new variable `nov` to convert the original precipitation value from inches to millimeters\n",
    "nov = 1.39 * 25.4\n",
    "\n",
    "# add new value for `nov` to the end of `precip` \n",
    "precip += [nov]\n",
    "\n",
    "# print the data in `precip`\n",
    "print(precip)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Append Items to an Existing List\n",
    "\n",
    "You can also use the `append()` function of lists (also, referred to as a method of the list object) to add a single value to the end of an existing list. \n",
    "\n",
    "You can do this by calling `listname.append()`, which indicates that this function is an inherent method of the list object that is being used. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Jan', 'Feb', 'Mar', 'Apr', 'May', 'June', 'July', 'Aug', 'Sept', 'Oct', 'Nov', 'December']\n"
     ]
    }
   ],
   "source": [
    "# append the item \"December\" to the end of `months`\n",
    "months.append(\"December\")\n",
    "\n",
    "# print the values in `months`\n",
    "print(months)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Delete Items From an Existing List\n",
    "\n",
    "You can delete unwanted items from an existing list using the `del` statement, followed by the listname and the index location of the items that we want to remove (e.g. `del list_name[index]`). \n",
    "\n",
    "Remember: checking the length and content of a list is helpful before using indexing to modify the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# print the length of `months`\n",
    "len(months)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can see that `months` has 12 items and an unwanted last item with the value `December`. \n",
    "\n",
    "You can remove the unwanted item using the `del` statement (e.g. `del list_name[index]`). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Jan', 'Feb', 'Mar', 'Apr', 'May', 'June', 'July', 'Aug', 'Sept', 'Oct', 'Nov']\n"
     ]
    }
   ],
   "source": [
    "# delete the last item \"December\" from the end of `months`\n",
    "del months[11]\n",
    "\n",
    "# print the data in `months`\n",
    "print(months)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You now know how to create lists and use indexing to update, add, and delete items in lists. \n",
    "\n",
    "## <i class=\"fa fa-pencil-square-o\" aria-hidden=\"true\"></i> Optional Challenge \n",
    "\n",
    "Test your `Python` skills to complete the lists for January through December:\n",
    "\n",
    "1. Create a variable of the precipitation value for December and add it to `precip` (hint: `listname += [value]`).\n",
    "\n",
    "2. Add the month name for December to `months` (hint: `listname.append(value)`). Be sure to use a name that matches the style of the other names in the list. \n",
    "\n",
    "3. Print each list to see the final values.\n"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Tags",
  "kernelspec": {
   "display_name": "Python [default]",
   "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}