DS109-Python/DS109-L3-Lists-and-Looping.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "50e6ddbb-52d3-4a02-9b69-100a4181e3b0",
   "metadata": {},
   "source": [
    "# DS109 Python : Lesson Three Lists and Looping"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1bd4bfc-9b15-4b80-87b4-b8b60eb56371",
   "metadata": {},
   "source": [
    "### Table of Contents <a class=\"anchor\" id=\"DS109L3_toc\"></a>\n",
    "\n",
    "* [Table of Contents](#DS109L3_toc)\n",
    "    * [Page 1 - Overview of this Module](#DS109L3_page_1)\n",
    "    * [Page 2 - Setup](#DS109L3_page_2)\n",
    "    * [Page 3 - What is a List?](#DS109L3_page_3)\n",
    "    * [Page 4 - Creating a List](#DS109L3_page_4)\n",
    "    * [Page 5 - Activity Part 1](#DS109L3_page_5)\n",
    "    * [Page 6 - Nested Lists](#DS109L3_page_6)\n",
    "    * [Page 7 - Tuples](#DS109L3_page_7)\n",
    "    * [Page 8 - Activity Part 2](#DS109L3_page_8)\n",
    "    * [Page 9 - Lists and Tuples Indexing](#DS109L3_page_9)\n",
    "    * [Page 10 - Modifying Lists](#DS109L3_page_10)\n",
    "    * [Page 11 - Adding an Item to the End of the List](#DS109L3_page_11)\n",
    "    * [Page 12 - Adding to List Activity](#DS109L3_page_12)\n",
    "    * [Page 13 - Removing an Item From a List](#DS109L3_page_13)\n",
    "    * [Page 14 - Modifying Lists Activity](#DS109L3_page_14)\n",
    "    * [Page 15 - Creating a List from a Range of Numbers ](#DS109L3_page_15)\n",
    "    * [Page 16 - Sorting a List](#DS109L3_page_16)\n",
    "    * [Page 17 - Iterating Over a Collection](#DS109L3_page_17)\n",
    "    * [Page 18 - Iterating Lists Activity](#DS109L3_page_18)\n",
    "    * [Page 19 - While Loop](#DS109L3_page_19)\n",
    "    * [Page 20 - Terminating a For Loop](#DS109L3_page_20)\n",
    "    * [Page 21 - Key Terms](#DS109L3_page_21)\n",
    "    * [Page 22 - Lesson 3 Practice Hands-On](#DS109L3_page_22)\n",
    "    * [Page 23 - Lesson 3 Practice Hands-On Solution](#DS109L3_page_23)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ef5a8c65-ed48-4354-a257-e01b0fd733d4",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 1 - Overview of this Module<a class=\"anchor\" id=\"DS109L3_page_1\"></a>\n",
    "\n",
    "[Back to Top](#DS109L3_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "51176727-deed-4926-b57a-c594b8c81cbc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"720\"\n",
       "            height=\"480\"\n",
       "            src=\"https://player.vimeo.com/video/238447766\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.VimeoVideo at 0x7f9178920f40>"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import VimeoVideo\n",
    "# Tutorial Video Name: Lists and Loops\n",
    "VimeoVideo('238447766', width=720, height=480)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b6ad526-95fa-43c4-bc43-1fe807708ed3",
   "metadata": {},
   "source": [
    "In the previous lessons, you learned how to store a single value in a variable. Storing a single value is useful, but what if you need to store sets of data in one place &mdash; whether a couple items or a few hundred items. In this lesson, you will learn about `tuples`, `lists`, and a few other powerful features in the Python language. The use of `list` ties together several different, yet equally important, programming concepts.\n",
    "\n",
    "By the end of this lesson, you should be able to:\n",
    "\n",
    "* Create and modify lists\n",
    "* Understand the difference between a list and a tuple\n",
    "* Access elements in a list or tuple\n",
    "* Utilize for and while loops\n",
    "\n",
    "This lesson will culminate in a hands-on in which you program the game \"ZipZap\" and make use of your newfound loop skills!\n",
    "\n",
    "<div class=\"panel panel-success\">\n",
    "    <div class=\"panel-heading\">\n",
    "        <h3 class=\"panel-title\">Additional Info!</h3>\n",
    "    </div>\n",
    "    <div class=\"panel-body\">\n",
    "        <p>If you have not already, you may want to watch this <a href=\"https://vimeo.com/426836051\"> recorded live workshop </a> that goes over the concept of for and while loops in addition to if/elif/else. </p>\n",
    "    </div>\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7990ac7a-5a2f-4744-af14-1b7e385ea484",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 2 - Setup<a class=\"anchor\" id=\"DS109L3_page_2\"></a>\n",
    "\n",
    "[Back to Top](#DS109L3_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "612429df-e4ef-4d85-8460-5bc8914079c3",
   "metadata": {},
   "source": [
    "# Setup\n",
    "\n",
    "1. First, open up your command prompt (Windows) or your terminal (Mac/Linux)\n",
    "    - For Windows, navigate to your search bar in the bottom left hand corner. Type in `Command Prompt` and it should pop up. Click on `Command Prompt` and a separate window should appear on your screen.\n",
    "    - For Mac, press `command` and the space bar at the same time. Type in `terminal` and press `enter`. A separate Terminal window will pop up.\n",
    "2. Now that you are in your Command Prompt/Terminal, run the following command:\n",
    "    ```text\n",
    "    cd desktop\n",
    "    ```\n",
    "3. Next, move your command prompt/terminal's location to the new `python_course` you just created by running the following:\n",
    "    ```text\n",
    "    cd python_course\n",
    "    ```\n",
    "4. Create a _new_ directory within the `python_course` directory. This new folder is the project you will be working in for this lesson. Run the following:\n",
    "    ```text\n",
    "    mkdir lesson_three\n",
    "    ```\n",
    "5. Open up a new window in VSCode.\n",
    "6. The first thing you should see a Welcome page. You can close this window.\n",
    "7. Now, its time to open the `lesson_three` directory. Click on the \"Explorer\" button on the left-hand side of the VSCode window.\n",
    "8. You will now see a button that says `Open Folder`, as shown below. Click this button.\n",
    "9. A new window will open that will allow you to search for files and folders. Locate the `python_course` folder you just created on your Desktop. Click on that folder and then locate the `lesson_three` folder. Select the `lesson_three` directory and click the `Open` button.\n",
    "10. Create a new file named `main.py` by one of the following three ways:\n",
    "    - To the right of __LESSON_THREE_ in the EXPLORER is a button that looks like a piece of paper with a plus symbol in its top-left corner. If you hover your mouse over this button for a moment, a popup will appear indicating that this button will create a new file.\n",
    "    - Choose `File > New File` from the app's menu.\n",
    "    - Press `Control + N` in Windows or `Command + N` on a Mac (the plus means \"and at the same time\").\n",
    "\n",
    "Once the `main.py` file is created, you are ready to go! As you work through this lesson, add the code examples into your project so you can see the output yourself. Remember, to see the output within the VSCode terminal, right-click within your file and choose \"Run Python File in Terminal\".\n",
    "\n",
    "The creation of this new project is for you to practice your new skills. It is highly recommended that you add the code from this lesson into your `lesson_three` project as you learn it. As you are going through this lesson and adding code to your project, you may find it helpful to include `comments` with a brief sentence explaining what is going on in the code. That way, you will have an easy reference to the topics explained in this lesson. Happy coding!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "832358fd-55fa-420a-8aa2-46fbf2097986",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 3 - What is a List?<a class=\"anchor\" id=\"DS109L3_page_3\"></a>\n",
    "\n",
    "[Back to Top](#DS109L3_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f564e3e7-3a7f-4936-b3a3-2e0a9ab78512",
   "metadata": {},
   "source": [
    "# What is a List?\n",
    "\n",
    "In Python, a *list* is a data structure that holds a collection of objects. In other programming languages, this data structure is sometimes called an _array_.\n",
    "\n",
    "You've already seen what a list looks like in a previous lesson. Do you remember the `split()` operation that you can perform on a string?\n",
    "\n",
    "```python\n",
    "my_message = \"Split these words for me\"\n",
    "split_at_spaces = my_message.split()\n",
    "```\n",
    "\n",
    "The result of calling `split` on the above string variable resulted in the creation of a `list`.\n",
    "\n",
    "```python\n",
    "['Split', 'these', 'words', 'for', 'me']\n",
    "```\n",
    "\n",
    "As you can see above, all of the words are between square brackets (`[` and `]`) and are separated with commas. This is the structure of a `list` in Python.\n",
    "\n",
    "In a `list`, each value has a location associated with it. This means that the items in a list are __ordered__ (that is _not_ the same as _sorted_). You will learn more about this \"location\" shortly.\n",
    "\n",
    "You can add and remove elements in a `list`. This means it is a mutable data type and can be altered.\n",
    "\n",
    "One nice feature of a `list` is that it can contain a mix of data types. This means that a single `list` object could contain, for example, a float, integer, and a string (or other data types).\n",
    "\n",
    "<div class=\"panel panel-success\">\n",
    "    <div class=\"panel-heading\">\n",
    "        <h3 class=\"panel-title\">Running into Errors?</h3>\n",
    "    </div>\n",
    "    <div class=\"panel-body\">\n",
    "        <p>Don't worry, code errors are a fact of life for a data scientist! Please feel free to watch <a href=\"https://vimeo.com/439142696\"> this live recorded workshop on Addressing Common Errors in Python!</a> Guaranteed to give you more clarity on what might be going wrong! </p>\n",
    "    </div>\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb1aade2-59af-4cbc-b5ed-da31e39f266d",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 4 - Creating a List<a class=\"anchor\" id=\"DS109L3_page_4\"></a>\n",
    "\n",
    "[Back to Top](#DS109L3_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eba2ed6e-98dd-43f7-8761-6ecc9a13af08",
   "metadata": {},
   "source": [
    "# Creating a List\n",
    "\n",
    "Now that you have a general idea of what a `list` is in Python, it's time to work with some examples. Take a look at the example below:\n",
    "\n",
    "```python\n",
    "another_variable = \"Hello world\"\n",
    "my_list = [\"String\", 3, 7.5, another_variable]\n",
    "\n",
    "print(my_list)\n",
    "```\n",
    "\n",
    "Above, the `my_list` variable is a list that contains a string value, two number values, and an additional string value by way of another variable named `another_variable`. \n",
    "\n",
    "It was created by:\n",
    "1. Defining the variable `my_list`.\n",
    "2. Assigning it to a value using the `=` assignment operator.\n",
    "3. Creating a list of items, each separated by a comma, and enclosed within square brackets.\n",
    "\n",
    "Simple!\n",
    "\n",
    "Now, what is the output of the above `print()` function?\n",
    "\n",
    "```\n",
    "['String', 3, 7.5, 'Hello world']\n",
    "```\n",
    "\n",
    "As you can see, when asked to print the list, Python prints the value of each item in the list including the value of `another_variable`.\n",
    "\n",
    "---\n",
    "\n",
    "## All String List\n",
    "\n",
    "Below you'll find examples of a list that contains some strings, as well as a list made up of only numbers:\n",
    "\n",
    "**INPUT:**\n",
    "\n",
    "```python\n",
    "planets = ['Earth', 'Mars', 'Saturn', 'Venus']\n",
    "print(planets)\n",
    "```\n",
    "\n",
    "**OUTPUT:**\n",
    "\n",
    "```python\n",
    "['Earth', 'Mars', 'Saturn', 'Venus']\n",
    "```\n",
    "\n",
    "---\n",
    "\n",
    "## All Number List\n",
    "\n",
    "**INPUT:**\n",
    "\n",
    "```python\n",
    "numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    "print(numbers)\n",
    "```\n",
    "\n",
    "**OUTPUT:**\n",
    "\n",
    "```python\n",
    "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    "```\n",
    "\n",
    "<div class=\"panel panel-warning\">\n",
    "    <div class=\"panel-heading\">\n",
    "        <h3 class=\"panel-title\">Try It Yourself!</h3>\n",
    "    </div>\n",
    "    <div class=\"panel-body\">\n",
    "        <p>Create a few lists in your <b>lesson_3.py</b> file and print them to the terminal like above. Remember, lists can contain a mixture of data types.</p>\n",
    "    </div>\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ead4ad3c-2fe6-457e-8924-1410e951bebd",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 5 - Activity Part 1<a class=\"anchor\" id=\"DS109L3_page_5\"></a>\n",
    "\n",
    "[Back to Top](#DS109L3_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bbbc06a2-e702-47a1-942f-cbcbe31221a7",
   "metadata": {},
   "source": [
    "Create a list of US states based upon the information below:\n",
    "\n",
    "- The list variable should be named `states`.\n",
    "\n",
    "- The contents of the list should be the following states in the same order:\n",
    "    - California\n",
    "    - Texas\n",
    "    - Florida\n",
    "    - New York"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "42a3007d-c7ff-41c4-a556-e211ea74d0ff",
   "metadata": {},
   "outputs": [],
   "source": [
    "answer = ['California', 'Texas', 'Florida', 'New York']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "b43f3a6d-0b52-4757-8b1e-6f748681fc57",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['California', 'Texas', 'Florida', 'New York']\n"
     ]
    }
   ],
   "source": [
    "print(answer)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd9e3b8a-9224-447f-8cf7-5035cae86421",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 6 - Nested Lists<a class=\"anchor\" id=\"DS109L3_page_6\"></a>\n",
    "\n",
    "[Back to Top](#DS109L3_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a81e2098-28ef-4ff5-a155-afe824de4323",
   "metadata": {},
   "source": [
    "# Nested Lists\n",
    "\n",
    "Not only can you make a list of individual items, but you can also create a list that contains other lists. This is called a *nested list*. Take a look at the examples below to see how a nested list is structured.\n",
    "\n",
    "**INPUT:**\n",
    "\n",
    "```python\n",
    "our_world = ['Earth', ['United States', 'Canada', 'Mexico'], [1, 2, 3]]\n",
    "print(our_world)\n",
    "```\n",
    "\n",
    "Above, the first element of the `our_world` list is a single string with the value `'Earth'`. The second element in the list is another list that contains three string values: `'United States'`, `'Canada'`, and `'Mexico'`. Finally, the last element in the `our_world` list is yet another list with three number values: 1, 2, and 3.\n",
    "\n",
    "When the `our_world` variable is printed, you should receive the following output:\n",
    "\n",
    "```python\n",
    " ['Earth', ['United States', 'Canada', 'Mexico'], [1, 2, 3]]\n",
    "```\n",
    "\n",
    "Here you can see that each list is printed inside of the `our_world` list.\n",
    "\n",
    "----\n",
    "## Empty Lists\n",
    "\n",
    "There will be times when you need to start with an empty list.\n",
    "\n",
    "```python\n",
    "my_empty_list = []\n",
    "```\n",
    "\n",
    "There's more to learn about lists, particularly how to add and delete items, as well as locating and accessing individual items in a list. Hold onto your seats - additional list fun is coming! \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42cb7d8a-aced-42e5-ac24-32acf8c95473",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 7 - Tuples<a class=\"anchor\" id=\"DS109L3_page_7\"></a>\n",
    "\n",
    "[Back to Top](#DS109L3_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf0debaf-5fae-4035-8e7d-ae62e62456cb",
   "metadata": {},
   "source": [
    "# Tuples\n",
    "\n",
    "Before you jump into additional list work, another data type will be covered: *tuples*. Lists work well for storing collections that have the ability to change throughout the life of your program. However, sometimes you may find that you need to create a collection of items that cannot change. This is where a tuple could be used. A tuple is a sequence, just like a list, except a tuple is *immutable*, or unchangeable. This means that the values inside of a tuple cannot be modified.\n",
    "\n",
    "When you use tuples in your code, you are saying to others that you do not intend for there to be any changes to the values. When it comes to performance, since the values do not change, you can optimize your code with the use of tuples in Python.\n",
    "\n",
    "The structure of a `tuple` is nearly identical to that of a `list`, except that instead of square brackets `[]` surrounding the list of items, parentheses `()` are used. This is best illustrated with examples:\n",
    "\n",
    "```python\n",
    "my_tuple = ('doctor', 'nurse', 'PA')\n",
    "print(my_tuple)\n",
    "```\n",
    "\n",
    "**OUTPUT:**\n",
    "\n",
    "```python\n",
    "('doctor', 'nurse', 'PA')\n",
    "```\n",
    "\n",
    "As you can see in the output above, when you print a `tuple`, it's just like an `list`, except with parentheses.\n",
    "\n",
    "---\n",
    "\n",
    "## Empty Tuples\n",
    "\n",
    "You can create __empty tuples__:\n",
    "\n",
    "```python\n",
    "empty_tuple = ()\n",
    "```\n",
    "\n",
    "But why on earth would you want an empty tuple? Tuples are like lists; they are collections of data. The major difference is that tuples are immutable &mdash; they cannot be altered. There will be times when you need to return an empty list. Imagine an app that loads a list of contacts and allows you to filter them by city. If a city you select yields zero results, you'll still need to return a list (albeit empty), because the code that's requesting it will expect it to be a list. The same holds true for tuples.\n",
    "\n",
    "---\n",
    "\n",
    "## Tuple with One Element\n",
    "\n",
    "When you create a tuple that contains only one element, you must still add a comma after it. It will look weird, but it's necessary. This is because the interpreter will not know if you meant a value simply inside of parentheses (like when performing arithmetic operations), or if you meant a tuple.\n",
    "\n",
    "```python\n",
    "one_item_tuple = ('just me',)\n",
    "print(one_item_tuple)\n",
    "```\n",
    "\n",
    "**OUTPUT**:\n",
    "\n",
    "```text\n",
    "('just me', )\n",
    "```\n",
    "\n",
    "---\n",
    "\n",
    "## Mixed Data Type Tuples\n",
    "\n",
    "Like lists, tuples can store any data type, and they can be mixed:\n",
    "\n",
    "```python\n",
    "# you've already seen a string tuple\n",
    "string_tuple = (\"this\", \"contains\", \"string\", \"values\")\n",
    "\n",
    "# you can, of course, create tuples with numbers\n",
    "number_tuple = (23, 23.5, 9, 144)\n",
    "\n",
    "# like lists, you can create tuples with a mix of types\n",
    "mixed_tuple = (\"Bob\", 33, \"Sally\", 29, \"Spike\", 8)\n",
    "```\n",
    "\n",
    "As you've seen, lists and tuples are very similar. You've also seen how to create both. Next, you'll learn how to access the elements inside of these collections.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d7b3f800-0a14-4d13-8c32-390965c537ca",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 8 - Activity Part 2<a class=\"anchor\" id=\"DS109L3_page_8\"></a>\n",
    "\n",
    "[Back to Top](#DS109L3_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4597e4b4-ce22-448d-843e-eab5ba74a9c4",
   "metadata": {},
   "source": [
    "Create a tuple named `items` with the following data:\n",
    "\n",
    "- The string `\"widget\"`.\n",
    "- A list of available colors for the box in the same order:\n",
    "    - `white`\n",
    "    - `black`\n",
    "    - `brown`\n",
    "- The number of items in stock: 25\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "7178ff75-9c87-4c1b-89cc-81e0ed9cf9ad",
   "metadata": {},
   "outputs": [],
   "source": [
    "answer = ('widget', ['white', 'black', 'brown'], 25)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "45bb5365-da04-4013-b30b-fb2c6d36da04",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('widget', ['white', 'black', 'brown'], 25)\n"
     ]
    }
   ],
   "source": [
    "print(answer)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36943bcd-7e16-4af1-97d3-c09e81ae5e99",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 9 - Lists and Tuples Indexing<a class=\"anchor\" id=\"DS109L3_page_9\"></a>\n",
    "\n",
    "[Back to Top](#DS109L3_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fdf2cdde-9447-49b5-8936-17d80f46b45e",
   "metadata": {},
   "source": [
    "# Lists and Tuples Indexing\n",
    "\n",
    "At some point, you'll need to know how many items are in a collection. The procedure to get the count is the same for both lists and tuples. In Python, the number of items in a collection is referred to as it's *length*.\n",
    "\n",
    "You're already familiar with the `print()` function, which takes a parameter that is printed to the console. The `len()` function is used to get a count of the items in a collection. Like the `print()` function, `len()` requires a parameter: the list or tuple to be counted.\n",
    "\n",
    "```python\n",
    "colors_list = ['red', 'green', 'blue', 'yellow']\n",
    "num_colors = len(colors_list)\n",
    "print(num_colors)\n",
    "```\n",
    "\n",
    "**OUTPUT**:\n",
    "\n",
    "```\n",
    "4\n",
    "```\n",
    "\n",
    "That's it! As you can see above, the length of `colors_list` is `4` &mdash; there are four values in the list.\n",
    "\n",
    "---\n",
    "\n",
    "## Accessing Items - Indexing\n",
    "\n",
    "You've learned how to structure lists and tuples, but how do you interact with them? How can you add, remove, change or even read the information in a list without printing the entire list? This is where the use of the *index*, or position, of an item in a list is important. Python considers the first item in a list to be at position `0` and not position `1` (unlike R). These positions are integers. This is illustrated below:\n",
    "\n",
    "```python\n",
    "[red, yellow, blue, green, purple]\n",
    "\n",
    "  0      1      2     3      4\n",
    "```\n",
    "\n",
    "Above you can see that `red` is the first value in the list. So, its index is `0`. The second value, `yellow`, is at index `1`. The third value is at index `2`. And so on.\n",
    "\n",
    "To access values in a list or tuple, you append the index enclosed within square brackets `[]` to the end of the variable. The examples below illustrate how to access individual items in a list and tuple:\n",
    "\n",
    "```python\n",
    "# print the third item of the list\n",
    "colors_list = ['red', 'green', 'blue', 'yellow']\n",
    "print(colors_list[2])\n",
    "\n",
    "# print the second item of the tuple\n",
    "numbers_tuple = (22, 33, 44, 55)\n",
    "print(numbers_tuple[1])\n",
    "```\n",
    "\n",
    "**OUTPUT**:\n",
    "\n",
    "```\n",
    "blue\n",
    "33\n",
    "```\n",
    "\n",
    "As you can see in the above output, the third item of the list and the second item of the tuple were printed. Another thing you may notice is that the values that were printed are not enclosed in brackets or parentheses, like when printing the list or tuple. When you access a specific item in a list or tuple, it is the data type associated with that item. In the two examples above, the first one is a string, while the second is an integer.\n",
    "\n",
    "Now, just focus on the code where the individual item of the list is accessed:\n",
    "\n",
    "```python\n",
    "colors_list[2]\n",
    "```\n",
    "\n",
    "The variable `colors_list` is followed by the left square bracket `[`, then the position/index of the item, finally followed by the closing, right square bracket `]`.\n",
    "\n",
    "---\n",
    "\n",
    "## Accessing the Last Item in a List or Tuple\n",
    "\n",
    "If you know the index of the last item, you can access it like you saw earlier. However, there is also a special index that can be used to access the last element, which is handy when you don't know how many items are in the collection.\n",
    "\n",
    "To access the last item in a list, you can specify `-1` as the index:\n",
    "\n",
    "```python\n",
    "# print the last item of the list\n",
    "colors_list = ['red', 'green', 'blue', 'yellow']\n",
    "print(colors_list[-1])\n",
    "\n",
    "# print the last item of the tuple\n",
    "numbers_tuple = (22, 33, 44, 55)\n",
    "print(numbers_tuple[-1])\n",
    "```\n",
    "\n",
    "**OUTPUT**:\n",
    "\n",
    "```\n",
    "yellow\n",
    "55\n",
    "```\n",
    "\n",
    "It doesn't stop there!\n",
    "\n",
    "To access the __next to the last item__, you can use `-2` as the index. You can use `-3` as the index to access the second from the last item. Basically, you can access the elements of a collection in reverse order, where the first item (the last in the list) starts with `-1`, and continues by reducing the index value by 1. Take a look:\n",
    "\n",
    "```python\n",
    "colors_list = ['red', 'green', 'blue', 'yellow']\n",
    "\n",
    "# access the last item with index `-1`\n",
    "first_from_end = colors_list[-1]\n",
    "\n",
    "# access the next-to-last item with index `-2`\n",
    "second_from_end = colors_list[-2]\n",
    "\n",
    "# access the second from the last item with index `-3`\n",
    "third_from_end = colors_list[-3]\n",
    "\n",
    "print(first_from_end)\n",
    "print(second_from_end)\n",
    "print(third_from_end)\n",
    "```\n",
    "\n",
    "**OUTPUT**:\n",
    "\n",
    "```\n",
    "yellow\n",
    "blue\n",
    "green\n",
    "```\n",
    "\n",
    "---\n",
    "\n",
    "## Accessing Multiple Items Within a Range\n",
    "\n",
    "You can also access a range of items within a collection. This is done by specifying the starting index, followed by a colon `:`, then specifying the ending index. While the item at the starting index will be returned, the item at the ending index will not. The ending index that is specified is non-inclusive, meaning that it specifies where to stop, but does not give you the value itself.\n",
    "\n",
    "* `[0:3]` - returns items at positions 0, 1, and 2\n",
    "* `[1:4]` - returns items at positions 1, 2, and 3\n",
    "\n",
    "Below are two examples:\n",
    "\n",
    "```python\n",
    "colors_list = ['red', 'green', 'blue', 'yellow']\n",
    "\n",
    "# get the first three items\n",
    "first_three_items = colors_list[0:3]\n",
    "\n",
    "# get the middle two items\n",
    "middle_two_items = colors_list[1:3]\n",
    "\n",
    "print(first_three_items)\n",
    "print(middle_two_items)\n",
    "```\n",
    "\n",
    "**OUTPUT**:\n",
    "\n",
    "```python\n",
    "['red', 'green', 'blue']\n",
    "['green', 'blue']\n",
    "```\n",
    "\n",
    "In the above code, the variables `first_three_items` and `middle_two_items` are lists. Do you know why? You're accessing multiple items of the list at one time, so it's returning those items as a list.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a0d02d5-04fa-4220-9637-d02c3b32dce5",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 10 - Modifying Lists<a class=\"anchor\" id=\"DS109L3_page_10\"></a>\n",
    "\n",
    "[Back to Top](#DS109L3_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "87898f54-46fe-454f-978d-7700da0fa4c7",
   "metadata": {},
   "source": [
    "# Modifying Lists\n",
    "\n",
    "If you recall, lists are mutable; they can be changed. Tuples, however, are immutable. You can add new items to a list, delete items from a list, and modify an existing item in a list.\n",
    "\n",
    "---\n",
    "## Modifying an Item in a List\n",
    "\n",
    "In order to make a change to an item in a list, it's as simple as assigning the specific item to a new value. You just learned how to access a specific element in a list, so now you get to combine steps together!\n",
    "\n",
    "Here's an example:\n",
    "\n",
    "```python\n",
    "# the starting list\n",
    "contacts = ['Sally', 'Bob', 'Mary', 'Steven']\n",
    "\n",
    "# Bob prefers to go by \"Robert\"\n",
    "# Bob is at index 1 in the list\n",
    "contacts[1] = \"Robert\"\n",
    "\n",
    "print(contacts)\n",
    "```\n",
    "\n",
    "**OUTPUT**:\n",
    "\n",
    "```\n",
    "['Sally', 'Robert', 'Mary', 'Steven']\n",
    "```\n",
    "\n",
    "The above code creates an initial list of people in a contact list: `contacts`. It then changes `Bob` to `Robert` by assigning the new value to the item at index `1`:\n",
    "\n",
    "```python\n",
    "contacts[1] = \"Robert\"\n",
    "```\n",
    "\n",
    "---\n",
    "\n",
    "## Another Example\n",
    "\n",
    "Below are a few more examples, and take special note of the last one:\n",
    "\n",
    "```python\n",
    "colors_list = ['white', 'white', 'white', 'white']\n",
    "print(colors_list)\n",
    "\n",
    "colors_list[0] = 'red'\n",
    "colors_list[1] = 'green'\n",
    "colors_list[2] = 'blue'\n",
    "colors_list[3] = 'yellow'\n",
    "print(colors_list)\n",
    "\n",
    "colors_list[-1] = 'purple'\n",
    "print(colors_list)\n",
    "```\n",
    "\n",
    "**OUTPUT**:\n",
    "\n",
    "```text\n",
    "['white', 'white', 'white', 'white']\n",
    "['red', 'green', 'blue', 'yellow']\n",
    "['red', 'green', 'blue', 'purple']\n",
    "```\n",
    "\n",
    "In the above code, the `colors_list` starts off with four `white` colors. Each item is then set to new values. Finally, the last item is set to `purple`. Did you notice the `-1` for the index? Remember the negative sign means that you are starting from the end and working your way forward!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a5b4d393-50b1-4e5a-be6a-9da98ba5784f",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 11 - Adding an Item to the End of the List<a class=\"anchor\" id=\"DS109L3_page_11\"></a>\n",
    "\n",
    "[Back to Top](#DS109L3_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c77ed56-46e8-4e9a-bd1f-75c3e3528521",
   "metadata": {},
   "source": [
    "# Adding an Item to the End of the List\n",
    "\n",
    "Let's say you want to add a new element to a list. For example, you might want to add new users to a website you've built. In order to add an item to a list, you use the `append` operation. You can only append one item at a time.\n",
    "\n",
    "Just like the `split` operation that you used on a string variable, `append` is used in the same fashion: adding a period `.` after the variable, then the `append` command. Using `append` requires that you provide it a single parameter: the item you wish to add.\n",
    "\n",
    "```python\n",
    "my_string = \"Hello there Bob\"\n",
    "\n",
    "# splits string into list using space as the delimiter/separator\n",
    "my_string_items = my_string.split()\n",
    "print(my_string_items)\n",
    "\n",
    "# but we forgot Sally!\n",
    "# add 'and' and 'Sally' to the list\n",
    "my_string_items.append(\"and\")\n",
    "my_string_items.append(\"Sally\")\n",
    "\n",
    "print(my_string_items)\n",
    "```\n",
    "\n",
    "**OUTPUT**:\n",
    "\n",
    "```\n",
    "['Hello', 'there', 'Bob']\n",
    "['Hello', 'there', 'Bob', 'and', 'Sally']\n",
    "```\n",
    "\n",
    "In the above code, the following lines add a new item to the list ('and' and 'Sally'):\n",
    "\n",
    "```python\n",
    "my_string_items.append(\"and\")\n",
    "my_string_items.append(\"Sally\")\n",
    "```\n",
    "\n",
    "Simple!\n",
    "\n",
    "Here are a few more examples:\n",
    "\n",
    "```python\n",
    "numbers = [1, 2, 3, 4, 5]\n",
    "\n",
    "# add 6 to the end\n",
    "numbers.append(6)\n",
    "\n",
    "# add 'seven' to the end\n",
    "numbers.append('seven')\n",
    "print(numbers)\n",
    "```\n",
    "\n",
    "**OUTPUT:**\n",
    "\n",
    "```python\n",
    "[1, 2, 3, 4, 5, 6, 'seven']\n",
    "```\n",
    "\n",
    "As you can see above, you can mix types: 'seven', a string, was added to the list which, at the time, consisted only of numbers.\n",
    "\n",
    "<div class=\"panel panel-warning\">\n",
    "    <div class=\"panel-heading\">\n",
    "        <h3 class=\"panel-title\">Try It!</h3>\n",
    "    </div>\n",
    "    <div class=\"panel-body\">\n",
    "        <p>Append three new elements to the end of a list and print your list to the terminal. Did you get all of the elements expected?</p>\n",
    "    </div>\n",
    "</div>\n",
    "\n",
    "---\n",
    "\n",
    "## Inserting an Item Into the List\n",
    "\n",
    "When you use `append`, it places the element at the end of the list. However, there will be times when you'll want to add an item to a list, but at a specific position.  This is called _insertion_, and the `insert` command is used. You can insert only one item at a time.\n",
    "\n",
    "Like the `append` command, `insert` requires the item to be added as a parameter. However, it also requires another parameter: the position of where the item should be inserted. This `index` parameter is actually the first one, while the item to be inserted is the second.\n",
    "\n",
    "```python\n",
    "a_list_variable.insert(index_value, item_to_add)\n",
    "```\n",
    "\n",
    "Here's an example:\n",
    "\n",
    "```python\n",
    "my_list = [1, 2, 4]\n",
    "\n",
    "# Oops! Forgot 3!\n",
    "my_list.insert(2, 3)\n",
    "print(my_list)\n",
    "```\n",
    "\n",
    "**OUTPUT**:\n",
    "\n",
    "```\n",
    "[1, 2, 3, 4]\n",
    "```\n",
    "\n",
    "In the example above, the value `3` is inserted into the `my_list` list at index `2`. Using numeric values might be confusing for remembering which parameter is the index. So, below, you'll find some more examples.\n",
    "\n",
    "```python\n",
    "my_list = [1, 2, 3, 5]\n",
    "\n",
    "# add 'zero' to the beginning of the list\n",
    "my_list.insert(0, 'zero')\n",
    "\n",
    "# insert `four' at index 4\n",
    "my_list.insert(4, 'four')\n",
    "\n",
    "print(my_list)\n",
    "```\n",
    "\n",
    "**OUTPUT**:\n",
    "\n",
    "```\n",
    "['zero', 1, 2, 3, 'four', 5]\n",
    "```\n",
    "\n",
    "As you can see in the above examples, you can insert mixed data types into a list. When you insert a new value at the specified index position, the old value is moved to the next available index position. For example, above, when 'zero' was inserted at index `0`, the value `1` moved to index 1, `2` moved to index 2, and so on.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d07df757-8334-43da-8037-dfd5fe9c1c2b",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 12 - Adding to List Activity<a class=\"anchor\" id=\"DS109L3_page_12\"></a>\n",
    "\n",
    "[Back to Top](#DS109L3_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "87133301-4f02-4f0f-bef2-c8658921dea3",
   "metadata": {},
   "source": [
    "Given the list `colors` below:\n",
    "\n",
    "- Insert the color `green` between `red` and `white`.\n",
    "- Insert the color `yellow` between `white` and `blue`.\n",
    "\n",
    "```python\n",
    "colors = ['red', 'white', 'blue']\n",
    "```\n",
    "Try below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eeb4cd0f-d23a-4adc-a5aa-8e317265ab0c",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "e3772fcc-4b6e-41a8-8328-4ed63b15565c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['red', 'green', 'white', 'yellow', 'blue']\n"
     ]
    }
   ],
   "source": [
    "# your answer should look like this\n",
    "answer = ['red', 'green', 'white', 'yellow', 'blue']\n",
    "print(answer)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e74a3e5a-be0e-47a1-9ab2-a22bc0eec088",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 13 - Removing an Item From a List<a class=\"anchor\" id=\"DS109L3_page_13\"></a>\n",
    "\n",
    "[Back to Top](#DS109L3_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce68174e-5f4c-40ee-85ab-80fd01ed4e9b",
   "metadata": {},
   "source": [
    "# Removing an Item From a List\n",
    "\n",
    "There will come a time when you need to remove items from a list. There are two ways to accomplish the task:\n",
    "\n",
    "- If you know the index of the item, you use the `del` command.\n",
    "\n",
    "- If you do __not__ know the index, you use the `.remove()` function, specifying the value to delete.\n",
    "\n",
    "Using either command above, you can only remove one item at a time.\n",
    "\n",
    "---\n",
    "\n",
    "## When You Know the Index - del\n",
    "\n",
    "If you know the index, you can remove an item from a list by using the `del` command. The item to be removed follows the command like so:\n",
    "\n",
    "```python\n",
    "numbers = [1, 2, 3, 4]\n",
    "\n",
    "# delete item at index 2\n",
    "del numbers[2]\n",
    "print(numbers)\n",
    "\n",
    "# the position of value 4 has changed\n",
    "# its index went from 3 to 2, due to the deletion\n",
    "\n",
    "# delete the first item\n",
    "del numbers[0]\n",
    "print(numbers)\n",
    "\n",
    "# delete the last item\n",
    "del numbers[-1]\n",
    "print(numbers)\n",
    "```\n",
    "\n",
    "**OUTPUT**:\n",
    "\n",
    "```\n",
    "[1, 2, 4]\n",
    "[2, 4]\n",
    "[2]\n",
    "```\n",
    "\n",
    "There are three uses of the `del` command above:\n",
    "\n",
    "```python\n",
    "del numbers[2]\n",
    "del numbers[0]\n",
    "del numbers[-1]\n",
    "```\n",
    "\n",
    "The first one deletes the item at index 2, or the third item. As you can see in the comments, this results in the index changing for the last item, namely `4`. Its index goes from 3 to 2.\n",
    "\n",
    "The second deletion removes the first item by using index `0`. The final one deletes the last item in the list using `-1` as the index.\n",
    "\n",
    "---\n",
    "\n",
    "## When You Don't Know the Index - .remove()\n",
    "\n",
    "If you do not know the index of the item you wish to remove, you can use the `remove` command. This command is like the `append` and `insert` commands, where you put a period `.` after the variable, followed by the command and its parameter. The parameter for the `remove` command is the value of the item that you wish to remove.\n",
    "\n",
    "Here's an example:\n",
    "\n",
    "```python\n",
    "colors = ['red', 'blue', 'yellow', 'green']\n",
    "colors.remove('yellow')\n",
    "print(colors)\n",
    "```\n",
    "\n",
    "**OUTPUT**:\n",
    "\n",
    "```\n",
    "['red', 'blue', 'green']\n",
    "```\n",
    "\n",
    "As you can see above, the item with the value 'yellow' is removed from the list `colors`.\n",
    "\n",
    "_But what if there are multiple items in the list with the same value_?\n",
    "\n",
    "Good question! When a list contains the same value multiple times, the __first__ item that matches will be removed, while the others will remain.\n",
    "\n",
    "```python\n",
    "colors = ['red', 'blue', 'red', 'green']\n",
    "colors.remove('red')\n",
    "print(colors)\n",
    "```\n",
    "\n",
    "**OUTPUT**:\n",
    "\n",
    "```\n",
    "['blue', 'red', 'green']\n",
    "```\n",
    "\n",
    "Great! Now you know how to add and insert items into a list, as well as remove them. Next, you'll learn about a few new useful commands that you can use that are related to lists.\n",
    "\n",
    "<div class=\"panel panel-success\">\n",
    "    <div class=\"panel-heading\">\n",
    "        <h3 class=\"panel-title\">Having Trouble with Lists?</h3>\n",
    "    </div>\n",
    "    <div class=\"panel-body\">\n",
    "        <p>You may want to watch this <a href=\"https://vimeo.com/428204013\"> recorded live workshop </a> that goes over lists in more depth.</p>\n",
    "    </div>\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "2f467363-b481-4b5d-94ea-12cf4d432f9c",
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    from DS_Students import MultipleChoice  \n",
    "except:\n",
    "    !pip install DS_Students\n",
    "    from DS_Students import MultipleChoice\n",
    "from ipynb.fs.full.DS109Questions import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "aac88e47-15dc-4e2e-ab36-3e2f579dd5f9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "8b9e0fd17c9a4e9b80fa35e1800dbe9e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '1. In this list [1, 2, 3, 4, 5], what number is at …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "586c42246a994606bcab23b3e6023b76",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '2. To select the last item of a list you can use wh…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "894f93050a4645ec9a1dd5606290d76a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '3. What is the proper syntax to retrieve the range …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "4e160dbaf1ef422c8dcb9dc9c3e817ec",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '4. Given a list of items named my_list, what will m…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "63db63bc2d5844c7960d849fc5fad760",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '5. Given the list my_list = [1, 2, 3, 4, 5], which …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "21411ebc61ca4afba1e350c446e7a85c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '6. Given the list my_list = [1, 2, 3, 4, 5], which …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "try:\n",
    "    display(L3P13Q1, L3P13Q2, L3P13Q3, L3P13Q4, L3P13Q5, L3P13Q6)\n",
    "except:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca8aeea3-7ab7-4a51-9bc3-4e54ee6feb4f",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 14 - Modifying Lists Activity<a class=\"anchor\" id=\"DS109L3_page_14\"></a>\n",
    "\n",
    "[Back to Top](#DS109L3_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3aa4ef4c-8063-4251-8cd9-dee7a4e1e984",
   "metadata": {},
   "source": [
    "Given the list `colors` below:\n",
    "\n",
    "- Correct each spelling of `yellw` to `yellow` (it's missing the 'o').\n",
    "\n",
    "- Remove all instances of `white`.\n",
    "\n",
    "- Add `purple` to the end of the list.\n",
    "\n",
    "Do not change the definition of the `colors` list. Modify the list instead.\n",
    "\n",
    "```python\n",
    "colors = ['green', 'white', 'green', 'yellw', 'yellw', 'white']\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "7227bb01-f181-4467-9454-abab73dabb44",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Try in the code cell\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "457bf7a9-ec75-4725-92c8-73fb4f2b7b25",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['green', 'green', 'yellow', 'yellow', 'purple']\n"
     ]
    }
   ],
   "source": [
    "#your answer should look like below:\n",
    "completed_colors = ['green', 'green', 'yellow', 'yellow', 'purple']\n",
    "print(completed_colors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "53ef268a-fe19-4d8a-9bf5-857bc8200fb0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['green', 'green', 'yellow', 'yellow', 'purple']\n"
     ]
    }
   ],
   "source": [
    "#helper code\n",
    "colors = ['green', 'white', 'green', 'yellw', 'yellw', 'white']\n",
    "colors[3] = 'yellow'\n",
    "colors[4] = 'yellow'\n",
    "colors.remove('white')\n",
    "colors.remove('white')\n",
    "colors.append('purple')\n",
    "print(colors)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7fceb1ba-06fa-46e9-8914-568efe5e8672",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 15 - Creating a List from a Range of Numbers<a class=\"anchor\" id=\"DS109L3_page_15\"></a>\n",
    "\n",
    "[Back to Top](#DS109L3_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88949d15-efa5-4b63-80a6-75506a60d126",
   "metadata": {},
   "source": [
    "# Creating a List from a Range of Numbers\n",
    "\n",
    "The function `range()` can be used to create a collection of numbers from a starting point to an ending point. It has three parameters: the starting value, the ending value (non-inclusive), and the size to increment between the starting and stopping values. Both the starting value and the step size parameters are optional.\n",
    "\n",
    "---\n",
    "\n",
    "## Storing Range as a List\n",
    "\n",
    "Since `range()` is a function, in order to use it as a `list`, it needs to be converted to a list using the `list()` function!\n",
    "\n",
    "Check out the example below:\n",
    "\n",
    "```python\n",
    "numbers = list(range(1, 11))\n",
    "print(numbers)\n",
    "```\n",
    "\n",
    "**OUTPUT:**\n",
    "\n",
    "```\n",
    "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    "```\n",
    "\n",
    "As you can see above, the `numbers` variable printed out as a list of numbers from 1 to 10 (remember the _stop_ parameter of `range` is non-inclusive). The first line of code creates a `list` object from the range that's created with `range(1, 11)`. You'll notice here that the default option to increment is `1` when it is not specified.\n",
    "\n",
    "---\n",
    "\n",
    "## Storing Range as a Variable\n",
    "\n",
    "The value of the range can also be stored as a variable:\n",
    "\n",
    "```python\n",
    "the_range = range(1, 11)\n",
    "numbers = list(the_range)\n",
    "```\n",
    "\n",
    "---\n",
    "\n",
    "## Range with No Start Value\n",
    "\n",
    "You can also exclude the starting value for a range. If you do, it will start from `0` by default.\n",
    "\n",
    "```python\n",
    "no_start_range = range(5)\n",
    "numbers = list(no_start_range)\n",
    "print(numbers)\n",
    "```\n",
    "\n",
    "**OUTPUT**:\n",
    "\n",
    "```\n",
    "[0, 1, 2, 3, 4]\n",
    "```\n",
    "\n",
    "---\n",
    "\n",
    "## Specify the Increment in the Range\n",
    "\n",
    "The optional third parameter for `range()` specifies how to increment from the starting value to the next value and so on. So, for example, if you wanted only the even numbers between 1 and 10, you would do:\n",
    "\n",
    "```python\n",
    "inc_by_2_range = range(2, 11, 2)\n",
    "numbers = list(inc_by_2_range)\n",
    "print(numbers)\n",
    "```\n",
    "\n",
    "**OUTPUT**:\n",
    "\n",
    "```\n",
    "[2, 4, 6, 8, 10]\n",
    "```\n",
    "\n",
    "Above, it start with `2` and ends at `11` (non-inclusive), but it uses a step size of `2`. Here's another:\n",
    "\n",
    "```python\n",
    "inc_by_10_range = range(0, 101, 10)\n",
    "numbers = list(inc_by_10_range)\n",
    "print(numbers)\n",
    "```\n",
    "\n",
    "**OUTPUT**:\n",
    "\n",
    "```\n",
    "[0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100]\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0046c959-6ad1-4e41-b291-01bdc8b0dcde",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 16 - Sorting a List<a class=\"anchor\" id=\"DS109L3_page_16\"></a>\n",
    "\n",
    "[Back to Top](#DS109L3_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a963dec-3478-4fd7-9e6a-3fa37b090896",
   "metadata": {},
   "source": [
    "# Sorting a List\n",
    "\n",
    "When storing data, your list may be created in an unpredictable order, as you cannot always control the order in which you receive data. However, there may come a time when you want to present the data in a particular order. To do so, Python provides an operation for sorting a list. The `sort()` function will take all of the elements of the list and place them in alphabetical or numerical order. After the `sort()` function is run on a list, the sequence of the list itself will change. It is a permanent change.\n",
    "\n",
    "```python\n",
    "numbers = [2, 6, 3, 9, 1, 10]\n",
    "strings = ['dog', 'cat', 'bird']\n",
    "\n",
    "#sort numerically\n",
    "numbers.sort()\n",
    "\n",
    "# sort alphabetically\n",
    "strings.sort()\n",
    "\n",
    "print(numbers)\n",
    "print(strings)\n",
    "```\n",
    "\n",
    "**OUTPUT:**\n",
    "\n",
    "```python\n",
    "[1, 2, 3, 6, 9, 10]\n",
    "['bird', 'cat', 'dog']\n",
    "```\n",
    "\n",
    "Here you can see the `sort()` function arranged the `numbers` list in numerical order starting with `1`, while it also sorted `strings` alphabetically. \n",
    "\n",
    "---\n",
    "\n",
    "## Sort in Descending Order\n",
    "\n",
    "What if you wanted to reverse that order? Python gives you a way to do just that by adding `reverse=True` to the sort operation.\n",
    "\n",
    "```python\n",
    "numbers = [2, 6, 3, 9, 1, 10]\n",
    "numbers.sort(reverse=True)\n",
    "print(numbers)\n",
    "```\n",
    "\n",
    "**OUTPUT:**\n",
    "\n",
    "```python\n",
    "[10, 9, 6, 3, 2, 1]\n",
    "```\n",
    "\n",
    "---\n",
    "\n",
    "## Non-Permanent Sorting\n",
    "\n",
    "What if you wanted to display the list in a sorted order, but did not want to affect the actual order of the list? This is when the `sorted()` function is useful! You can temporarily sort the elements of the list without affecting the actual list itself.\n",
    "\n",
    "Here's an example:\n",
    "\n",
    "```python\n",
    "numbers = [2, 6, 3, 9, 1, 10]\n",
    "\n",
    "print(\"This is the original set of numbers: \")\n",
    "print(numbers)\n",
    "\n",
    "print(\"This is the sorted set of numbers: \")\n",
    "print(sorted(numbers))\n",
    "\n",
    "print(\"This is the original set of numbers again: \")\n",
    "print(numbers)\n",
    "```\n",
    "\n",
    "**OUTPUT:**\n",
    "\n",
    "```python\n",
    "This is the original set of numbers:\n",
    "[2, 6, 3, 9, 1, 10]\n",
    "This is the sorted set of numbers:\n",
    "[1, 2, 3, 6, 9, 10]\n",
    "This is the original set of numbers again:\n",
    "[2, 6, 3, 9, 1, 10]\n",
    "```\n",
    "\n",
    "As you can see, the list can be sorted without changing the original list.\n",
    "\n",
    "Great! Now it's time to learn about how to iterate over the items in a collection. You will do that often in programming.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bba2290e-9acf-4efc-a9d4-6d3d24a17f29",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 17 - Iterating Over a Collection<a class=\"anchor\" id=\"DS109L3_page_17\"></a>\n",
    "\n",
    "[Back to Top](#DS109L3_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "763be804-e9c7-4ec3-9976-e9a9dca79dcc",
   "metadata": {},
   "source": [
    "# Iterating Over a Collection\n",
    "\n",
    "What is iterating? *Iteration* is the act of repeating a process to generate a sequence of outcomes with the aim of approaching a desired goal, target, or result.\n",
    "\n",
    "In the world of programming, when you have a collection of items, like a list, you can iterate over each item in the list to do something.\n",
    "\n",
    "In Python, there are two common mechanisms that you can use to iterate through a list: the for loop, and the while loop.\n",
    "\n",
    "---\n",
    "## For Loop\n",
    "\n",
    "To understand how to use a for loop, consider a situation where you have a list of countries, and you want to print them out. Of course, you already know that you can print out the actual list. You've already seen this:\n",
    "\n",
    "```python\n",
    "countries = ['USA', 'Canada', 'England', 'Ireland']\n",
    "print(countries)\n",
    "```\n",
    "\n",
    "**OUTPUT**:\n",
    "\n",
    "```\n",
    "['USA', 'Canada', 'England', 'Ireland']\n",
    "```\n",
    "\n",
    "If, however, you wanted to print out each country individually, instead of all at once, then you would need to iterate over the list and print each country as you get to it. \n",
    "\n",
    "The following code uses the for loop to do this:\n",
    "\n",
    "```python\n",
    "countries = ['USA', 'Canada', 'England', 'Ireland']\n",
    "\n",
    "# loop through list of countries using `for` loop\n",
    "for country in countries:\n",
    "    print(country)\n",
    "```\n",
    "\n",
    "**OUTPUT:**\n",
    "\n",
    "```\n",
    "USA\n",
    "Canada\n",
    "England\n",
    "Ireland\n",
    "```\n",
    "\n",
    "<div class=\"panel panel-info\">\n",
    "    <div class=\"panel-heading\">\n",
    "        <h3 class=\"panel-title\">Tip!</h3>\n",
    "    </div>\n",
    "    <div class=\"panel-body\">\n",
    "        <p>Don't forget to use proper indentation!</p>\n",
    "    </div>\n",
    "</div>\n",
    "\n",
    "As you can see, each element in the list was printed on a new line.\n",
    "\n",
    "Above, the variable `countries` is a list. `country` is a temporary variable that contains the value of each item in the list as it iterates over the list. The code below the line containing the `for` statement will be executed once per item.  Since there are four countries in the `countries` list, this means that it will `print()` four times.\n",
    "\n",
    "Did you notice the colon `:` after the `for country in countries`? Just like using an `if` or `else` keyword, a colon is required at the end of the for statement (but before the block of code that gets executed for each item in the list).\n",
    "\n",
    "If you were to translate the for loop code to spoken language, it could be read as:\n",
    "\n",
    "> For each country in the list of countries, print the country.\n",
    "\n",
    "---\n",
    "\n",
    "## Another Example\n",
    "\n",
    "Looping, or iterating, is an important concept to understand. Undoubtedly, you will need to iterate over lists throughout your programming career. So, below you will find another example to help you gain a solid understanding of iteration using a `for` loop.\n",
    "\n",
    "```python\n",
    "# 1. a list of numbers from 1-5\n",
    "all_numbers = [1, 2, 3, 4, 5]\n",
    "\n",
    "# 2. an empty list that will store even numbers\n",
    "even_numbers = []\n",
    "\n",
    "# 3. loop through `all_numbers` and add the even\n",
    "# numbers to the `even_numbers` list\n",
    "for the_number in all_numbers:\n",
    "    # 4. if the number is even, add to `even_numbers`\n",
    "    if the_number % 2 == 0:\n",
    "        even_numbers.append(the_number)\n",
    "    else:\n",
    "        print(\"Ignoring the odd number: \", the_number)\n",
    "\n",
    "# 5. print out `even_numbers`\n",
    "print(even_numbers)\n",
    "```\n",
    "\n",
    "**OUTPUT**:\n",
    "\n",
    "```\n",
    "Ignoring the odd number: 1\n",
    "Ignoring the odd number: 3\n",
    "Ignoring the odd number: 5\n",
    "[2, 4]\n",
    "```\n",
    "\n",
    "In the example above, there are numbered comments that will be discussed:\n",
    "\n",
    "1. The list `all_numbers` is created first, and it contains numbers from 1 through 5.\n",
    "\n",
    "2. An empty list variable named `even_numbers` is created. This list will, eventually, contain the list of even numbers of the `all_numbers` list.\n",
    "\n",
    "3. The `for` loop iterates over each number in the `all_numbers` list variable. The variable `the_number` will contain the value of each number of the list as it loops through. __A colon is required at the end of this line!__\n",
    "\n",
    "4. The four lines of code beneath this comment have the same indentation, so they are considered as one block of code that gets executed for each item in the list. First, it tests whether the current number of the list is even (`the_number % 2 == 0`), and if it is, it adds it to the `even_numbers` list. Otherwise, it prints out a message with the odd number.\n",
    "\n",
    "5. Once the `for` loop has finished iterating over the list of `all_numbers`, the `even_numbers` list should now contain the even numbers, and it is printed to the console.\n",
    "\n",
    "In both examples above, the `country` and `the_number` variables in the `for` loops are named as desired. They could have been named any way you'd like, but you should name them such that they make sense. Since the variable name for the list is plural (e.g. \"countries\"), the temporary variable that holds the current value while looping should be singular (e.g. \"country\"), since it represents an individual item.\n",
    "\n",
    "That's it! Next, you'll see another way you can iterate over a list.\n",
    "\n",
    "<div class=\"panel panel-warning\">\n",
    "    <div class=\"panel-heading\">\n",
    "        <h3 class=\"panel-title\">Try It Yourself!</h3>\n",
    "    </div>\n",
    "    <div class=\"panel-body\">\n",
    "        <p>Write three <code>for</code> loops that iterate through a list and prints out each item to the console.</p>\n",
    "    </div>\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "00391af0-ce6a-4dfb-b5ce-9a77a92dae68",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 18 - Iterating Lists Activity<a class=\"anchor\" id=\"DS109L3_page_18\"></a>\n",
    "\n",
    "[Back to Top](#DS109L3_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "39aa00cb-e2cc-4e15-bcda-d30a5ec733ad",
   "metadata": {},
   "source": [
    "Given the list of numbers `numbers` below:\n",
    "\n",
    "- Create a new list `doubled_numbers` that will contain the results of the next step.\n",
    "\n",
    "- Using a `for` loop, iterate over each value in the `numbers` list and double it. The doubled value should be inserted into/added to the list `doubled_numbers`.\n",
    "\n",
    "- The `doubled_numbers` list should have the same number of items as the `numbers` list, and each value should be double that of the corresponding value in the `numbers` list.\n",
    "\n",
    "For instance, if the `numbers` list contained [1, 2, 3], the `doubled_numbers` list should be [2, 4, 6]: each number was doubled.\n",
    "\n",
    "```python\n",
    "numbers = [10, 25, 50]\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "0a082abd-24c1-4b41-b05f-bfc8b9757998",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[20, 50, 100]\n"
     ]
    }
   ],
   "source": [
    "#the answer should be\n",
    "answer = [20, 50, 100]\n",
    "print(answer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "6e88c8d3-464a-48dc-a1bd-8d982c7f86e2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[20, 50, 100]\n"
     ]
    }
   ],
   "source": [
    "numbers = [10, 25, 50] #original numbers list\n",
    "doubled_numbers = [] # we created a new doubled_numbers list to hold the new values that we doubled when interating\n",
    "for number in numbers: # we interate over each number in the list called numbers\n",
    "    doubled_numbers.append(number * 2) # we append each number to the list while at the same time multiplying by 2\n",
    "\n",
    "print(doubled_numbers) # we print out new doubled_numbers list"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "414e943f-1ac7-4be9-92b9-b80cf98bb5bd",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 19 - While Loop<a class=\"anchor\" id=\"DS109L3_page_19\"></a>\n",
    "\n",
    "[Back to Top](#DS109L3_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b9a18fb-5029-46ad-8e5b-0784f087b568",
   "metadata": {},
   "source": [
    "# While Loop\n",
    "\n",
    "The `while` loop is another mechanism for iterating over the items of a list; it is similar to a `for` loop, but there is a noteworthy difference.\n",
    "\n",
    "A *for loop* takes a collection of elements and executes a command or series of commands once for each element in the collection. On the other hand, a *while loop* will run as long as, or __while__, a certain condition is `True`.\n",
    "\n",
    "For example, you could use a `while` loop to count up through a series of numbers:\n",
    "\n",
    "```python\n",
    "a_number = 1\n",
    "while a_number <= 5:\n",
    "  print(a_number)\n",
    "  a_number += 1\n",
    "```\n",
    "\n",
    "**OUTPUT:**\n",
    "\n",
    "```python\n",
    "1\n",
    "2\n",
    "3\n",
    "4\n",
    "5\n",
    "```\n",
    "\n",
    "The first line of code, above, initializes (creates) a number variable named `a_number` to the value of `1`. The `while` loop is then set to continue running _while_ the value of `a_number` is less than or equal to `5`. The code block within the loop prints out the number and then increments it by 1 (`a_number += 1`). Remember, the `+=` operator is shorthand &mdash; it could have been written as `a_number = a_number + 1`. Because you can overwrite variables, you will keep changing the value of `a_number` until that value gets to be `5`, at which point the `while` loop will stop because the condition of `a_number` less than 5 has no longer been met.\n",
    "\n",
    "---\n",
    "\n",
    "## Iterating over a List with a While Loop\n",
    "\n",
    "Great! As you can see, the `while` loops doesn't require a list variable to be used, but it can be used to iterate over a list like in the example below. The example is the same one as above that grabbed the even numbers from a list and put it in another list &mdash; it just uses a `while` loop instead of a `for` loop:\n",
    "\n",
    "```python\n",
    "all_numbers = [1, 2, 3, 4, 5]\n",
    "even_numbers = []\n",
    "\n",
    "# use a while loop to iterate over the list\n",
    "current_position = 0\n",
    "while current_position < len(all_numbers):\n",
    "    the_number = all_numbers[current_position]\n",
    "    if the_number % 2 == 0:\n",
    "        even_numbers.append(the_number)\n",
    "    else:\n",
    "        print(\"Ignoring the odd number: \", the_number)\n",
    "    current_position += 1\n",
    "\n",
    "print(even_numbers)\n",
    "```\n",
    "\n",
    "**OUTPUT**:\n",
    "\n",
    "```\n",
    "Ignoring the odd number: 1\n",
    "Ignoring the odd number: 3\n",
    "Ignoring the odd number: 5\n",
    "[2, 4]\n",
    "```\n",
    "\n",
    "In the above code, before the `while` loop, a variable `current_position` is used to track the current position within the `all_numbers` list starting at 0 (the first item in the list). With each iteration of the while loop:\n",
    "\n",
    "- The value of the item at index `current_position` of the `all_numbers` list is assigned to the variable `the_number`.\n",
    "\n",
    "- If `the_number` is even, it is added to the `even_numbers` list. Otherwise, a message is printed to the console.\n",
    "\n",
    "- Finally, the value of the `current_position` variable is incremented by 1.\n",
    "\n",
    "---\n",
    "\n",
    "## It Goes on and On and On...\n",
    "\n",
    "That's it! However, there is one important thing to consider when working with `while` loops. In the above code, the `while` loop finishes when the value of `current_position` is greater than or equal to the number of items in the `all_numbers` collection &mdash; so when it's 5 or more. What if the line of code that increments `current_position` was excluded? The condition to terminate the `while` loop would never be met, so the loop would continue on forever. NOT GOOD! Always ensure that your test condition can be satisfied without locking up the system with a never-ending loop.\n",
    "\n",
    "Now you know how to loop using `for` and `while`. However, what if you were just looking for something in a list and could stop looping once you found it? In the next section, you'll learn how you can terminate a loop.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "89888ba6-6f7f-46f4-ac97-7e7410341948",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "812ba9c3c4fd422a9cd8d52b4cb64fee",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '1. A while loop will run as long as a certain condi…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7d34d7405a324b1b943cbacdf56cdc2a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '2. When writing a for loop, it is best practice for…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "try:\n",
    "    display(L3P19Q1, L3P19Q2)\n",
    "except:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "44a1e957-53e2-48ec-b715-9030133c697c",
   "metadata": {},
   "source": [
    "```python\n",
    "\n",
    "cars = ['bmw', 'chevy', 'ford']\n",
    "\n",
    "for car in cars:\n",
    "\n",
    "print(car)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "b7f8016e-d8f0-407a-aa79-61351211ae7b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ebdd448f302b4239afff7b3be67972a5",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '3. In the above code snippet, what needs to be chan…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "try:\n",
    "    display(L3P19Q3)\n",
    "except:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a1cd711-d5bc-476f-a8c1-82061120aa74",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 20 - Terminating a For Loop<a class=\"anchor\" id=\"DS109L3_page_20\"></a>\n",
    "\n",
    "[Back to Top](#DS109L3_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a2df2f6a-b22a-4cd9-ba47-d756b5dc2c6d",
   "metadata": {},
   "source": [
    "# Terminating a For Loop\n",
    "\n",
    "When you need to terminate a loop before it completes iterating over a list using a `for` loop or a test condition is met, you would use the `break` statement. Take a look at the sample below:\n",
    "\n",
    "```python\n",
    "for letter in \"Sally\":\n",
    "  if letter == \"l\":\n",
    "    break\n",
    "  print(\"Current letter: \" + letter)\n",
    "\n",
    "print(\"The loop is over.\")\n",
    "```\n",
    "\n",
    "**OUTPUT:**\n",
    "\n",
    "```python\n",
    "Current letter: S\n",
    "Current letter: a\n",
    "The loop is over.\n",
    "```\n",
    "\n",
    "In the example above, the loop is terminated using `break` when the letter `l` is discovered. The line of code after the break will not be executed when `break` is called.\n",
    "\n",
    "---\n",
    "\n",
    "## Terminating a While Loop\n",
    "\n",
    "Here's an example using `break` within a `while` loop:\n",
    "\n",
    "```python\n",
    "a_number = 7\n",
    "\n",
    "while a_number > 0:\n",
    "    print(\"Current number value is:\", a_number)\n",
    "    a_number -= 1\n",
    "    if a_number == 4:\n",
    "        break\n",
    "\n",
    "print(\"The loop is over.\")\n",
    "```\n",
    "\n",
    "**OUTPUT:**\n",
    "\n",
    "```python\n",
    "Current number value is: 7\n",
    "Current number value is: 6\n",
    "Current number value is: 5\n",
    "The loop is over.\n",
    "```\n",
    "\n",
    "As you can see, the `break` statement stops the loop when the `a_number` variable reaches the value of 4.\n",
    "\n",
    "---\n",
    "\n",
    "## Skipping an Iteration of a Loop\n",
    "\n",
    "Using a `break` statement allows you to exit a loop immediately. But what if you need to skip an iteration? Consider an example where you're looking for a specific item within a list. For each item that does not match, you don't need to do anything, so just skip it. The key term for this is `continue`.\n",
    "\n",
    "```python\n",
    "everyone = ['Sally', 'Billy', 'Mary', 'Bob']\n",
    "looking_for = 'Mary'\n",
    "\n",
    "for person in everyone:\n",
    "    if person != looking_for:\n",
    "        continue\n",
    "    print(\"Found \" + looking_for + \"!\")\n",
    "```\n",
    "\n",
    "**OUTPUT**:\n",
    "\n",
    "```\n",
    "Found Mary!\n",
    "```\n",
    "\n",
    "The `continue` statement can be used in both _while_ and _for_ loops.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "41673c9c-2299-44cb-86a0-b0febf8d734e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "20bde73d73f84b38b3f5261bbd0bb165",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '1. Which statement will allow you to exit a loop im…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0821655e7c614d48b1ec9ba2d1e94e96",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '2. The continue statement can only be used in a for…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "1ffa1430f4ba4b38a10d86c5e4f4e327",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '3. The break statement is most commonly used when a…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "try:\n",
    "    display(L3P20Q1, L3P20Q2, L3P20Q3)\n",
    "except:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "47b89348-a850-4515-93db-97a8287c0a3f",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 21 - Key Terms<a class=\"anchor\" id=\"DS109L3_page_21\"></a>\n",
    "\n",
    "[Back to Top](#DS109L3_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97ee85e8-bd7f-41fd-ac86-ec4eddf8b56a",
   "metadata": {},
   "source": [
    "# Key Terms\n",
    "\n",
    "Below is a list and short description of the important keywords learned in this lesson. Please read through and go back and review any concepts you do not fully understand. Great Work!\n",
    "\n",
    "<table class=\"table table-striped\">\n",
    "    <tr>\n",
    "        <th>Keyword</th>\n",
    "        <th>Description</th>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>List</td>\n",
    "        <td>Data structure that holds a collection of objects; defined with [ ].</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>Nested List</td>\n",
    "        <td>A list of lists</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>Tuple</td>\n",
    "        <td>Data structure that holds unchangeable objects; defined with ( ).</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>Immutable</td>\n",
    "        <td>Cannot be modified.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>Iteration</td>\n",
    "        <td>Repeat a process multiple times for every piece in a series.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>for loop</td>\n",
    "        <td>A way to iterate that reads \"for this in that: do something\"</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>while loop</td>\n",
    "        <td>Iterates over a series, but only while a particular condition is true.</td>\n",
    "    </tr>\n",
    "</table>\n",
    "\n",
    "\n",
    "---\n",
    "\n",
    "## Key Python Code\n",
    "\n",
    "<table class=\"table table-striped\">\n",
    "    <tr>\n",
    "        <th>Keyword</th>\n",
    "        <th>Description</th>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>len()</td>\n",
    "        <td>A description of the keyword.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>.append()</td>\n",
    "        <td>Add new data to the end of a list.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>.insert()</td>\n",
    "        <td>Add new data to a list at a point specified by the index value.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>del</td>\n",
    "        <td>Remove an item from a list when you know the index number.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>.remove()</td>\n",
    "        <td>Get rid of an item in a list when you do not know its index.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>.range()</td>\n",
    "        <td>Generate random numbers, specifying a starting and ending point.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>.sort()</td>\n",
    "        <td>Order a list from A-Z or smallest to largest.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>.sort(reverse=True)</td>\n",
    "        <td>Order a list from Z-A or largest to smallest.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>sorted()</td>\n",
    "        <td>Temporarily sort a list without affecting it permanently.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>break</td>\n",
    "        <td>Stops a loop.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>continue</td>\n",
    "        <td>Allows you to skip over components in a loop.</td>\n",
    "    </tr>\n",
    "</table>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "922b100a-e8b6-4b01-98cd-6f0de748aa19",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 22 - Lesson 3 Practice Hands-On<a class=\"anchor\" id=\"DS109L3_page_22\"></a>\n",
    "\n",
    "[Back to Top](#DS109L3_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "097d6cf8-efeb-4399-ae38-3b5ff7a4478b",
   "metadata": {},
   "source": [
    "For your Lesson 3 Practice Hands-On, you will be working with your new knowledge of lists and loops. For this project, you will be creating a new directory, so please follow the below setup instructions. This Hands-On will **not** be graded, but we encourage you to complete it. The best way to become a great programmer is to practice! Once you have submitted your project, you will be able to access the solution on the next page.\n",
    "\n",
    "---\n",
    "\n",
    "## Setup\n",
    "\n",
    "1. First, open up your command prompt/terminal\n",
    "2. Within your command prompt/terminal, run the following command:\n",
    "    ```text\n",
    "    cd desktop\n",
    "    ```\n",
    "3. Next, run the following:\n",
    "    ```text\n",
    "    cd python_course\n",
    "    ```\n",
    "4. Run the following to create a new directory for this project:\n",
    "    ```text\n",
    "    mkdir lesson_three_handson\n",
    "    ```\n",
    "5. Open up a new window in VSCode.\n",
    "6. Click on the \"Explorer\" button on the left-hand side of the VSCode window.\n",
    "7. Click the `Open Folder` button.\n",
    "8. Select the `lesson_three_handson` directory within the `python_course` folder on your Desktop. Click the `Open` button.\n",
    "10. Create a new file named `main.py` by one of the following three ways:\n",
    "    - To the right of __LESSON_THREE_HANDSON__ in the EXPLORER is a button that looks like a piece of paper with a plus symbol in its top-left corner. If you hover your mouse over this button for a moment, a popup will appear indicating that this button will create a new file.\n",
    "    - Choose `File > New File` from the app's menu.\n",
    "    - Press `Control + N` in Windows or `Command + N` on a Mac (the plus means \"and at the same time\").\n",
    "\n",
    "Now you are ready to get started on your Lesson 3 Practice Hands-On!\n",
    "\n",
    "---\n",
    "\n",
    "## Requirements\n",
    "\n",
    "This hands-on is broken into three parts. Please complete each part within your `main.py` file.\n",
    "\n",
    "---\n",
    "## Part 1\n",
    "\n",
    "1. Create a list of the following first names: `Kurt`, `David`, `Katherine`.\n",
    "2. The variable name for the above list should be `list_of_names`.\n",
    "3. Use a `for` loop to loop through each name in the list and print the following question: `Where is _____ today?`\n",
    "    - Each name should replace the blank within the question.\n",
    "4. The output should look like the following:\n",
    "    ```text\n",
    "    Where is Kurt today?\n",
    "    Where is David today?\n",
    "    Where is Katherine today?\n",
    "    ```\n",
    "\n",
    "---\n",
    "## Part 2\n",
    "\n",
    "1. Create three separate lists with the following variable names: `my_favorite_cars`, `my_favorite_flowers`, `my_favorite_animals`\n",
    "    - `my_favorite_cars` should include 3 different cars\n",
    "    - `my_favorite_flowers` should include 4 different flowers\n",
    "    - `my_favorite_animals` should include 5 different animals\n",
    "2. Concatenate the above three lists into a single list named `my_favorite_things`.\n",
    "3. Use a `for` loop to iterate over each element of the `my_favorite_things` combined list. Print out each item with an even length.\n",
    "    - The output should show only items in the `my_favorite_things` list that have an even number of letters.\n",
    "\n",
    "---\n",
    "## Part 3\n",
    "\n",
    "Finally, add to your program new code that does the following:\n",
    "\n",
    "1. Create a list named `number_range` that includes the numbers 1 - 20\n",
    "2. Loop through the list\n",
    "3. For every number that is divisible by 3 _and_ 5, print `ZipZap`\n",
    "4. For every number that is divisible by 3, print `Zip`\n",
    "5. For every number that is divisible by 5, print `Zap`\n",
    "6. If the number is not divisible by any of the three, then just print the number.\n",
    "\n",
    "Your output should look like the following:\n",
    "\n",
    "```python\n",
    "1\n",
    "2\n",
    "Zip\n",
    "4\n",
    "Zap\n",
    "Zip\n",
    "7\n",
    "8\n",
    "Zip\n",
    "Zap\n",
    "11\n",
    "Zip\n",
    "13\n",
    "14\n",
    "ZipZap\n",
    "16\n",
    "17\n",
    "Zip\n",
    "19\n",
    "Zap\n",
    "```\n",
    "\n",
    "<div class=\"panel panel-danger\">\n",
    "    <div class=\"panel-heading\">\n",
    "        <h3 class=\"panel-title\">Caution!</h3>\n",
    "    </div>\n",
    "    <div class=\"panel-body\">\n",
    "        <p>Be sure to zip and submit your entire <code>lesson_three_handson</code> directory when finished!</p>\n",
    "    </div>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff54eed1-d9aa-4cc8-8e95-5b5437674705",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 23 - <a class=\"anchor\" id=\"DS109L3_page_23\"></a>\n",
    "\n",
    "[Back to Top](#DS109L3_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "22ee834d-6d53-4fa2-9822-d8a8e8f1776d",
   "metadata": {},
   "source": [
    "# Solution\n",
    "\n",
    "Below is the solution to your Lesson 3 Practice Hands-On.\n",
    "\n",
    "```python\n",
    "# Part 1\n",
    "list_of_names = ['Kurt', 'David', 'Katherine']\n",
    "\n",
    "for name in list_of_names:\n",
    "    print(\"Where is \" + name + \" today?\")\n",
    "\n",
    "# Part 2\n",
    "\n",
    "my_favorite_cars = [\"BMW\", \"Toyota\", \"Mazda\"]\n",
    "my_favorite_flowers = [\"Rose\", \"Sunflower\", \"Tulip\", \"Daisy\"]\n",
    "my_favorite_animals = [\"Cat\", \"Dog\", \"Giraffe\", \"Elephant\", \"Lion\"]\n",
    "\n",
    "my_favorite_things = my_favorite_cars + my_favorite_flowers + my_favorite_animals\n",
    "\n",
    "for thing in my_favorite_things:\n",
    "    if len(thing) % 2 == 0:\n",
    "        print(thing)\n",
    "\n",
    "# Part 3\n",
    "\n",
    "number_range = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]\n",
    "\n",
    "for number in number_range:\n",
    "    if number % 3 == 0 and number % 5 == 0:\n",
    "        print('ZipZap')\n",
    "    elif number % 3 == 0:\n",
    "        print('Zip')\n",
    "    elif number % 5 == 0:\n",
    "        print('Zap')\n",
    "    else:\n",
    "        print(number)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a791b2eb-457e-49c8-9ae1-3b32c93c3e5a",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}