Intro_to_Python_and_Jupyter.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "a825fb92",
   "metadata": {},
   "source": [
    "# Introduction to Python and Jupyter \n",
    "\n",
    "**Estimated time:** 15 minutes\n",
    "\n",
    "**Notebook developed by:** <br>\n",
    "Team Lead: Skye Pickett  <br>\n",
    "Fall 2022 Developers: Leah Hong, Emily Guo, Reynolds Zhang <br>\n",
    "Summer 2022 Developers: Vaidehi Bulusu, Leah Hong, Drishti Gupta, Hans Ocampo <br>\n",
    "\n",
    "\n",
    "### Learning Outcomes\n",
    "\n",
    "In this notebook, you will learn about:\n",
    "- Navigating a Jupyter Notebook\n",
    "- Basics of Coding in Python\n",
    "- How to Understand Tables\n",
    "\n",
    "\n",
    "## Table of Contents\n",
    "1. [Jupyter Basics](#1.-Jupyter-Basics)\n",
    "1. [Python Basics](#2.-Python-Basics)\n",
    "1. [Introduction to Tables](#3.-Introduction-to-Tables)\n",
    "1. [Conclusion](#4.-Conclusion)\n",
    "\n",
    "***\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6238f471",
   "metadata": {},
   "source": [
    "### Helpful Data Science Resources\n",
    "Here are some resources you can check out while doing this notebook!\n",
    "\n",
    "- [DATA 8 Textbook](https://inferentialthinking.com/chapters/03/1/Expressions.html) (also the reference source of this notebook)\n",
    "- [Reference Sheet for the datascience Module](http://data8.org/sp22/python-reference.html)（This is extremely helpful whenever you need a cheatsheet!)\n",
    "- [Documentation for the datascience Module](http://data8.org/datascience/index.html)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "637ebdda",
   "metadata": {},
   "source": [
    "# 1. Jupyter Basics"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4321db6-623a-4b13-9461-f4a0b6c09fde",
   "metadata": {},
   "source": [
    "### 1.1 Cells"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "995ad044",
   "metadata": {},
   "source": [
    "#### What is a cell?\n",
    "A cell is a block in the Notebook. This whole document is a Jupyter Notebook. Each cell will be highlighted when clicked on. For example, if you click on this text, you should see a thin gray rectangle, which outlines the cell."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58fe8206",
   "metadata": {},
   "source": [
    "#### Types of Cells\n",
    "\n",
    "**Markdown Cell**\n",
    "\n",
    "A markdown cell is where you write text. This cell a markdown cell! \n",
    "\n",
    "To edit a markdown cell, you must double click the cell's text. Try double clicking this block of text!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "827a1bac",
   "metadata": {},
   "source": [
    "**Code Cell**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "da9a1183",
   "metadata": {},
   "outputs": [],
   "source": [
    "# This is a code cell \n",
    "# A code cell is where you will write code\n",
    "# Errors can arise when you run code cells if there are any errors"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "087745e1",
   "metadata": {},
   "source": [
    "#### Adding a cell\n",
    "\n",
    "To add a cell, find the plus `+` sign on the tab bar above.\n",
    "\n",
    "When you add a cell, it is automatically a code cell.\n",
    "\n",
    "To switch from a code cell to a markdown cell, click the *Cell* button in the menu bar then click *Cell Type* then click *Markdown*."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "540d83f6",
   "metadata": {},
   "source": [
    "**Running a Cell**\n",
    "\n",
    "To run a code cell, click *shift+return* on your keyboard or the `Run` button in the tab bar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "60dab3c3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# try to run this cell\n",
    "\n",
    "1+12"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fe1dcbce-1630-4dd6-84a1-55f33eaa05a4",
   "metadata": {},
   "source": [
    "The above cell should return 13 below the cell."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "edf78160-4daa-462a-9828-013f6839a1af",
   "metadata": {},
   "source": [
    "### 1.2 Navigating the Notebook"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aba6ecd7",
   "metadata": {},
   "source": [
    "**Editing, saving, and submitting work**\n",
    "\n",
    "To delete a cell, you can click the *Scissors* icon in the tab bar or click the *Edit* button in the tab bar.  \n",
    "\n",
    "To save your notebook and your progress, click the *File* button in the tab bar.  \n",
    "**Tip:** It is important to ***Save and Checkpoint*** your progress in order to be able to revert back to your data if you need to restart your kernel!\n",
    "\n",
    "To submit your completed notebook, click the *File* button then the *Download as* button. Finally, download the notebook as  *Notebook (.ipynb)* or as *PDF*."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "547f7d3b",
   "metadata": {},
   "source": [
    "**How to get more Jupyter help**\n",
    "\n",
    "[\"Jupyter Notebook Tips, Tricks, and Shortcuts\"](https://dataquest.io/blog/jupyter-notebook-tips-tricks-shortcuts/): Here you can find some high level tools to get more function and variable information  as well as some tips on how to use Jupyter in other languages. (This is a way to give a better understanding of Jupyter and may appeal to students who have other programming language foundations.)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38a8cab2",
   "metadata": {},
   "source": [
    "*** \n",
    "# 2. Python Basics"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a030b82",
   "metadata": {
    "tags": [
     "ignore"
    ]
   },
   "source": [
    "**Python** is a popular programming language, for both data science and general software development. It gives us a way for us to communicate with the computer and give it instructions, which is why mastering the fundamentals is critical. \n",
    "\n",
    "Just like any language, Python has a set vocabulary made up of words it can understand, and a syntax which provides the rules for how to structure our commands and give instructions. \n",
    "\n",
    "### 2.1 Errors\n",
    "Errors in programming are common and totally okay! Don't be afraid when you see an error because more likely than not the solution lies in the error code itself! Let's see what an error looks like. <font color = #d14d0f>**Run the cell below to see the output.**</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "93b127ab",
   "metadata": {
    "tags": [
     "ignore"
    ]
   },
   "outputs": [],
   "source": [
    "print(\"This line is missing something.\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f878937",
   "metadata": {
    "tags": [
     "ignore"
    ]
   },
   "source": [
    "The last line of the error message in the output attempts to tell you what went wrong. You should see a message saying \"SyntaxError: unexpected EOF while parsing.\" This just means it expected a closing to your code in this instance. <font color = #d14d0f>**Try adding a parentheses to end the statement and watch the error message disappear!**</font>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ac8be02c",
   "metadata": {},
   "source": [
    "### 2.2 Expressions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "883036fd",
   "metadata": {},
   "source": [
    "Programs are made up of expressions, which describe to the computer how to combine pieces of data. For example, a multiplication expression consists of a * symbol between two numerical expressions. \n",
    "\n",
    "Expressions, such as 5 * 3, are evaluated by the computer. The value (the result of evaluation) of the last expression in each cell, 15 in this case, is displayed below the cell. <font color = #d14d0f>**Try running the cell below to see the value of the expression!**</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "75d7e906",
   "metadata": {},
   "outputs": [],
   "source": [
    "turtle = 5 * 3\n",
    "turtle"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6062be6",
   "metadata": {},
   "source": [
    "The grammar rules of a programming language are strict. In Python, the * symbol cannot appear twice in a row. Instead of computing the cell, it will show a SyntaxError error. The Syntax of a language is its set of grammar rules, and a SyntaxError indicates that an expression structure doesn’t match any of the rules of the language. <font color = #d14d0f>**Run the cell below to see the SyntaxError!**</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5ef8a4a3",
   "metadata": {},
   "outputs": [],
   "source": [
    "5 * * 3"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b2d33503",
   "metadata": {},
   "source": [
    "Small changes to an expression can change its meaning entirely. Below, the space between the \\*’s has been removed. Because ** appears between two numerical expressions, the expression is an exponentiation expression (the first number raised to the power of the second number, so 5 to the power of 3 or 5 times 5 times 5). The symbols * and ** are called operators, and the values they combine are called operands."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5b006b72",
   "metadata": {},
   "outputs": [],
   "source": [
    "5 ** 3"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "211f2fd4",
   "metadata": {},
   "source": [
    "#### Common Operators\n",
    "\n",
    "In Python, the following operators are essential:\n",
    "\n",
    "| Expression Type | Operator | Example | Value |\n",
    "| --- | --- | --- | --- |\n",
    "| Addition | + | 2 + 3 | 5 |\n",
    "| Subtraction | - | 2 - 3 | -1 |\n",
    "| Multiplication | * | 2 * 3 | 6 |\n",
    "| Division | / | 6 / 3 | 2 |\n",
    "| Remainder | % | 7 % 3 | 1 |\n",
    "| Exponentiation | ** | 2 ** 3 | 8 |"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8b1cd6e5",
   "metadata": {},
   "source": [
    "Python expressions obey the same familiar rules of PEMDAS as in algebra: multiplication and division occur before addition and subtraction. Parentheses can be used to group together smaller expressions within a larger expression. <font color = #d14d0f>**Try running the cell below to see the difference parentheses can make!**</font> "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "81c60dbf",
   "metadata": {},
   "outputs": [],
   "source": [
    "1 + 2 * 3 * 4 * 5 / 6 ** 3 + 7 + 8 - 9 + 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ebce4469",
   "metadata": {},
   "outputs": [],
   "source": [
    "1 + 2 * (3 * 4 * 5 / 6) ** 3 + 7 + 8 - 9 + 10"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c851941",
   "metadata": {
    "tags": [
     "ignore"
    ]
   },
   "source": [
    "#### Assignment Statements"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ae379f9",
   "metadata": {
    "tags": [
     "ignore"
    ]
   },
   "source": [
    "Names are given to values in Python using an **assignment statement**. An assignment statement consists of the name (on the left), followed by =, which is followed by any expression. \n",
    "\n",
    "The value of the expression to the right of the =, is **assigned** to the name (on the right). Once you've assigned an expression to a name, you can access that expression through the name in future instances. <font color = #d14d0f>**Try running the cell below to see how names are stored!**</font> "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f4081513",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 5 \n",
    "b = 7 \n",
    "a + b"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "afae4524",
   "metadata": {},
   "source": [
    "Sometimes, instead of trying to work with raw information all the time in a long calculation like 4 - 2 * (1 + 6 / 3) you will want to store it as an assignment statement for easy access in future calculations. <font color = #d14d0f>**Check out how we can use assignment statements to our advantage below!**</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "05a16f06",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Instead of performing this calculation over and over again ...\n",
    "4 - 2 * (1 + 6 / 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7871f99e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Try assigning it to a name for future use!\n",
    "y = 4 - 2 * (1 + 6 / 3)\n",
    "# This cell doesn't return anything since it only assigns and doesn't say to return y"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0e60a9c9",
   "metadata": {},
   "source": [
    "An assignment statement, such as `y = 4 - 2 * (1 + 6 / 3)` has three parts:\n",
    ">On the left is the variable name (y) <br>\n",
    "On the right is the variable's value (4 - 2 * (1 + 6 / 3)) <br> \n",
    "The equals sign in the middle tells the computer to assign the value to the name."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4b3e629c",
   "metadata": {},
   "source": [
    "You might have noticed that running that second cell did not output anything, however, we can access that value again and again in the future.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c4044d9b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# We can print the value as follows\n",
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "436a2898",
   "metadata": {},
   "outputs": [],
   "source": [
    "# We can also use it in other calculations now!\n",
    "y * 2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4d45c83",
   "metadata": {},
   "source": [
    "Names must start with a letter, but can contain both letters and numbers. A name cannot contain a space; instead, it is common to use an underscore character _ to replace each space.\n",
    "\n",
    "Names are only as useful as you make them; it’s up to the programmer to choose names that are easy to interpret. Typically, more meaningful names can be invented than a and b. For example, to describe the different types of data from a labor report, the following names clarify the meaning of the various quantities involved."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c787517e",
   "metadata": {},
   "outputs": [],
   "source": [
    "year = 2022\n",
    "unemployment_rate_females = 0.04\n",
    "unemployment_rate_males = 0.037\n",
    "total_unemployment_rate = unemployment_rate_females + unemployment_rate_males\n",
    "total_unemployment_rate"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da558431",
   "metadata": {},
   "source": [
    "## 2.3 Data Types"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f2b1eeea",
   "metadata": {},
   "source": [
    "Every value has a type, and the built-in `type` function returns the type of the result of any expression."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "907f5aa3",
   "metadata": {},
   "source": [
    "### Numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d1fda2c",
   "metadata": {},
   "source": [
    "One type we have encountered already is Numbers. \n",
    "\n",
    "Python distinguishes between two different types of numbers:\n",
    "\n",
    "**Integers are called int values** in the Python language. They can only represent whole numbers (negative, zero, or positive) that don’t have a fractional component.\n",
    "\n",
    "Recall earlier we ran a cell that stated: `a = 5`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "edfe3878",
   "metadata": {},
   "outputs": [],
   "source": [
    "#the \"a\" we just defined is an int type number\n",
    "type(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "104a1b76",
   "metadata": {},
   "source": [
    "**Real numbers are called float values** (or floating point values) in the Python language. They can represent whole or fractional numbers but have some limitations due to approximation.\n",
    "\n",
    "Recall earlier we ran a cell that stated:\n",
    "`y = 4 - 2 * (1 + 6 / 3)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "51bde03b",
   "metadata": {},
   "outputs": [],
   "source": [
    "#the \"y\" we just defined is a float type number\n",
    "type(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f69e93a",
   "metadata": {},
   "source": [
    "### Strings"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a6d2959",
   "metadata": {},
   "source": [
    "Much of the world’s data is text, and a piece of text represented in a computer is called a string. A string can represent a word, a sentence, or even the contents of every book in a library. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ac2ef7ad",
   "metadata": {},
   "source": [
    "The meaning of an expression depends both upon its structure and the types of values that are being combined. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f831f53d",
   "metadata": {},
   "source": [
    "So, for instance, adding two strings together produces another string. This expression is still an addition expression, but it is combining a different type of value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9e085eac",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"public\" + \" \" + \"policy\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "19295456",
   "metadata": {},
   "source": [
    "We use the `split()` method to split a string into a list. You can specify the separator (the default separator is any whitespace). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1db3ed78",
   "metadata": {},
   "outputs": [],
   "source": [
    "txt = \"welcome to PP190\"\n",
    "\n",
    "x = txt.split() \n",
    "\n",
    "# using the default separator \n",
    "\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bef807a3",
   "metadata": {},
   "outputs": [],
   "source": [
    "txt = \"one#two#three\"\n",
    "\n",
    "x = txt.split(\"#\") \n",
    "# specifying the separator\n",
    "\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1419a689",
   "metadata": {},
   "source": [
    "The string `join()` method returns a string by joining all the elements of an array, separated by the given separator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "de775f78",
   "metadata": {},
   "outputs": [],
   "source": [
    "text = ['PPC164A', 'is', 'a', 'fun', 'class.']\n",
    "\n",
    "# join elements of text with space\n",
    "print(' '.join(text))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a20e1be",
   "metadata": {},
   "source": [
    "The string `replace()` method replaces a specified phrase with another specified phrase."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9208275c",
   "metadata": {},
   "outputs": [],
   "source": [
    "txt = \"I like listening to pop music.\"\n",
    "\n",
    "x = txt.replace(\"pop\", \"country\").replace(\"like\", \"love\")\n",
    "\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ed24e8f",
   "metadata": {},
   "source": [
    "*** \n",
    "# 3. Introduction to Tables\n",
    "\n",
    "### What is a Table?\n",
    "\n",
    "A table is an object in Python that allows you to store data. It is a collection of rows and columns. Each row corresponds to one entry in the table and each column corresponds to a particular aspect you have data about. For example, say you have a table with information about 10 college students. It would have one row for each student and one column for each aspect of the students (e.g. name, major, year in college, etc.).\n",
    "\n",
    "### How to Use Tables\n",
    "\n",
    "You can create and edit tables using functions. One type of functions we can use on tables are called table methods. We use table methods in a specific format: table_name.method_name(any arguments). We'll look at plenty of examples of table methods below and in future notebooks!\n",
    "\n",
    "#### How to Create Tables\n",
    "\n",
    "Let's look at how to create tables. First, we have to import the `datascience` module using the following import statement:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1894ae62",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Run this cell (otherwise the next code cells will error)\n",
    "from datascience import *\n",
    "import numpy as np\n",
    "import otter\n",
    "grader = otter.Notebook()\n",
    "print(\"All necessary packages have been imported!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d42cec6e",
   "metadata": {},
   "source": [
    "A module is a collection of functions. We have to import modules using an import statement to use the functions they contain. We want to use the table functions in the `datascience` module, so we're importing it. The above statement is basically saying: from the `datascience` module, import all functions (which is what the * means).\n",
    "\n",
    "Next, we can create an empty table using the `Table()` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1b2ae0d9",
   "metadata": {},
   "outputs": [],
   "source": [
    "new_table = Table()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d4f43019",
   "metadata": {},
   "source": [
    "Here, we created a new variable called `new_table`, which is assigned to an empty table. Because it's an empty table, nothing shows up when we display it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "68c561bd",
   "metadata": {},
   "outputs": [],
   "source": [
    "new_table"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cd919718",
   "metadata": {},
   "source": [
    "Now, let's add some data to this table. We can do this by creating the columns we want the table to have, then adding those columns to the table.\n",
    "\n",
    "Each column is a collection of values of the same type. So, we can use the `make_array` function to create columns."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0b686fe2",
   "metadata": {},
   "outputs": [],
   "source": [
    "cafe_names = make_array(\"Peet's\", \"Romeo's\", \"Milano\", \"Strada\")\n",
    "cafe_prices = make_array(4, 5, 6.5, 3)\n",
    "\n",
    "# Like before, this cell won't return anything since it's only assignment statements"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "30a50cb9-3503-466a-b20f-41a9ee87c210",
   "metadata": {},
   "source": [
    "An **array** is essentially a list. As seen above, it can be made up of any items (like strings and integers and floats)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ff88821",
   "metadata": {},
   "source": [
    "Now we've created two columns for our table: one for the names of different cafes in Berkeley and one for the prices of their coffee *(note: prices are made-up)*. \n",
    "\n",
    "Now, let's add these columns to the table using the `.with_columns` method where our first argument is the name of the column and the second argument is the column values:\n",
    "\n",
    "\n",
    "\n",
    "> **`Table().with_columns(...)`**: create a new table by adding columns\n",
    "     "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d9164e74",
   "metadata": {},
   "outputs": [],
   "source": [
    "new_table = new_table.with_columns(\"Cafe Names\", cafe_names,\n",
    "                                  \"Cafe Prices\", cafe_prices)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a4290208",
   "metadata": {},
   "source": [
    "The first argument in the `.with_columns` method is the name of your column – make sure to enclose this name within single or double quotes. The second argument is the array with the values for this column.\n",
    "\n",
    "If we look at `new_table` now, we'll see that two new columns are added to it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7257cd1d",
   "metadata": {},
   "outputs": [],
   "source": [
    "new_table"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ec000f0",
   "metadata": {},
   "source": [
    "This is a good resource for learning about tables: https://inferentialthinking.com/chapters/06/Tables.html\n",
    "\n",
    "Feel free to also look through [documentation](http://data8.org/datascience/tables.html) on Tables, which lists the different methods of the `Table` object. We'll learn more about tables in future notebooks!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "54c0dde5",
   "metadata": {},
   "source": [
    "Below you will find a data dictionary for future reference. This data dictionary goes over what the column names mean in the data we are about to load."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bf5f1c84",
   "metadata": {},
   "source": [
    "| Column Name | Definition |\n",
    "| :- | :- |\n",
    "| year | The year the data in the row is for. |\n",
    "| overall_6_to_17 | The overall unemployment rate (%) for individuals with children strictly between the ages of 6 and 17. |\n",
    "| men_6_to_17 | The unemployment rate (%) for men with children strictly between the ages of 6 and 17. |\n",
    "| women_6_to_17 | The unemployment rate (%) for women with children strictly between the ages of 6 and 17. |\n",
    "| overall_under_6 | The overall unemployment rate (%) for individuals with children under the age of 6. |\n",
    "| men_under_6 | The unemployment rate (%) for men with children under the age of 6. |\n",
    "| women_under_6 | The unemployment rate (%) for women with children under the age of 6. |"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "11627acf",
   "metadata": {},
   "source": [
    "Now, we're going to load the data we're going to be working with! Run the cell below to see the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "76891a74",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Below we see an assignment statement.\n",
    "# We are telling the computer to create a Table and read in some data.\n",
    "unemployment = Table().read_table('Data/marital.csv')\n",
    "\n",
    "# This next command will display the top 5 entries. You can change the number to view a different amount of entries at time.\n",
    "unemployment.show(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ac091ba7",
   "metadata": {},
   "source": [
    "Now that we have the table loaded and saved with an assignment statement, we can start to use some of the table documentation that we introduced above to reorganize the data as we like!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2110a3b4",
   "metadata": {},
   "source": [
    "### Sorting"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "48efa318",
   "metadata": {},
   "source": [
    "\n",
    "Let's say that we want to specifcally see which years the unemployment rate was the highest for women with children under the age of 6.\n",
    "\n",
    "To do this, we would use the `tbl.sort` method, which creates a copy of a table sorted by the values in a column. The table generated will default to ascending order unless `descending = True` is included.\n",
    "\n",
    "Run the cell below to generate the sorted table!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8ecdd14b",
   "metadata": {},
   "outputs": [],
   "source": [
    "sorted_table = unemployment.sort(\"women_under_6\", descending = True) \n",
    "# We included descending = True because we want to see the years with the highest unemployment rate!\n",
    "\n",
    "sorted_table"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "704648b8-8292-4192-8767-bd96e82fef4a",
   "metadata": {},
   "source": [
    "Notice that the table produced earlier and the table presented now are the same data, but the rows are in a different order."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "29b37daf",
   "metadata": {},
   "source": [
    "### Selecting Column(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "160c185d",
   "metadata": {},
   "source": [
    "So, now we have a table with the sorted data, but we can still see the other columns! How would we generate a table with the sorted data, but just displaying the column we want to see?\n",
    "\n",
    "To accomplish this, we would use the `tbl.select` method, which creates a copy of the table displaying only the column(s) specified.\n",
    "\n",
    "Run the cell below to see the table with just the sorted data!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0fef25d7",
   "metadata": {},
   "outputs": [],
   "source": [
    "filtered_table = sorted_table.select(\"year\", \"women_under_6\") # Place the column name in quotes\n",
    "filtered_table"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10bfb922",
   "metadata": {},
   "source": [
    "### Grouping Columns"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9192d7cb",
   "metadata": {},
   "source": [
    "Data scientists often need to classify individuals into groups according to shared features, and then identify some characteristics of the groups."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5162274c-b1c4-42d2-ad41-3f91abdbbe1e",
   "metadata": {},
   "source": [
    "\n",
    "[This page on the `group` function](https://inferentialthinking.com/chapters/08/3/Cross-Classifying_by_More_than_One_Variable.html?highlight=group) from the Data8 Textbook is an excellent resource with great examples!\n",
    "\n",
    "Let's try using the group function. \n",
    "> **`tablename.group(column_name(s), func)`**: Group rows by unique values or combinations of values in a column(s). Multiple columns must be entered in array or list form. Other values aggregated by count (default) or optional argument func."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d9fad51-ed9e-4f5c-8a92-fff556aff0c6",
   "metadata": {},
   "source": [
    "Below, the `group` method lists every distinct year in the unemployment table. Since there is no function provided as seen in the above documentation, it counts the number of rows that have each year in the dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "22b950d0",
   "metadata": {},
   "outputs": [],
   "source": [
    "grouped_years = unemployment.group('year')\n",
    "grouped_years"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3cd2f05a-4fb0-40db-a7ac-c526a65b8255",
   "metadata": {},
   "source": [
    "The result of the previous code cell shows that all the years appear just once in this table."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "435af7fd",
   "metadata": {},
   "source": [
    "Now that we have some of the basic table manipulation concepts down, let's attempt to play around with the data a little! Let's try to find the difference in the average unemployment rates of men and women with children under 6.\n",
    "\n",
    "First, we'll need to find the average unemployment rates of both columns. To store all the values of a column as an array, use the `.column` function, and type in the name of the column."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "97ed81ae",
   "metadata": {},
   "outputs": [],
   "source": [
    "# This will store the values in the 'men_under_6' column as an array!\n",
    "men_column = unemployment.column('men_under_6')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c6b71ee-4b36-48ae-b8fb-9d1350a86be5",
   "metadata": {},
   "source": [
    "<!-- BEGIN QUESTION -->\n",
    "<font color = #d14d0f>\n",
    "\n",
    "#### **Question 1:**\n",
    "Now you try! In the cell below, replace the ... with the column name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9a1d843e-fe4b-452e-ba23-52c1f7f215f5",
   "metadata": {},
   "outputs": [],
   "source": [
    "women_column = unemployment.column(...)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae2a2013",
   "metadata": {},
   "source": [
    "<!-- END QUESTION -->\n",
    "<!-- BEGIN QUESTION -->\n",
    "<font color = #d14d0f>\n",
    "    \n",
    "#### Question 2:\n",
    "Next, we want to find the average unemployment rates of the respective columns. For this, we need to use the `.mean` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c91b97c5",
   "metadata": {},
   "outputs": [],
   "source": [
    "men_averages = np.mean(men_column)\n",
    "\n",
    "# Now you try!\n",
    "women_averages = np.mean(...)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b351afe7",
   "metadata": {},
   "source": [
    "<!-- END QUESTION -->\n",
    "Now, to find the difference between the average unemployment rates, we will subtract one from the other."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6371da29",
   "metadata": {},
   "outputs": [],
   "source": [
    "difference = women_averages - men_averages\n",
    "difference"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e786939",
   "metadata": {},
   "source": [
    "<!-- BEGIN QUESTION -->\n",
    "<font color = #d14d0f>\n",
    "    \n",
    "#### Question 3:\n",
    "What about the median unemployment rates of the respective columns? For this, we need to use the `np.median` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2f4acb2f",
   "metadata": {},
   "outputs": [],
   "source": [
    "men_median = np.median(men_column)\n",
    "\n",
    "# Now you try!\n",
    "women_median = ..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e2f5124",
   "metadata": {},
   "source": [
    "<!-- END QUESTION -->\n",
    "<!-- BEGIN QUESTION -->\n",
    "<font color = #d14d0f>\n",
    "\n",
    "#### Question 4:\n",
    "\n",
    "What about the standard deviation for unemployment rates of the respective columns? For this, we need to use the `np.std` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ebb52de1",
   "metadata": {},
   "outputs": [],
   "source": [
    "men_sd = np.std(men_column)\n",
    "\n",
    "# Now you try!\n",
    "women_sd = ..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "741263ed",
   "metadata": {},
   "source": [
    "<!-- END QUESTION -->\n",
    "<!-- BEGIN QUESTION -->\n",
    "<font color = #d14d0f>\n",
    "\n",
    "#### Question 5:    \n",
    "\n",
    "What are the ranges for unemployment rates of the respective columns? Remember that range is the difference between the largest and smallest numbers. For this, we need to use the `max` and `min` functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ce0bcb71",
   "metadata": {},
   "outputs": [],
   "source": [
    "men_range = max(men_column) - min(men_column)\n",
    "\n",
    "# Now you try!\n",
    "women_range = ..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1388a602",
   "metadata": {},
   "source": [
    "<!-- END QUESTION -->\n",
    "***\n",
    "# 4. Conclusion"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "22f0210c-fcee-46a9-9880-f39b59976022",
   "metadata": {},
   "source": [
    "### Congratulations! You have finished the notebook! ##"
   ]
  }
 ],
 "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.11.9"
  },
  "vscode": {
   "interpreter": {
    "hash": "844e5ba5d4c316c035929c4fd91388752dd6dce21e7d80073ac03afad47246bb"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}