pandas.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "59a2d3de-f2c0-4afe-a54a-5e294d266273",
   "metadata": {},
   "source": [
    "# pandas"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e7f4b330-9e0a-4ad5-98b4-e54bebd3a3d7",
   "metadata": {},
   "source": [
    "- Pandas is one of the most commonly used Python packages/libraries/modules for data science.<br><br>\n",
    "- Pandas is Python's answer for making two dimensional tables (ala Excel and SQL).<br><br>\n",
    "- Pandas calls a table a \"DataFrame\".<br><br>\n",
    "- Pandas DataFrames are used by Python's other packages for statistical analysis, data manipulation, and data visualization.<br><br>\n",
    "- Pandas DataFrames can be exported as .csv and other files.<br><br>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2d00bfc0-4a81-47d9-ab3a-a25a1fe60aaa",
   "metadata": {},
   "source": [
    "The pandas syntax isn't very instinctual. Some of the syntax will differ from basic Python. I still have to look a lot of things up in pandas, if it's something I don't do very often. However, it is the tool for working with spreadsheets in Python, so you'll need to learn it at some point.<br><br>\n",
    "Pandas is written as more of a *functional* language than basic Python. This means that instead of manipulating objects, we'll be applying more functions across our data."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a2d4bf7-cc0c-401e-8d7f-0991ff5e7a85",
   "metadata": {},
   "source": [
    "#### <br>Why do we work with Jupyter Notebooks for data science?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "033b772e-5946-432b-aa51-9d501b3e7758",
   "metadata": {},
   "source": [
    "Jupyter Notebooks allow us to view nicely formatted output (such as pandas DataFrames and data visualizations) directly below the code used to create the object. They also allow you to scroll through large DataFrames or images."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b0c1dbbb-5312-4cf1-bb75-82774efc3190",
   "metadata": {},
   "source": [
    "#### <br>NumPy arrays\n",
    "This week is going to focus on the Python package Pandas. However, Pandas (and many other Python packages) are built on NumPy arrays. NumPy is another Python module, and NumPy arrays are multi-dimensional datasets made up entirely of numerical data. They allow for much faster calculations than other basic Python objects. If you work with large numerical datasets, you will also want to look into the NumPy package. NumPy arrays do not have the features that many of us want to work with, such as column headers and the ability to work with non-numerical data; that's why pandas is so popular."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf83b2a9-28b9-44f0-9ae1-1dd9367d7162",
   "metadata": {},
   "source": [
    "## <br><br><br>Importing pandas"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b493b70-6ed7-4af4-bea4-1effec56e603",
   "metadata": {},
   "source": [
    "Because pandas is one of the most commonly used Python packages, it often gets imported as a shortened version of it's actual name. This makes it quicker to type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1b96aee5-766e-4ace-b7c1-21ba17809d98",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7caeb892-3b60-42d3-a172-832db988e604",
   "metadata": {},
   "source": [
    "Pandas comes with the Anaconda distribution of Python and is available on Google Colab."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b726cf1-7ef4-4530-ad63-374715e48b0c",
   "metadata": {},
   "source": [
    "## <br><br><br>PART ONE: LOADING AND VIEWING DATAFRAMES"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "17684dc2-0354-416a-b777-bf3430e27567",
   "metadata": {},
   "source": [
    "### <br>Opening files from your computer"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "79718441-3bcb-472c-a4c7-036ddfde025d",
   "metadata": {},
   "source": [
    "#### If you are using Google Colab, you must run the next line of code. *If you are NOT using Google Colab, do NOT run the next line.*\n",
    "Google Colab requires you to load data files into your workspace by hand (or by using this trick to pull them in from github)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9a46bce5-8d87-4b71-bec6-10c3a1f4e2b8",
   "metadata": {},
   "outputs": [],
   "source": [
    "!wget https://raw.githubusercontent.com/aGitHasNoName/pandasBasics/main/wnba-team-elo-ratings.csv\n",
    "!wget https://raw.githubusercontent.com/aGitHasNoName/pandasBasics/main/pigeonRacing.txt\n",
    "!wget https://raw.githubusercontent.com/aGitHasNoName/pandasBasics/main/zoo.xlsx"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3bee105d-c718-4ee8-95a8-77d8b98eb19e",
   "metadata": {},
   "source": [
    "### <br><br><br>Loading a csv file"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b2f470eb-6b9d-4007-a2fa-7cb028d63c7d",
   "metadata": {},
   "source": [
    "We will use the function `pd.read_csv()`. As a reminder, when we use a function from an imported module, we first give the module's name, followed by a dot, followed by the function name.\n",
    "<br><br>This will automatically create a **DataFrame** object, which we are saving as `df`. `df` is a common variable name for a DataFrame. You can open the file, define it as a Pandas DataFrame, assign it to a variable, and close the file in one line. (Already we're seeing the differences from basic Python)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6ed11452-979d-4d67-853e-e1cacd5baf89",
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv(\"wnba-team-elo-ratings.csv\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "99b8b8a0-e1f6-4a2e-9a21-ff52206ff561",
   "metadata": {},
   "source": [
    "<br><br>Our sample dataset was taken from FiveThirtyEight. It contains game data for WNBA games since 1997."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3abad5eb-2de4-4ed2-8285-6d0d62ec704b",
   "metadata": {},
   "source": [
    "### <br><br><br>Viewing the DataFrame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "169f37f5-fc47-40d6-82c8-323eac82f60a",
   "metadata": {},
   "outputs": [],
   "source": [
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ada87b22-8011-4e98-b349-74d7892cd475",
   "metadata": {},
   "source": [
    "<br>Take a minute to look at the data. The DataFrame will have a slightly different look on Colab and Jupyter, and on different versions of Jupyter.\n",
    "<br><br>The number at the beginning of each row is called an **index**. The index was automatically assigned by pandas when the dataset was loaded. It was not in the original csv file. It is merely a series of consecutive numbers going down the rows. The rows were loaded in whatever order they were in the csv file."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "139e5c60-4bd8-4a6a-a708-c1a2d22ad0e3",
   "metadata": {},
   "source": [
    "If you are working in Google Colab, there is a new feature that lets you magically convert your DataFrame into an interactive table. We're NOT going to use that feature, though you can feel free to explore it on your own time. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "15ffe23c-6090-4253-8136-db80aabfc9da",
   "metadata": {},
   "source": [
    "<br><br>There are ways to view pieces of the DataFrame. Try these to see what they do:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "21b419ef-4fd1-42b2-8033-e0609b240f78",
   "metadata": {},
   "outputs": [],
   "source": [
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d06549f4-9340-4f19-bc15-bdf5eaa9da8b",
   "metadata": {},
   "outputs": [],
   "source": [
    "df.head(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "848ea7e2-dbc2-43e3-a879-1864bc5bce05",
   "metadata": {},
   "outputs": [],
   "source": [
    "df.tail()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5f99ffae-91cb-47dc-8fb1-e0d01c026c7a",
   "metadata": {},
   "outputs": [],
   "source": [
    "df.tail(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e3c93e9c-262c-44b1-9666-96ec5c4407e5",
   "metadata": {},
   "outputs": [],
   "source": [
    "df.sample()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5959de80-7806-4c3c-b974-1941c4c875d3",
   "metadata": {},
   "outputs": [],
   "source": [
    "df.sample(6)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7804e54b-201f-47e4-9207-053aee88be97",
   "metadata": {},
   "source": [
    "### <br><br><br>Loading other types of files"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0559c0d4-8019-441a-985b-2c00dc293254",
   "metadata": {},
   "source": [
    "We can open a tab-separated file using the same function we used to open a csv. We just have to pass a second argument, a **keyword argument**, to tell it that the delimiter is a tab instead of the default (comma). This dataset contains rankings of profressional racing pigeons."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "702d1bf6-ab06-4840-b454-109c84348cea",
   "metadata": {},
   "outputs": [],
   "source": [
    "pigeon_df = pd.read_csv(\"pigeonRacing.txt\", delimiter=\"\\t\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d7c0f42d-0e34-40e5-8338-b326095ee00e",
   "metadata": {},
   "outputs": [],
   "source": [
    "pigeon_df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8837778b-8e96-42ab-9279-5e75bceb199c",
   "metadata": {},
   "source": [
    "<br><br>We will use a different function to open an Excel file. This file has information about animals and has two sheets within the excel file. We will first load sheet 1 and then sheet 2. We have to pass the `read_excel()` function one extra argument to specify the sheet:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7c158d46-2f49-483d-8a62-e14f20b0a6c7",
   "metadata": {},
   "outputs": [],
   "source": [
    "zoo_df = pd.read_excel(\"zoo.xlsx\", sheet_name=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f9cdf71f-c051-42db-8d35-b301ebdaf1f8",
   "metadata": {},
   "outputs": [],
   "source": [
    "zoo_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cf493098-de3d-48e9-b9f8-5d2c5fc99a79",
   "metadata": {},
   "outputs": [],
   "source": [
    "zoo_class_df = pd.read_excel(\"zoo.xlsx\", sheet_name=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a614aa41-3e12-457a-9f65-584a3b98b0ab",
   "metadata": {},
   "outputs": [],
   "source": [
    "zoo_class_df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41047684-b6e4-4983-ab11-169782c9b029",
   "metadata": {},
   "source": [
    "### <br><br>Exercise 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98ba836d-4925-4026-a4ff-8e0af898f2c7",
   "metadata": {},
   "source": [
    "Try to load two or three files from your own computer into pandas. Try with at least two different file types (csv, tab-delimited, excel). You can copy and paste the files into today's workshop folder, or you can open them by using the full path to the file (for example, \"\\~/Documents/myfolder/myfile.xlsx\" or \"\\~\\Documents\\myfolder\\myfile.csv\")."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "12decee2-1668-4ae5-b58a-ed1a2038c404",
   "metadata": {},
   "source": [
    "<br>**If you are using Google Colab**, you will need to upload the files to Colab yourself. You can do this by clicking on the folder on the left menu. You should see a file tree come up that includes sample_data. Right click anywhere in this space and choose upload to upload your own files."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "be593ebd-4ae2-4d4f-bdb3-ff743c9498ab",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9e537b55-d918-4df4-b43b-ee18dbdbad2b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6bfe1681-6b7b-44e2-8e0c-65751464d927",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "f5f6c568-a611-4bb1-b36c-11244906b5ca",
   "metadata": {},
   "source": [
    "### <br><br><br>Getting basic info about the DataFrame"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ca39c8b-4b2f-4baf-90d6-b45b5c6bd4c0",
   "metadata": {},
   "source": [
    "You can use the `len()` function to find out how many rows are in a DataFrame object:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "47e27d66-48b1-4e0c-99f7-69d1e9755aa5",
   "metadata": {},
   "outputs": [],
   "source": [
    "len(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d0b5146c-77eb-4923-84c3-0d771fddbbdd",
   "metadata": {},
   "source": [
    "<br>The `describe()` method will give you some very basic stats about each column in your DataFrame:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ee1b17d4-81d4-42f1-b584-18e49361ce8d",
   "metadata": {},
   "outputs": [],
   "source": [
    "df.describe()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d0772ca9-9784-4ea2-8b79-33bfc23efe1c",
   "metadata": {},
   "source": [
    "<br>The `shape` attribute will return the number of rows and columns as a tuple. An attribute gives us some stored data about an object - it is not a method function, so it does not get parentheses."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3c198928-2fd2-41ab-9f50-01bd57347c62",
   "metadata": {},
   "outputs": [],
   "source": [
    "df.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4df6da40-ca29-437b-8d15-4a91e95e92b6",
   "metadata": {},
   "source": [
    "You can even save the shape tuple as an object, in case you need to include it in any code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ef080b39-916d-49ab-8e4e-c8f46c9504bb",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_shape = df.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "24546350-5e1f-4b44-a7b3-c86b8a99244b",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Our DataFrame has \" + str(df_shape[0]) + \" rows and \" + str(df_shape[1]) + \" columns.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1678f7ec-7f18-42ce-8fd6-033afd48b6c5",
   "metadata": {},
   "source": [
    "<br>The `size` attribute will tell you the total number of elements in the DataFrame (size = rows x columns):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "42785a65-750e-41ad-b7ec-316a08d92f84",
   "metadata": {},
   "outputs": [],
   "source": [
    "df.size"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e0d18135-10e0-4b80-b033-8bcb7893492c",
   "metadata": {},
   "source": [
    "<br>To return a list of the column names, you can start with the `columns` attribute:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f76d1e85-ec06-4a20-a880-e7c7ef6ec31d",
   "metadata": {},
   "outputs": [],
   "source": [
    "df.columns"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d8f1c8cb-d4f3-497b-b2f7-0322ef672caf",
   "metadata": {},
   "source": [
    "Hmm. That looks strange because it is a pandas object. You can make it into a list so that it is easier to work with:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "816c7e65-6a5b-4a1a-9abb-0b9074712016",
   "metadata": {},
   "outputs": [],
   "source": [
    "column_names = list(df.columns)\n",
    "print(column_names)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "76131bc7-fd7a-4ca1-ad54-2cfd48a801d9",
   "metadata": {},
   "source": [
    "<br>To find out the data types of the data found in each column, use the `dtypes` attribute:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "29e11ace-5786-4240-ac4c-695c8cdd0aa0",
   "metadata": {},
   "outputs": [],
   "source": [
    "df.dtypes"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a727130-0d81-4959-b88d-a2b0509252d7",
   "metadata": {},
   "source": [
    "<br>To **transpose** a DataFrame (swap the rows and columns), you also use an attribute. Let's transpose `zoo_df`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f4785770-ec65-4901-b948-a17b4291d727",
   "metadata": {},
   "outputs": [],
   "source": [
    "zoo_df.T"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "53ed919c-2376-461d-bd6d-2a53b1f80c55",
   "metadata": {},
   "source": [
    "<br>Let's see if that changed our DataFrame object:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e21da875-ab56-4734-9d50-7d5f497f0f97",
   "metadata": {},
   "outputs": [],
   "source": [
    "zoo_df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0d612c4f-45d9-446f-9522-eb3ace390356",
   "metadata": {},
   "source": [
    "<br><br>It didn't change! DataFrames are **immutable objects** like strings and numpy arrays. To save the transposed DataFrame, we would have to reassign it to a variable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b63fdd7d-62a9-4a3f-9d36-1c74911ccc0c",
   "metadata": {},
   "outputs": [],
   "source": [
    "zoo_df_t = zoo_df.T\n",
    "zoo_df_t"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0937b97b-0076-485c-acca-8e05fc541051",
   "metadata": {},
   "source": [
    "### <br><br>Exercise 2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0e36cb80-e4a1-4b1c-91f2-da0785deccbb",
   "metadata": {},
   "source": [
    "Write code to create a list of column names from `zoo_df`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "21c02665-e5d1-4b40-8766-67f6685e8302",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "986a65d3-7135-443c-a3ae-de17cbdb700a",
   "metadata": {},
   "source": [
    "Write code to return the data type for each column in `zoo_df`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7b051b1c-d698-4722-bc96-19d12cf1d2aa",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "536f593c-9941-45cf-9f44-a737c33f9560",
   "metadata": {},
   "source": [
    "## <br><br><br>PART TWO: SELECTING DATA"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "084353cd-6545-4c22-9656-f9d2f8f7189a",
   "metadata": {},
   "source": [
    "There are multiple ways to select data in pandas. You will need to learn all of the ways because you will see these techniques being used in other people's code and in answers to your pandas questions when you search online.\n",
    "<br><br>We will cover:\n",
    "- Selecting columns using DataFrame indexing\n",
    "- Selecting rows based on a boolean condition using DataFrame indexing\n",
    "- Selecting columns, rows, and individual data points with `loc` and `iloc`\n",
    "- Selecting individual data points with `at` and `iat`\n",
    "*You cannot select individual data points using indexing.*"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9895468a-410e-4174-b676-b5503ec04b17",
   "metadata": {},
   "source": [
    "We will work with the WNBA game data. Let's look at it again:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e42066c8-60b0-449a-a3d3-846aa7b1a81e",
   "metadata": {},
   "outputs": [],
   "source": [
    "df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "324f3565-5dc2-4482-b9d3-7fd03b8aaf1c",
   "metadata": {
    "tags": []
   },
   "source": [
    "### <br><br>Selecting columns or rows using indexing"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "84f3e993-04b8-43e2-a608-cc2a81356029",
   "metadata": {},
   "source": [
    "To create a DataFrame with only some columns, you use indexing, and you pass it a list of the columns that you want to include:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "26f7e111-8e1b-4abb-abe5-8932d4e6e6bb",
   "metadata": {},
   "outputs": [],
   "source": [
    "my_columns = [\"season\", \"team1\", \"team2\"]\n",
    "df[my_columns]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "758552dc-d1aa-4438-9c7f-059c0dbc1757",
   "metadata": {},
   "source": [
    "<br>OR you could just include the list inside the indexing. This creates two sets of square brackets, which looks a little silly, but it works!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2c605f4b-db6a-4430-9c7c-b8e78e01bd31",
   "metadata": {},
   "outputs": [],
   "source": [
    "df[[\"season\", \"team1\", \"team2\"]]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "64ee3f9b-7ca4-41d5-9344-3678085c1441",
   "metadata": {},
   "source": [
    "<br>If you want to return just one column as a DataFrame, you still use the list inside the index:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9c8c54eb-5adb-4e90-97ca-1fc0f46b70d6",
   "metadata": {},
   "outputs": [],
   "source": [
    "df[[\"date\"]]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da91f6c3-8548-402d-8283-fbfa71764cf4",
   "metadata": {},
   "source": [
    "### <br><br>Exercise 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07ab06d0-1613-440d-a350-45008be17d4a",
   "metadata": {},
   "source": [
    "Here's a reminder of what the DataFrame looks like:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "089c2dd0-02e9-4d21-b543-b57a8804e4ac",
   "metadata": {},
   "outputs": [],
   "source": [
    "df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce13baab-eb29-4c8b-84d3-72a2533f9bd6",
   "metadata": {},
   "source": [
    "Write code to return the name1, name2, and is_home1 columns:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3d689a06-5424-4d8a-875b-eec479243a4c",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "50dd3462-a9c5-4232-bd42-3193aa424715",
   "metadata": {},
   "source": [
    "Write code to return the playoff column:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "77d5766f-95cb-4237-927e-5f797d74978d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "92d26f14-13b5-4b16-b940-f4764d22fb2d",
   "metadata": {},
   "source": [
    "<br><br><br>If you only index the column name, without putting it in a list, you get a different type of pandas object - the **Series** object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "99c46638-438f-486b-a12d-6e19206453d8",
   "metadata": {},
   "outputs": [],
   "source": [
    "df[\"date\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1a56797-3221-454f-b483-8eca893cffdf",
   "metadata": {},
   "source": [
    "<br>A Series object only returns the values from one column. It can be turned into a list, which is very convenient:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "44e0725d-677d-4255-9010-a5ac78ccddce",
   "metadata": {},
   "outputs": [],
   "source": [
    "date_list = list(df[\"date\"])\n",
    "print(len(date_list))\n",
    "print(type(date_list))\n",
    "print(date_list[0:5])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "783476a5-2155-4ab8-8dab-64779bb726d8",
   "metadata": {},
   "source": [
    "<br>**A Series object is a one-dimensional object, while a DataFrame is a two-dimensional object. A Series can be turned into a list, while a DataFrame can be indexed based on row number, so they both have their uses.**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ee3cb99-6f57-401e-a16c-a06cfdf8fd0c",
   "metadata": {},
   "source": [
    "### <br><br>Exercise 2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "20546404-a317-4826-8580-de1f26b90cb2",
   "metadata": {},
   "source": [
    "Write code to return a list of data in the prob1 column:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "981427e2-0002-4bda-beb8-059cf083ee70",
   "metadata": {},
   "outputs": [],
   "source": [
    "prob_data = "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4352ed8f-3522-426f-8a6e-9cf3a5cbabeb",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(len(prob_data))\n",
    "print(type(prob_data))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "990a1af9-622c-4d0a-82b3-ad64c6623698",
   "metadata": {},
   "source": [
    "### <br><br><br>Selecting rows using indexing"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "11891ffa-6371-4753-b624-0c3bc74a85ab",
   "metadata": {},
   "source": [
    "If we want to return a DataFrame with only some **rows**, we can index a range. DataFrame indexing uses regular Python indexing, so we ask for the first item we want, and then a colon, and then we go one position past the last item we want. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0701704b-1fd2-4c37-8043-76d8af913728",
   "metadata": {},
   "outputs": [],
   "source": [
    "df[0:10]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d8fa19de-1035-4dbd-8ff7-4ae98397255b",
   "metadata": {},
   "source": [
    "<br>Because this indexing is referencing the position of the row in the DataFrame, not the index number, we an use negative indexing in either spot to count from the bottom of the DataFrame."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cef717f4-5ddc-438b-811b-058b2ba89f63",
   "metadata": {},
   "outputs": [],
   "source": [
    "df[495:-12]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7923721a-9f65-4379-9d63-d9e8f72cb83f",
   "metadata": {},
   "source": [
    "<br>If you only want a single row, you still need to use indexing with a `:`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ad47fd6f-2dea-4762-b0ff-fffd94d64836",
   "metadata": {},
   "outputs": [],
   "source": [
    "df[4:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d97f64b6-db27-4a66-9226-cd465e0e51fa",
   "metadata": {},
   "source": [
    "### <br><br>Exercise 3"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7496515a-3b53-421e-8d0b-8c75b7fe5922",
   "metadata": {},
   "source": [
    "Write code to return row number 9,999."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c63c905b-4bc9-4b36-9cbb-3c3e6625b38a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "b0158700-008b-4780-950a-519fe8f9f02b",
   "metadata": {},
   "source": [
    "Write code to return the second row in our DataFrame."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1b67e7fc-578c-4cc3-8ac5-2e11d9c36371",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "55baa66e-10dd-4eae-9ba1-3155b117a567",
   "metadata": {},
   "source": [
    "### <br><br><br>Selecting data with a boolean"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d5e2ea5e-5e03-4272-b2df-e115e8a5543c",
   "metadata": {},
   "source": [
    "To return a DataFrame that only has rows that meet a certain condition, we use this syntax. The outer `df[]` lets Python know that you want the answer to be returned as a DataFrame, meaning you can return all the columns included in the output. Inside the indexing, we include our boolean statement, which usually means we need to index a particular column in the dataset to filter the data on."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aa426ded-096c-4d2f-9394-f45c8db13862",
   "metadata": {},
   "outputs": [],
   "source": [
    "df[df[\"team1\"] == \"LVA\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "68c02143-ef3b-4647-bc58-2fb9c45e56e0",
   "metadata": {},
   "outputs": [],
   "source": [
    "df[df[\"score1\"] > 100]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "14f6ef09-d54f-45e7-b22b-cb2a996939ae",
   "metadata": {},
   "source": [
    "### <br><br>Exercise 4"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a21a3f93-6549-440c-8edc-ce6ec8b38613",
   "metadata": {},
   "source": [
    "Write code to return a DataFrame that only includes games that were playoff games (playoff games are coded as 1 in that column):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "192e4345-04e9-4fc2-a584-f00ce6d8fc9c",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "ebe21cd6-89e5-463b-a880-29043b02c3ae",
   "metadata": {},
   "source": [
    "Write code to return a DataFrame that only includes games where score2 was greater than 100:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "72532c89-5377-4ee0-8e77-c6b11d88be24",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "fbdb9a46-a1e2-485b-a702-bec72f91ccce",
   "metadata": {},
   "source": [
    "<br><br><br>If you don't use the outer `df[]` the return is a Series object that returns the boolean value for each row based on the condition you set:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6e7a6d14-4419-4a0c-840e-3cc3c0d1db23",
   "metadata": {},
   "outputs": [],
   "source": [
    "df[\"team1\"] == \"LVA\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a315316-6097-49eb-baa3-a15498a86024",
   "metadata": {},
   "source": [
    "### <br><br><br>Combining boolean indexing with column indexing"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "72bd8f65-00d3-419c-ac2b-d95050289afe",
   "metadata": {},
   "source": [
    "You can also combine a boolean with column indexing to return only some columns for your filtered data. Here I am returning only the team2, score1, and score2 columns for any rows with \"CHI\" in the team1 column."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b7a0d120-2ca5-49ce-9b52-c97964f82f8d",
   "metadata": {},
   "outputs": [],
   "source": [
    "df[df[\"team1\"] == \"CHI\"][[\"team2\", \"score1\", \"score2\"]]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0aafd74e-0f99-469d-8979-60a425834444",
   "metadata": {},
   "source": [
    "### <br><br>Exercise 5"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "be5e5488-1ef6-475d-859a-9f202ea851eb",
   "metadata": {},
   "source": [
    "Write code to return all the games that were played in the 2017 season. Return only columns for date, team1, and team2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6535f219-0f60-4ed5-8f47-13bdbf76f026",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "dd0f0b66-2e73-4b3a-8e1e-d79d32da2903",
   "metadata": {},
   "source": [
    "<br><br><br>**Using the indexing method, we cannot refer to individual rows by name or pull up individual cells in our DataFrame.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e5982808-88ee-4c37-b568-1d2c2a8a510e",
   "metadata": {},
   "outputs": [],
   "source": [
    "df[25]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6240b7a2-3559-4539-8773-1abab458b598",
   "metadata": {
    "tags": []
   },
   "source": [
    "### <br><br><br>pandas loc"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6ace5f2-9ed6-4eb1-b0cc-5275a41fff70",
   "metadata": {},
   "source": [
    "The `loc` **attribute** allows us to call up certain rows and columns. The syntax is:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa6c9669-b721-4fe3-8009-f976cb1ee68a",
   "metadata": {},
   "source": [
    "#### `df.loc[row, column]`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a6caa83-81e7-4567-ae37-1222893647c3",
   "metadata": {},
   "source": [
    "#### `df.loc[list of rows, list of columns]`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5600beb6-bc6c-4c01-85c7-12879ba4c1c4",
   "metadata": {},
   "source": [
    "#### `df.loc[range of rows, range of columns]`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0aa9e930-d69c-484a-96c7-de09e81a0c36",
   "metadata": {},
   "source": [
    "`loc` can take a row, a list of rows, or a range of rows, followed by a comma, and then a column, list of columns, or range of columns. <br><br>If you want all the rows or all the columns, you can use a `:`. <br><br>**The rows that we refer to here are the row names (index names) that are found in bold on the far left of our DataFrame.**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "decd9344-c813-4398-9384-b85fab700fdc",
   "metadata": {},
   "source": [
    "<br>To reference one cell:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "772ca4d2-c62c-443d-b68c-8c25e48571f0",
   "metadata": {},
   "outputs": [],
   "source": [
    "df.loc[25, \"date\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9980ff86-3d83-47c3-8b6c-090c8c66f271",
   "metadata": {},
   "source": [
    "<br>All rows for one column:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1acaa43d-6671-45c5-8c14-f8beae14884e",
   "metadata": {},
   "outputs": [],
   "source": [
    "df.loc[:, \"team1\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36aa9c5d-1f1a-461c-9f5d-7092c2254d69",
   "metadata": {},
   "source": [
    "<br>All columns for one row:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5d3313b7-834c-4bff-84fb-6624219bd2dc",
   "metadata": {},
   "outputs": [],
   "source": [
    "df.loc[12, :]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f7cbeb77-3706-4e0d-b7ee-253c2698c71c",
   "metadata": {},
   "source": [
    "### <br><br>Exercise 6"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "62b80fb3-dda5-4284-bf4b-218c25c4d231",
   "metadata": {},
   "source": [
    "The very first game played by the Chicago Sky is in the row with index 6427."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2df46706-14cf-4ef9-b306-e6b291bcef36",
   "metadata": {},
   "source": [
    "Write code to return all columns in that row:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bd21eb3f-7d4c-49e7-90bf-2c26146f6772",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "4a9e604f-8009-46f2-99ae-a41ed0a28233",
   "metadata": {},
   "source": [
    "Did the Chicago Sky play their very first game at home or away? Write code to return the data in the column \"is_home1\" for that row:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "98f0ca53-9ada-4c8e-9a4e-1e3ed7d89567",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "0af06382-19bd-4b26-aa4e-cf50c5b03343",
   "metadata": {},
   "source": [
    "*(1 is True and 0 is False)* "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97c8515d-ce89-4d59-ab12-8b9e9d8357fd",
   "metadata": {},
   "source": [
    "### <br><br>`loc` with a range and a list"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a9124c5b-b601-43ad-ae57-147da56cfb80",
   "metadata": {},
   "source": [
    "This code will return all columns for the rows 0 through 10."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c18caf4f-ea30-4c96-925d-8948587a0d17",
   "metadata": {},
   "outputs": [],
   "source": [
    "df.loc[0:10, :]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "64822241-5c4e-465e-8abb-9db40cf8009e",
   "metadata": {},
   "source": [
    "<br>**Unlike Python indexing, `loc` is referencing the rows by their index names, so row 10 is included.**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a0271056-16c5-4c05-be25-ae6897d29d25",
   "metadata": {},
   "source": [
    "<br><br>We can also ask for a range of columns, from left to right:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b11ba013-fddd-4499-ad55-15eceee4ef86",
   "metadata": {},
   "outputs": [],
   "source": [
    "df.loc[0:10, \"season\":\"name2\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "468126ba-ef8f-4804-a5ca-f5a68bb4ddba",
   "metadata": {},
   "source": [
    "<br><br>Again, `loc` uses the column and row names, not their positions, so this will not work:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a37f9b9c-acc0-4ce7-b4d6-12a20ed6828f",
   "metadata": {},
   "outputs": [],
   "source": [
    "df.loc[0:10, 0:4]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "038b4aa4-9a43-4d57-8cc0-db2bec1284c5",
   "metadata": {},
   "source": [
    "<br><br>We can also pass a list of rows or columns:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "225ae36d-17bf-4cd3-b90e-40fca646376d",
   "metadata": {},
   "outputs": [],
   "source": [
    "df.loc[[0, 10, 8], [\"team1\", \"score1\", \"team2\", \"score2\"]]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f04362fa-f2a7-4d33-ac6c-969c71f53e4b",
   "metadata": {},
   "source": [
    "*Notice how the returned DataFrame used the same order given in the lists.*"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a9eeeac8-9cd8-4862-baa7-f92a27eb5aea",
   "metadata": {},
   "source": [
    "### <br><br>Exercise 7"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a2d74301-06a2-4e67-aaaf-b094d4503707",
   "metadata": {},
   "source": [
    "Run the following cell to store the list of row indexes for the first 5 games played by the Chicago Sky:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f786bfc7-0817-4ef8-ba70-f32252c4fc6d",
   "metadata": {},
   "outputs": [],
   "source": [
    "first5 = [6427, 6415, 6393, 6387, 6371]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e1ea4db-0a47-4774-9818-f62603645904",
   "metadata": {},
   "source": [
    "Write code to return the rows for the first 5 Chicago Sky games, and return only the columns \"team2\", \"score1\", \"score2\", and \"is_home1\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "66c4ed80-75b9-4180-bbb9-0b7cf8a18828",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "8cd3da9a-e5b4-4638-84cb-5b6e50449d29",
   "metadata": {},
   "source": [
    "### <br><br>`loc` with a conditional"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "63fd90a8-01e6-42a4-a99c-0f5d346b4a13",
   "metadata": {},
   "source": [
    "You can use a conditional to filter rows. The conditional is written the same way as we would write it without using loc:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7c0ddafb-d51e-4401-a9e1-70bf2b4b3e61",
   "metadata": {},
   "outputs": [],
   "source": [
    "df.loc[df[\"team1\"] == \"CHI\", :]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "87fed3ca-c071-4b73-9f1e-6928c2b1ab7c",
   "metadata": {},
   "source": [
    "<br><br>Here I use the same filter for the rows, but I only ask for three columns to be returned:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2ed22201-4e97-4a76-804d-66fb00c07163",
   "metadata": {},
   "outputs": [],
   "source": [
    "df.loc[df[\"team1\"] == \"CHI\", [\"team2\", \"score1\", \"score2\"]]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8cfdb905-4287-45f2-8072-f7f1c103cf19",
   "metadata": {},
   "source": [
    "### <br><br>Exercise 8"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a3de793b-0f6e-46b2-b454-a20298460686",
   "metadata": {},
   "source": [
    "Write code to return all games played in the 2012 season. Only return the columns \"date\", \"name1\", and \"name2\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ad94e9b5-6d92-4f47-86bb-5ece18aae7da",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5cf2e2b8-8e41-499b-a4e9-39311043513c",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "0f45a137-6703-4ff1-9258-7a35bdff1967",
   "metadata": {},
   "source": [
    "### <br><br><br>pandas `iloc`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4703e090-0552-4372-ab48-75ca19150e7e",
   "metadata": {},
   "source": [
    "**While `loc` searches by row and column names, `iloc` searches only by the indexed positions in the DataFrame.**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "313ab21d-5b95-405d-94c5-f3967316b390",
   "metadata": {},
   "source": [
    "Here, I'm asking for the top 10 rows and the first four columns:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ada588f8-1cf2-40c6-9056-220ec1af6747",
   "metadata": {},
   "outputs": [],
   "source": [
    "df.iloc[0:10, 0:4]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7129da68-671e-4eed-9895-e1b2b37cc566",
   "metadata": {},
   "source": [
    "<br>**Notice that `iloc` uses Python indexing!** When we ask for rows 0:10, it returns rows 0 to 9. Also notice that the index (the bold number on the left side of each row) does not count as a true column."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f4932b14-ae20-4e38-bb3c-ee7bb83d9993",
   "metadata": {},
   "source": [
    "<br>Because `iloc` uses Python indexing, we can use negative numbers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "47c808dc-2c7a-4da5-880e-b77689ad8233",
   "metadata": {},
   "outputs": [],
   "source": [
    "df.iloc[0:-5000, 4:-10]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "475d891a-5526-446c-8c4a-c9c09071c099",
   "metadata": {},
   "source": [
    "### <br><br>Exercise 9"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f1aafd4-3c9a-4ad6-b469-d004221b81f4",
   "metadata": {},
   "source": [
    "The games are included in reverse chronological order, so the last row in the table is the very first game ever played."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ac3c7ded-25c7-4ce5-a0ea-1e9abed00744",
   "metadata": {},
   "source": [
    "Was the very first game played at home or away for team1? Use iloc to return the column \"is_home1\" for the very last row in the DataFrame:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b3fab7c2-c4a1-4b8d-be0c-dee6af82975b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bfbf7fa9-acaa-4820-867c-a36de1eecb95",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "3b46ae29-2a4e-4005-8db4-b065945b7147",
   "metadata": {},
   "source": [
    "Use iloc to write code to return the columns \"team1\" and \"team2\" for the most recent 20 games:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b47bdd95-8860-4308-b48d-4b86c5cb5e6e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "af803bad-537f-4d2e-9d78-6aaa6de29a3a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "89c8f396-cae6-49ec-888e-3ef23dcad856",
   "metadata": {},
   "source": [
    "### <br><br><br>pandas `at` and `iat`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dcee7b7c-8076-4ab9-b620-03badbe13a49",
   "metadata": {},
   "source": [
    "If you are looking for the contents of only a single cell (called a **scalar**) in the DataFrame, you can use `loc` or `iloc`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "76578098-c5d6-4203-af99-1afa690a3a2e",
   "metadata": {},
   "outputs": [],
   "source": [
    "df.loc[0, \"season\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d3b8de50-8dd8-4e67-a5e1-7840b542cf00",
   "metadata": {},
   "outputs": [],
   "source": [
    "df.iloc[0, 0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7152378e-8df4-49cf-a48f-97c2e6211693",
   "metadata": {},
   "source": [
    "<br>However, there is another set of pandas functions designed to look up only a single cell. `at` will look up a single cell by row name and column name (like `loc`), and `iat` will look up a single cell by index position (like `iloc`)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ae554fa-566f-40d1-9177-fffda024f636",
   "metadata": {},
   "source": [
    "Why does pandas have a separate way to look up a single cell? Because `at` and `iat` are very fast. If you write code to look up 10,000 single points in a DataFrame, it would be much faster to use `at` or `iat` than `loc` or `iloc`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aa20d245-c1e0-4f61-b8ab-b8c74b438123",
   "metadata": {},
   "outputs": [],
   "source": [
    "df.at[0, \"season\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a924d777-0551-4918-be99-257d87a7ef1c",
   "metadata": {},
   "outputs": [],
   "source": [
    "df.iat[0, 0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2167852c-1370-4350-923e-6078cf1ae455",
   "metadata": {},
   "source": [
    "<br><br>Just to reiterate, `at` and `iat` cannot be used with multiple rows or columns:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1d74620a-5e25-4d1e-b2bc-9b2cf525207b",
   "metadata": {},
   "outputs": [],
   "source": [
    "df.at[0, [\"season\", \"date\"]]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d6ad6dfd-7069-4dc8-bf61-b328180f466d",
   "metadata": {},
   "source": [
    "### <br><br>Exercise 10"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f1c283a4-934e-4811-811a-e88daa18d177",
   "metadata": {},
   "source": [
    "Use `at` to write code to find out if the game in row 5485 was played at home or away:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "721e26eb-cc6c-4d04-8ab4-bf46829ad55b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "789d0876-8331-46b5-9908-c15a5a85830a",
   "metadata": {},
   "source": [
    "Now use `iat` to find the same answer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fdea5139-9c30-4833-b71e-b7b8f6698e24",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "0b112b76-3066-4764-a492-313bc525fa84",
   "metadata": {},
   "source": [
    "### <br><br>A note about index labels"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "57fe6d0c-38b2-4a09-a241-76247bbb7001",
   "metadata": {},
   "source": [
    "The bold numbers on the far left of each column were assigned to each row when the csv file was originally loaded into pandas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fd71c70c-ed04-4d7b-8745-6877a8257bc7",
   "metadata": {},
   "outputs": [],
   "source": [
    "df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2d55d3e-ae1d-4d35-a248-5906775dadf0",
   "metadata": {},
   "source": [
    "<br>If we make a new DataFrame out of only some rows, the index labels will stay the same, leaving gaps. Let's make a new DataFrame that only includes games played by the Chicago Sky:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aaf0b714-15ca-4f25-bbf8-9fcb599e6d83",
   "metadata": {},
   "outputs": [],
   "source": [
    "CHIdf = df.loc[df[\"team1\"] == \"CHI\", :]\n",
    "CHIdf.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d27d467-590f-403e-bc2c-2a379c1e08e6",
   "metadata": {},
   "source": [
    "<br>I can now use `iloc` to get Chicago's most recent 30 games:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8962c887-bd77-4cb1-b450-06a98eab0099",
   "metadata": {},
   "outputs": [],
   "source": [
    "CHIdf.iloc[0:30, :]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0937d5ea-01f1-4592-801b-369200d19166",
   "metadata": {},
   "source": [
    "<br>But I could not use `loc` to get the same thing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ed49cc57-7508-4d65-ad9d-33e39acc1aea",
   "metadata": {},
   "outputs": [],
   "source": [
    "CHIdf.loc[0:30, :]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bed6ce50-ad66-4a22-a0e0-e1d073b6bae9",
   "metadata": {},
   "source": [
    "<br>You can, however, set one of your columns as the index labels:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5b52d864-3cb8-420b-97a9-6083f121d476",
   "metadata": {},
   "outputs": [],
   "source": [
    "CHIdf = CHIdf.set_index(\"date\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1b7c5d09-b5de-451c-a964-204644c08d93",
   "metadata": {},
   "outputs": [],
   "source": [
    "CHIdf.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f0f598e-1b04-4661-8512-b64571164384",
   "metadata": {},
   "source": [
    "<br>Now I can use `loc` to reference the games by date:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cb15da68-db7d-4287-a605-2c7b834029ca",
   "metadata": {},
   "outputs": [],
   "source": [
    "CHIdf.loc[\"9/13/2012\", :]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5df475d5-3c8c-47a0-bd3d-2dea8e4040f9",
   "metadata": {},
   "source": [
    "<br><br>I can still use a range of row labels:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9f03590a-5236-4f84-834c-6098680948f5",
   "metadata": {},
   "outputs": [],
   "source": [
    "CHIdf.loc[\"9/13/2012\":\"5/19/2012\", :]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e90308cb-3a08-4e91-9dc9-f47a556442ee",
   "metadata": {},
   "source": [
    "<br>If you've been wondering why referencing rows by index numbers would ever be useful, now you can set your index names to any unique value that would be useful to you - a sample ID, a name, a date, etc."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e252a57-5b3d-480c-a1a6-9d8c84f9bd0e",
   "metadata": {},
   "source": [
    "### <br><br>Exercise 11"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "96efaeba-d1a2-4443-a8c3-8d3d805721c6",
   "metadata": {},
   "source": [
    "Using the CHIdf, write code (use either `loc` or `at`) to find out which team Chicago played against on 6/16/2017:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4e301a87-5375-4fb2-81b4-b49ef62c6731",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4a3aa4e3-8ad2-49f1-a079-146675f7a8d1",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "8d3af5ba-a5d2-414f-a7c5-24d315accdaf",
   "metadata": {},
   "source": [
    "### <br><br><br>Searching for multiple conditionals in pandas"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "23ca5570-8514-44b3-b54f-f2437c1d41b2",
   "metadata": {},
   "source": [
    "Let's say we want to search through the original DataFrame, `df`, for all games played by the Chicago Sky where the Chicago Sky won. For each of these games, we want to return only the columns for season and the name of the opposing team."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b66878e7-22b0-400c-bae9-04ee8033cf31",
   "metadata": {},
   "source": [
    "The conditional for only Chicago Sky games is:\n",
    "<br>`df[\"team1\"] == \"CHI\"`\n",
    "<br><br>The conditional for games that Chicago won is:\n",
    "<br>`df[\"score1\"] > df[\"score2\"]`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cfc02ea7-4c8e-4ca9-be9c-4c2c8f077909",
   "metadata": {},
   "source": [
    "We might try to use Python operators (`and`, `or`, `not`):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cd31f7fd-959e-45c5-9312-aa8bccea7295",
   "metadata": {},
   "outputs": [],
   "source": [
    "df.loc[df[\"team1\"] == \"CHI\" and df[\"score1\"] > df[\"score2\"], [\"season\", \"name2\"]]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fce07b50-7657-494d-8c8c-49340ca0ea34",
   "metadata": {},
   "source": [
    "<br><br>**However, pandas uses the operators `&`, `|`, `!` for and, or, and not. Pandas also requires you to include each conditional inside parentheses.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "db9e6f19-9760-4106-b878-130f9cb3cd98",
   "metadata": {},
   "outputs": [],
   "source": [
    "df.loc[(df[\"team1\"] == \"CHI\") & (df[\"score1\"] > df[\"score2\"]), [\"season\", \"team2\"]]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c6172a13-a154-4b4f-9b81-8aa88f1805b1",
   "metadata": {},
   "source": [
    "### <br><br>Exercise 12"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c1702a7-2220-457d-9826-967ffdaed76e",
   "metadata": {},
   "source": [
    "Use `loc` to return rows in the DataFrame that were played in either the 1999 or 2000 seasons. For each row, return all columns:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "236a8c1e-c5ad-4241-b9b2-b050f850c2d9",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "db643dbe-e30e-4220-8524-8039a4bebedc",
   "metadata": {},
   "source": [
    "Has Chicago ever played in any playoff games? Return rows that have CHI in the \"team1\" column and 1 in the \"playoff\" column. Only return the columns \"season\", \"team2\", and \"date\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a32e2a01-6424-4f7b-9ab5-cecaa74c1693",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "25340a60-bc81-42ae-b11e-520266bb6ab1",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "2f230881-4e23-4643-ac45-5f402dddd9cd",
   "metadata": {},
   "source": [
    "## <br><br><br>PART THREE: *OPEN UP THE NOTEBOOK PANDAS2.IPYNB*"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "afabe6ab-58ba-47f7-9c07-8974288ec34c",
   "metadata": {},
   "source": [
    "We don't want our notebook to get too slow as we continue to work with additional dataframes."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}