Exemplar_ Lists & tuples.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "KBiVrAwUswaC"
   },
   "source": [
    "<h1>Exemplar: Introduction to lists and tuples</h1>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "h6Ek5LgkszCv"
   },
   "source": [
    "## Introduction \n",
    "\n",
    "In this lab, you will practice creating, modifying, and working with data structures in Python. This will develop your knowledge of different kinds of data structures and the different operations that you can perform with them to answer questions about the data. This will help you prepare for projects you may encounter where you will need to use data structures to store and keep track of data.\n",
    "\n",
    "For this activity, you are part of a research team that focuses on air quality, and you have received a few data points collected by the U.S. Environmental Protection Agency (EPA). Your goal is to store and organize this data, so that it can be accessed and updated easily.\n",
    "\n",
    "In this lab, you'll be working specifically with the state names and county names of places that reported air quality index readings."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "9PsbdqW9s1Ti"
   },
   "source": [
    "## Tips for completing this lab\n",
    "\n",
    "As you navigate this lab, keep the following tips in mind:\n",
    "\n",
    "- `### YOUR CODE HERE ###` indicates where you should write code. Be sure to replace this with your own code before running the code cell.\n",
    "- Feel free to open the hints for additional guidance as you work on each task.\n",
    "- To enter your answer to a question, double-click the markdown cell to edit. Be sure to replace the \"[Double-click to enter your responses here.]\" with your own answer.\n",
    "- You can save your work manually by clicking File and then Save in the menu bar at the top of the notebook.\n",
    "- You can download your work locally by clicking File and then Download and then specifying your preferred file format in the menu bar at the top of the notebook."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Be_AFo3JtZnv"
   },
   "source": [
    "## Task 1: Create lists and use tuples\n",
    "\n",
    "As you continue your work with the EPA, you want to create an ordered data structure containing pairs of values, which can be iterated over to gain insights from the data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4oWGIKOPxgoF"
   },
   "source": [
    "### 1a: Create lists\n",
    "\n",
    "You'll work with state names and county names indicated below.\n",
    "\n",
    "| state_name | county_name |\n",
    "| --- | --- |\n",
    "| Arizona | Maricopa |\n",
    "| California | Alameda |\n",
    "| California | Sacramento |\n",
    "| Kentucky | Jefferson |\n",
    "| Louisiana | East Baton Rouge |\n",
    "\n",
    "<br/>\n",
    "\n",
    "\n",
    "*  In this task, assign two variables:\n",
    "\n",
    "    1. `state_names` - a `list` of each state in the `state_name` column in the table above, in order, as strings\n",
    "    2. `county_names` - a `list` of each county in the `county_name` column in the table above, in order, as strings\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "id": "mifeWTLK9RSL"
   },
   "outputs": [],
   "source": [
    "# 1. ### YOUR CODE HERE ###\n",
    "state_names = [\"Arizona\", \"California\", \"California\", \"Kentucky\", \"Louisiana\"]\n",
    "\n",
    "# 2. ### YOUR CODE HERE ###\n",
    "county_names = [\"Maricopa\", \"Alameda\", \"Sacramento\", \"Jefferson\", \"East Baton Rouge\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "wLdpH1tZNUh7"
   },
   "source": [
    "<details><summary><h4>Hint</h4></summary>\n",
    "\n",
    "Refer to what you've learned about the syntax for instantiating lists.\n",
    "\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ncDkZB1gxzDq"
   },
   "source": [
    "### 1b: Use a loop to combine the lists into a single list of tuples\n",
    "\n",
    "* Use `state_names` and `county_names` to:\n",
    "    * Create a new list of tuples, where each tuple contains a pair of state name and county name.\n",
    "    * Assign the new list to a variable called `state_county_tuples`.\n",
    "* Print the result\n",
    "\n",
    "*Expected result:*\n",
    "\n",
    "```\n",
    "[OUT] [('Arizona', 'Maricopa'),\n",
    "       ('California', 'Alameda'),\n",
    "       ('California', 'Sacramento'),\n",
    "       ('Kentucky', 'Jefferson'),\n",
    "       ('Louisiana', 'East Baton Rouge')]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 198,
     "status": "ok",
     "timestamp": 1680215612444,
     "user": {
      "displayName": "Matteo Riotto",
      "userId": "15211004813978485634"
     },
     "user_tz": 420
    },
    "id": "4wZijs-JI5q9",
    "outputId": "ab56737b-cea0-480c-f9e4-48b4a8aad058"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('Arizona', 'Maricopa'),\n",
       " ('California', 'Alameda'),\n",
       " ('California', 'Sacramento'),\n",
       " ('Kentucky', 'Jefferson'),\n",
       " ('Louisiana', 'East Baton Rouge')]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "### YOUR CODE HERE ###\n",
    "state_county_tuples = []\n",
    "for i in range(len(state_names)):\n",
    "    state_county_tuples.append((state_names[i], county_names[i]))\n",
    "\n",
    "state_county_tuples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "YNHrym4yPusC"
   },
   "source": [
    "<details><summary><h4>Hint 1</h4></summary>\n",
    "\n",
    "There are several ways to accomplish this task. One way could involve looping over the elements of each list and, with each iteration, assigning a tuple consisting of `(state_names[i], county_names[i])`, which could then be used to build the `state_county_tuples` list.\n",
    "\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "o4b_8cnMUH8x"
   },
   "source": [
    "<details><summary><h4>Hint 2</h4></summary>\n",
    "\n",
    "Use the `len()` function and the `range()` function to generate the appropriate number of iterations for a `for` loop.\n",
    "\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "wxRAYAviZJtA"
   },
   "source": [
    "<details><summary><h4>Hint 3</h4></summary>\n",
    "\n",
    "1. Instantiate `state_county_tuples` as an empty list\n",
    "2. Write a `for` loop to iterate over `range(len(state_names))`\n",
    "3. With each iteration, append `(state_names[i], county_names[i])` to `state_county_tuples`\n",
    "\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "fEEo-2zEaVtA"
   },
   "source": [
    "### 1c: Do the same thing using the `zip()` function\n",
    "\n",
    "Python has a built-in function to make the above process much easier. It's called the `zip()` function. This function accepts any number of iterable objects as arguments. If the arguments are all of equal length, the function returns an iterator object of tuples, where each tuple contains `element[i]` of each argument.\n",
    "\n",
    "You can then either loop over the iterator object or pass it to the `list()` function to unpack its values.\n",
    "\n",
    "Refer to the [zip() Python documentation](https://docs.python.org/3/library/functions.html#zip) for more information.\n",
    "\n",
    "Here's an example:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 176,
     "status": "ok",
     "timestamp": 1680215616018,
     "user": {
      "displayName": "Matteo Riotto",
      "userId": "15211004813978485634"
     },
     "user_tz": 420
    },
    "id": "Ok6_9uQEbDba",
    "outputId": "b498d005-7b05-4ac3-ac99-3ec1124b356d"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<zip object at 0x7f717452fd70>\n",
      "[('a', 1), ('b', 2), ('c', 3)]\n"
     ]
    }
   ],
   "source": [
    "# RUN THIS CELL\n",
    "a = ['a', 'b', 'c']\n",
    "b = [1, 2, 3]\n",
    "c = zip(a, b)\n",
    "\n",
    "print(c)\n",
    "print(list(c))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "XiYt-05zeSMo"
   },
   "source": [
    "Use the `zip()` function to generate the same output created in Task 1b.\n",
    "\n",
    "1. Use `state_names` and `county_names` to:\n",
    "    * Create a new list of tuples, where each tuple contains a pair of state name and county name.\n",
    "    * Assign the new list to a variable called `state_county_zipped`.\n",
    "2. Check that `state_county_zipped` is the same as `state_county_tuples`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 196,
     "status": "ok",
     "timestamp": 1680215617920,
     "user": {
      "displayName": "Matteo Riotto",
      "userId": "15211004813978485634"
     },
     "user_tz": 420
    },
    "id": "OfQvejUZJo5T",
    "outputId": "1c086d2f-fcb7-4de8-cbf0-22dbfefb33ee"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 1. ### YOUR CODE HERE ###\n",
    "state_county_zipped = list(zip(state_names, county_names))\n",
    "\n",
    "# 2. ### YOUR CODE HERE ###\n",
    "state_county_zipped == state_county_tuples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "fPWkM_KGtg_i"
   },
   "source": [
    "<details><summary><h4>Hint 1</h4></summary>\n",
    "\n",
    "Refer to the example of the `zip()` function provided above.\n",
    "\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "u7dcpH60tg3O"
   },
   "source": [
    "<details><summary><h4>Hint 2</h4></summary>\n",
    "\n",
    "Don't forget to convert the result of the zip operation to a list.\n",
    "\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "om5EmUcFtgvZ"
   },
   "source": [
    "<details><summary><h4>Hint 3</h4></summary>\n",
    "\n",
    "1. Use `list(zip(state_names, county_names))` and assign the result to `state_county_zipped`.\n",
    "\n",
    "2. Test for equality with `state_county_tuples` using the `==` operator.\n",
    "\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "s_2Z9SArtgno"
   },
   "source": [
    "## Task 2: Use list comprehension to convert to list of lists\n",
    "\n",
    "Since tuples are immutable and can't be changed, converting tuples to lists is a practice data professionals use so they can make adjustments to the data, if necessary.\n",
    "\n",
    "* Use a list comprehension to convert `state_county_tuples` from a list of tuples to a list of lists. Assign the result to a variable called `state_county_lists`.\n",
    "\n",
    "* Print the result.\n",
    "\n",
    "*Expected result:*\n",
    "\n",
    "```\n",
    "[OUT] [['Arizona', 'Maricopa'],\n",
    "       ['California', 'Alameda'],\n",
    "       ['California', 'Sacramento'],\n",
    "       ['Kentucky', 'Jefferson'],\n",
    "       ['Louisiana', 'East Baton Rouge']]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 201,
     "status": "ok",
     "timestamp": 1680215622689,
     "user": {
      "displayName": "Matteo Riotto",
      "userId": "15211004813978485634"
     },
     "user_tz": 420
    },
    "id": "2MPPyoLZhZ4j",
    "outputId": "e5d01096-b24d-4e34-9ec9-22cfe52bec38"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['Arizona', 'Maricopa'],\n",
       " ['California', 'Alameda'],\n",
       " ['California', 'Sacramento'],\n",
       " ['Kentucky', 'Jefferson'],\n",
       " ['Louisiana', 'East Baton Rouge']]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "### YOUR CODE HERE\n",
    "state_county_lists = [list(i) for i in state_county_tuples]\n",
    "state_county_lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "s-YNkMmARTBg"
   },
   "source": [
    "<details><summary><h4>Hint 1</h4></summary>\n",
    "\n",
    "Refer to what you've learned about list comprehension.\n",
    "\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "JURyZsP6RSy6"
   },
   "source": [
    "<details><summary><h4>Hint 2</h4></summary>\n",
    "\n",
    "Remember that list comprehensions are like loops written in reverse:\n",
    "\n",
    "`[{operation to perform} for {element} in {iterable}]`\n",
    "\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "aa1gE-13RSgM"
   },
   "source": [
    "<details><summary><h4>Hint 3</h4></summary>\n",
    "\n",
    "There are multiple ways to perform this operation. The simplest uses the `list()` function on each element in `state_county_zipped`.\n",
    "\n",
    "Another way is to use indexing to unpack each tuple into a list.\n",
    "\n",
    "`[[i[0], i[1]] for i in state_county_tuples]`\n",
    "\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "dEcBjMF1GZWo"
   },
   "source": [
    "## Task 3: Unpacking an iterable\n",
    "\n",
    "Data professionals often use the technique of unpacking to work with individual elements of iterable objects. As you continue in your work as an analyst, you are asked to iterate through your list of state/county pairs to identify only the counties in California.\n",
    "\n",
    "As a refresher, here is the data you have been working with:\n",
    "\n",
    "| state_name | county_name |\n",
    "| --- | --- |\n",
    "| Arizona | Maricopa |\n",
    "| California | Alameda |\n",
    "| California | Sacramento |\n",
    "| Kentucky | Jefferson |\n",
    "| Louisiana | East Baton Rouge |\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "xDabjCpI7qRz"
   },
   "source": [
    "### 3a: Unpacking in a loop\n",
    "\n",
    "* Write a loop that unpacks each tuple in `state_county_tuples` and, if the state in the tuple is `California`, add the corresponding county to a list called `ca_counties`.\n",
    "\n",
    "*Expected output:*\n",
    "\n",
    "```\n",
    "[OUT] ['Alameda', 'Sacramento']\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 259,
     "status": "ok",
     "timestamp": 1680220162897,
     "user": {
      "displayName": "Matteo Riotto",
      "userId": "15211004813978485634"
     },
     "user_tz": 420
    },
    "id": "fnM_zydH7HU9",
    "outputId": "6a14ffb7-eff9-4b35-94fb-d1e9b85e3f98"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Alameda', 'Sacramento']"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "### YOUR CODE HERE ###\n",
    "ca_counties = []\n",
    "for state, county in state_county_tuples:\n",
    "    if state=='California':\n",
    "        ca_counties.append(county)\n",
    "ca_counties"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "JMD5CxfI80o1"
   },
   "source": [
    "<details><summary><h4>Hint 1</h4></summary>\n",
    "\n",
    "Refer to what you learned about unpacking tuples, `for` loops, conditional statements, and `list` methods.\n",
    "\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "DOvKJGDR9Mme"
   },
   "source": [
    "<details><summary><h4>Hint 2</h4></summary>\n",
    "\n",
    "To unpack a tuple in a loop, you must assign each of its elements to a variable. Each tuple in `state_county_tuples` has two elements, so instead of writing `for a in x`, you must write `for a, b in x`.\n",
    "\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "gytbqb8O-kzJ"
   },
   "source": [
    "<details><summary><h4>Hint 3</h4></summary>\n",
    "\n",
    "* Instantiate the `ca_counties` list before you begin writing your loop.\n",
    "\n",
    "* With each iteration of the loop:\n",
    "    1. Unpack each tuple in `state_county_tuples`:\n",
    "     ```\n",
    "     for state, county in state_county_tuples:\n",
    "     ```\n",
    "    2. Check whether `state` is California:\n",
    "    ```\n",
    "    if state == 'California':\n",
    "    ```\n",
    "    3. If it is, append `county` to `ca_counties`:\n",
    "    ```\n",
    "    ca_counties.append(county)\n",
    "    ```\n",
    "\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "nDdaoVyd76_u"
   },
   "source": [
    "### 3b: Unpacking in a list comprehension\n",
    "\n",
    "Now, use a list comprehension to accomplish the same thing as what you did in Task 3a.\n",
    "\n",
    "* In a list comprehension, unpack each tuple in `state_county_tuples` and, if the state in the tuple is `California`, add the corresponding county to the list comprehension.\n",
    "\n",
    "* Assign the result to a variable called `ca_counties`.\n",
    "\n",
    "* Print `ca_counties`.\n",
    "\n",
    "*Expected output:*\n",
    "\n",
    "```\n",
    "[OUT] ['Alameda', 'Sacramento']\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 208,
     "status": "ok",
     "timestamp": 1680218613985,
     "user": {
      "displayName": "Matteo Riotto",
      "userId": "15211004813978485634"
     },
     "user_tz": 420
    },
    "id": "Du9vZxAaydOa",
    "outputId": "52802e68-9448-4ebd-aeab-b82edc92deba"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Alameda', 'Sacramento']"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "### YOUR CODE HERE ###\n",
    "ca_counties = [county for (state, county) in state_county_tuples if state=='California']\n",
    "ca_counties"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "jCt4G5zxGgU7"
   },
   "source": [
    "<details><summary><h4>Hint 1</h4></summary>\n",
    "\n",
    "Refer to what you learned about list comprehension syntax. Also refer to previous tasks and examples in this lab.\n",
    "\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "DkJ31iPxGgNI"
   },
   "source": [
    "<details><summary><h4>Hint 2</h4></summary>\n",
    "\n",
    "It can be helpful to progress towards the goal in smaller steps. For example, first try to create a list comprehension that unpacks the `county` from each `state, county` pair, resulting in a list of *all* the counties.\n",
    "\n",
    "If you can do that, then tweak the list comprehension by adding a conditional statement that only keeps the `county` if its corresponding `state` is `California`.\n",
    "\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "EhhBU4IbGgGW"
   },
   "source": [
    "<details><summary><h4>Hint 3</h4></summary>\n",
    "\n",
    "Consider the following syntax:\n",
    "\n",
    "```\n",
    "[___ for (___, ___) in _________ if __________]\n",
    "```\n",
    "\n",
    "</details>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "a9do9ZntRTKa"
   },
   "source": [
    "## Conclusion\n",
    "\n",
    "**What are your key takeaways from this lab?**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "czqqJEAaR71s"
   },
   "source": [
    "- Lists and tuples are important iterable data types in Python that share many characteristics.\n",
    "- Tuples in Python are useful for storing data in ordered sequences that are preserved and cannot be modified after creation.\n",
    "- The `zip()` function is very useful for combining iterable objects element-wise.\n",
    "- Tuples and lists can be unpacked.\n",
    "- List comprehensions are quick and efficient ways to execute loop-like processes in a single line of code that results in a list.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Congratulations!** You've completed this lab. However, you may not notice a green check mark next to this item on Coursera's platform. Please continue your progress regardless of the check mark. Just click on the \"save\" icon at the top of this notebook to ensure your work has been logged. "
   ]
  }
 ],
 "metadata": {
  "colab": {
   "provenance": [],
   "toc_visible": true
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}