{ "cells": [ { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "# Basic Functionality\n", "\n", "**Outcomes**\n", "\n", "- Be familiar with `datetime` \n", "- Use built-in aggregation functions and be able to create your own and\n", " apply them using `agg` \n", "- Use built-in Series transformation functions and be able to create your\n", " own and apply them using `apply` \n", "- Use built-in scalar transformation functions and be able to create your\n", " own and apply them using `applymap` \n", "- Be able to select subsets of the DataFrame using boolean selection \n", "- Know what the “want operator” is and how to apply it \n", "\n", "\n", "**Data**\n", "\n", "- US state unemployment data from Bureau of Labor Statistics " ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "## State Unemployment Data\n", "\n", "In this lecture, we will use unemployment data by state at a monthly\n", "frequency." ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "hide-output": false, "slideshow": { "slide_type": "-" } }, "outputs": [ { "data": { "text/plain": [ "'1.2.3'" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import pandas as pd\n", "\n", "import qeds\n", "\n", "%matplotlib inline\n", "\n", "# activate plot theme\n", "qeds.themes.mpl_style();\n", "\n", "pd.__version__" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "fragment" } }, "source": [ "First, we will download the data directly from a url and read it into a pandas DataFrame." ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "hide-output": false, "slideshow": { "slide_type": "-" } }, "outputs": [], "source": [ "## Load up the data -- this may take a couple seconds\n", "url = \"https://datascience.quantecon.org/assets/data/state_unemployment.csv\"\n", "unemp_raw = pd.read_csv(url, parse_dates=[\"Date\"])" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "fragment" } }, "source": [ "The pandas `read_csv` will determine most datatypes of the underlying columns. The\n", "exception here is that we need to give pandas a hint so it can load up the `Date` column as a Python datetime type: the `parse_dates=[\"Date\"]`.\n", "\n", "We can see the basic structure of the downloaded data by getting the first 5 rows, which directly matches\n", "the underlying CSV file." ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "hide-output": false, "slideshow": { "slide_type": "-" } }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
DatestateLaborForceUnemploymentRate
02000-01-01Alabama2142945.04.7
12000-01-01Alaska319059.06.3
22000-01-01Arizona2499980.04.1
32000-01-01Arkansas1264619.04.4
42000-01-01California16680246.05.0
\n", "
" ], "text/plain": [ " Date state LaborForce UnemploymentRate\n", "0 2000-01-01 Alabama 2142945.0 4.7\n", "1 2000-01-01 Alaska 319059.0 6.3\n", "2 2000-01-01 Arizona 2499980.0 4.1\n", "3 2000-01-01 Arkansas 1264619.0 4.4\n", "4 2000-01-01 California 16680246.0 5.0" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "unemp_raw.head()" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "fragment" } }, "source": [ "Note that a row has a date, state, labor force size, and unemployment rate.\n", "\n", "For our analysis, we want to look at the unemployment rate across different states over time, which\n", "requires a transformation of the data similar to an Excel pivot-table." ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "hide-output": false, "slideshow": { "slide_type": "-" } }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
stateAlabamaAlaskaArizonaArkansasCaliforniaColoradoConnecticutDelawareFloridaGeorgia...South DakotaTennesseeTexasUtahVermontVirginiaWashingtonWest VirginiaWisconsinWyoming
Date
2000-01-014.76.34.14.45.02.82.83.53.73.7...2.43.74.63.12.72.64.95.83.24.1
2000-02-014.76.34.14.35.02.82.73.63.73.6...2.43.74.63.12.62.54.95.63.23.9
2000-03-014.66.34.04.35.02.72.63.63.73.6...2.43.84.53.12.62.45.05.53.33.9
2000-04-014.66.34.04.35.12.72.53.73.73.7...2.43.84.43.12.72.45.05.43.43.8
2000-05-014.56.34.04.25.12.72.43.73.73.7...2.43.94.33.22.72.35.15.43.53.8
\n", "

5 rows × 50 columns

\n", "
" ], "text/plain": [ "state Alabama Alaska Arizona Arkansas California Colorado \\\n", "Date \n", "2000-01-01 4.7 6.3 4.1 4.4 5.0 2.8 \n", "2000-02-01 4.7 6.3 4.1 4.3 5.0 2.8 \n", "2000-03-01 4.6 6.3 4.0 4.3 5.0 2.7 \n", "2000-04-01 4.6 6.3 4.0 4.3 5.1 2.7 \n", "2000-05-01 4.5 6.3 4.0 4.2 5.1 2.7 \n", "\n", "state Connecticut Delaware Florida Georgia ... South Dakota \\\n", "Date ... \n", "2000-01-01 2.8 3.5 3.7 3.7 ... 2.4 \n", "2000-02-01 2.7 3.6 3.7 3.6 ... 2.4 \n", "2000-03-01 2.6 3.6 3.7 3.6 ... 2.4 \n", "2000-04-01 2.5 3.7 3.7 3.7 ... 2.4 \n", "2000-05-01 2.4 3.7 3.7 3.7 ... 2.4 \n", "\n", "state Tennessee Texas Utah Vermont Virginia Washington \\\n", "Date \n", "2000-01-01 3.7 4.6 3.1 2.7 2.6 4.9 \n", "2000-02-01 3.7 4.6 3.1 2.6 2.5 4.9 \n", "2000-03-01 3.8 4.5 3.1 2.6 2.4 5.0 \n", "2000-04-01 3.8 4.4 3.1 2.7 2.4 5.0 \n", "2000-05-01 3.9 4.3 3.2 2.7 2.3 5.1 \n", "\n", "state West Virginia Wisconsin Wyoming \n", "Date \n", "2000-01-01 5.8 3.2 4.1 \n", "2000-02-01 5.6 3.2 3.9 \n", "2000-03-01 5.5 3.3 3.9 \n", "2000-04-01 5.4 3.4 3.8 \n", "2000-05-01 5.4 3.5 3.8 \n", "\n", "[5 rows x 50 columns]" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Don't worry about the details here quite yet\n", "unemp_all = (\n", " unemp_raw\n", " .reset_index()\n", " .pivot_table(index=\"Date\", columns=\"state\", values=\"UnemploymentRate\")\n", ")\n", "unemp_all.head()" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "fragment" } }, "source": [ "Finally, we can filter it to look at a subset of the columns (i.e. “state” in this case)." ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "hide-output": false, "slideshow": { "slide_type": "-" } }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
stateArizonaCaliforniaFloridaIllinoisMichiganNew YorkTexas
Date
2000-01-014.15.03.74.23.34.74.6
2000-02-014.15.03.74.23.24.74.6
2000-03-014.05.03.74.33.24.64.5
2000-04-014.05.13.74.33.34.64.4
2000-05-014.05.13.74.33.54.64.3
\n", "
" ], "text/plain": [ "state Arizona California Florida Illinois Michigan New York Texas\n", "Date \n", "2000-01-01 4.1 5.0 3.7 4.2 3.3 4.7 4.6\n", "2000-02-01 4.1 5.0 3.7 4.2 3.2 4.7 4.6\n", "2000-03-01 4.0 5.0 3.7 4.3 3.2 4.6 4.5\n", "2000-04-01 4.0 5.1 3.7 4.3 3.3 4.6 4.4\n", "2000-05-01 4.0 5.1 3.7 4.3 3.5 4.6 4.3" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "states = [\n", " \"Arizona\", \"California\", \"Florida\", \"Illinois\",\n", " \"Michigan\", \"New York\", \"Texas\"\n", "]\n", "unemp = unemp_all[states]\n", "unemp.head()" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "When plotting, a DataFrame knows the column and index names." ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "hide-output": false, "slideshow": { "slide_type": "-" } }, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "unemp.plot(figsize=(8, 6))" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "## Dates in pandas\n", "\n", "You might have noticed that our index now has a nice format for the\n", "dates (`YYYY-MM-DD`) rather than just a year.\n", "\n", "This is because the `dtype` of the index is a variant of `datetime`." ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "hide-output": false, "slideshow": { "slide_type": "-" } }, "outputs": [ { "data": { "text/plain": [ "DatetimeIndex(['2000-01-01', '2000-02-01', '2000-03-01', '2000-04-01',\n", " '2000-05-01', '2000-06-01', '2000-07-01', '2000-08-01',\n", " '2000-09-01', '2000-10-01',\n", " ...\n", " '2017-03-01', '2017-04-01', '2017-05-01', '2017-06-01',\n", " '2017-07-01', '2017-08-01', '2017-09-01', '2017-10-01',\n", " '2017-11-01', '2017-12-01'],\n", " dtype='datetime64[ns]', name='Date', length=216, freq=None)" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "unemp.index" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "We can index into a DataFrame with a `DatetimeIndex` using string\n", "representations of dates.\n", "\n", "For example" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "hide-output": false, "slideshow": { "slide_type": "-" } }, "outputs": [ { "data": { "text/plain": [ "state\n", "Arizona 4.1\n", "California 5.0\n", "Florida 3.7\n", "Illinois 4.2\n", "Michigan 3.3\n", "New York 4.7\n", "Texas 4.6\n", "Name: 2000-01-01 00:00:00, dtype: float64" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Data corresponding to a single date\n", "unemp.loc[\"01/01/2000\", :]" ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "hide-output": false, "slideshow": { "slide_type": "-" } }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
stateArizonaCaliforniaFloridaIllinoisMichiganNew YorkTexas
Date
2000-01-014.15.03.74.23.34.74.6
2000-02-014.15.03.74.23.24.74.6
2000-03-014.05.03.74.33.24.64.5
2000-04-014.05.13.74.33.34.64.4
2000-05-014.05.13.74.33.54.64.3
2000-06-014.05.13.84.33.74.64.3
\n", "
" ], "text/plain": [ "state Arizona California Florida Illinois Michigan New York Texas\n", "Date \n", "2000-01-01 4.1 5.0 3.7 4.2 3.3 4.7 4.6\n", "2000-02-01 4.1 5.0 3.7 4.2 3.2 4.7 4.6\n", "2000-03-01 4.0 5.0 3.7 4.3 3.2 4.6 4.5\n", "2000-04-01 4.0 5.1 3.7 4.3 3.3 4.6 4.4\n", "2000-05-01 4.0 5.1 3.7 4.3 3.5 4.6 4.3\n", "2000-06-01 4.0 5.1 3.8 4.3 3.7 4.6 4.3" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Data for all days between New Years Day and June first in the year 2000\n", "unemp.loc[\"01/01/2000\":\"06/01/2000\", :]" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "-" } }, "source": [ "We may learn more about what pandas can do with dates and times in an\n", "upcoming lecture on time series data." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "## DataFrame Aggregations\n", "\n", "Let’s talk about *aggregations*.\n", "\n", "Loosely speaking, an aggregation is an operation that combines multiple\n", "values into a single value.\n", "\n", "For example, computing the mean of three numbers (for example\n", "`[0, 1, 2]`) returns a single number (1).\n", "\n", "We will use aggregations extensively as we analyze and manipulate our data.\n", "\n", "Thankfully, pandas makes this easy!" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "### Built-in Aggregations\n", "\n", "pandas already has some of the most frequently used aggregations.\n", "\n", "For example:\n", "\n", "- Mean (`mean`) \n", "- Variance (`var`) \n", "- Standard deviation (`std`) \n", "- Minimum (`min`) \n", "- Median (`median`) \n", "- Maximum (`max`) \n", "- etc… \n", "\n", "\n", ">**Note**\n", ">\n", ">When looking for common operations, using “tab completion” goes a long way." ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
stateArizonaCaliforniaFloridaIllinoisMichiganNew YorkTexas
Date
2000-01-014.15.03.74.23.34.74.6
2000-02-014.15.03.74.23.24.74.6
2000-03-014.05.03.74.33.24.64.5
2000-04-014.05.13.74.33.34.64.4
2000-05-014.05.13.74.33.54.64.3
\n", "
" ], "text/plain": [ "state Arizona California Florida Illinois Michigan New York Texas\n", "Date \n", "2000-01-01 4.1 5.0 3.7 4.2 3.3 4.7 4.6\n", "2000-02-01 4.1 5.0 3.7 4.2 3.2 4.7 4.6\n", "2000-03-01 4.0 5.0 3.7 4.3 3.2 4.6 4.5\n", "2000-04-01 4.0 5.1 3.7 4.3 3.3 4.6 4.4\n", "2000-05-01 4.0 5.1 3.7 4.3 3.5 4.6 4.3" ] }, "execution_count": 29, "metadata": {}, "output_type": "execute_result" } ], "source": [ "unemp.head()" ] }, { "cell_type": "code", "execution_count": 30, "metadata": { "hide-output": false, "slideshow": { "slide_type": "-" } }, "outputs": [ { "data": { "text/plain": [ "state\n", "Arizona 3.6\n", "California 4.5\n", "Florida 3.1\n", "Illinois 4.2\n", "Michigan 3.2\n", "New York 4.2\n", "Texas 3.9\n", "dtype: float64" ] }, "execution_count": 30, "metadata": {}, "output_type": "execute_result" } ], "source": [ "unemp.min()" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "fragment" } }, "source": [ "As seen above, the aggregation’s default is to aggregate each column.\n", "\n", "However, by using the `axis` keyword argument, you can do aggregations by\n", "row as well." ] }, { "cell_type": "code", "execution_count": 33, "metadata": { "hide-output": false, "slideshow": { "slide_type": "-" } }, "outputs": [ { "data": { "text/plain": [ "Date\n", "2000-01-01 0.352381\n", "2000-02-01 0.384762\n", "2000-03-01 0.364762\n", "2000-04-01 0.353333\n", "2000-05-01 0.294762\n", " ... \n", "2017-08-01 0.141429\n", "2017-09-01 0.163333\n", "2017-10-01 0.165714\n", "2017-11-01 0.165714\n", "2017-12-01 0.148095\n", "Length: 216, dtype: float64" ] }, "execution_count": 33, "metadata": {}, "output_type": "execute_result" } ], "source": [ "unemp.var(axis=1)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "### Writing Your Own Aggregation\n", "\n", "The built-in aggregations will get us pretty far in our analysis, but\n", "sometimes we need more flexibility.\n", "\n", "We can have pandas perform custom aggregations by following these two\n", "steps:\n", "\n", "1. Write a Python function that takes a `Series` as an input and\n", " outputs a single value. \n", "1. Call the `agg` method with our new function as an argument. \n", "\n", "\n", "For example, below, we will classify states as “low unemployment” or\n", "“high unemployment” based on whether their mean unemployment level is\n", "above or below 6.5." ] }, { "cell_type": "code", "execution_count": 34, "metadata": { "hide-output": false, "slideshow": { "slide_type": "-" } }, "outputs": [], "source": [ "#\n", "# Step 1: We write the (aggregation) function that we'd like to use\n", "#\n", "def high_or_low(s):\n", " \"\"\"\n", " This function takes a pandas Series object and returns high\n", " if the mean is above 6.5 and low if the mean is below 6.5\n", " \"\"\"\n", " if s.mean() < 6.5:\n", " out = \"Low\"\n", " else:\n", " out = \"High\"\n", "\n", " return out" ] }, { "cell_type": "code", "execution_count": 35, "metadata": { "hide-output": false, "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "data": { "text/plain": [ "state\n", "Arizona Low\n", "California High\n", "Florida Low\n", "Illinois High\n", "Michigan High\n", "New York Low\n", "Texas Low\n", "dtype: object" ] }, "execution_count": 35, "metadata": {}, "output_type": "execute_result" } ], "source": [ "#\n", "# Step 2: Apply it via the agg method.\n", "#\n", "unemp.agg(high_or_low)" ] }, { "cell_type": "code", "execution_count": 36, "metadata": { "hide-output": false, "slideshow": { "slide_type": "-" } }, "outputs": [ { "data": { "text/plain": [ "Date\n", "2000-01-01 Low\n", "2000-02-01 Low\n", "2000-03-01 Low\n", "2000-04-01 Low\n", "2000-05-01 Low\n", "dtype: object" ] }, "execution_count": 36, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# How does this differ from unemp.agg(high_or_low)?\n", "unemp.agg(high_or_low, axis=1).head()" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "fragment" } }, "source": [ "Notice that `agg` can also accept multiple functions at once." ] }, { "cell_type": "code", "execution_count": 43, "metadata": { "hide-output": false, "slideshow": { "slide_type": "-" } }, "outputs": [], "source": [ "foo = unemp.agg([min, max, \"mean\",high_or_low], axis=1)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "**Exercise**\n", "\n", "Do the following exercises in separate code cells below:\n", "\n", "- At each date, what is the minimum unemployment rate across all states\n", " in our sample? \n", "- What was the median unemployment rate in each state? \n", "- What was the maximum unemployment rate across the states in our\n", " sample? What state did it happen in? In what month/year was this\n", " achieved? \n", " - Hint 1: What Python type (not `dtype`) is returned by the\n", " aggregation? \n", " - Hint 2: Read documentation for the method `idxmax` \n", "- Classify each state as high or low volatility based on whether the\n", " variance of their unemployment is above or below 4. " ] }, { "cell_type": "code", "execution_count": null, "metadata": { "hide-output": false, "slideshow": { "slide_type": "-" } }, "outputs": [], "source": [ "# min unemployment rate by state" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "hide-output": false, "slideshow": { "slide_type": "-" } }, "outputs": [], "source": [ "# median unemployment rate by state" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "hide-output": false, "slideshow": { "slide_type": "-" } }, "outputs": [], "source": [ "# max unemployment rate across all states and Year" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "hide-output": false, "slideshow": { "slide_type": "-" } }, "outputs": [], "source": [ "# low or high volatility" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "## Transforms\n", "\n", "Many analytical operations do not necessarily involve an aggregation.\n", "\n", "The output of a function applied to a Series might need to be a new\n", "Series.\n", "\n", "Some examples:\n", "\n", "- Compute the percentage change in unemployment from month to month. \n", "- Calculate the cumulative sum of elements in each column. " ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "### Built-in Transforms\n", "\n", "pandas comes with many transform functions including:\n", "\n", "- Cumulative sum/max/min/product (`cum(sum|min|max|prod)`) \n", "- Difference (`diff`) \n", "- Elementwise addition/subtraction/multiplication/division (`+`, `-`, `*`, `/`) \n", "- Percent change (`pct_change`) \n", "- Number of occurrences of each distinct value (`value_counts`) \n", "- Absolute value (`abs`) \n", "\n", "\n", "Again, tab completion is helpful when trying to find these functions." ] }, { "cell_type": "code", "execution_count": 48, "metadata": { "hide-output": false, "slideshow": { "slide_type": "-" } }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
stateArizonaCaliforniaFloridaIllinoisMichiganNew YorkTexas
Date
2000-01-014.15.03.74.23.34.74.6
2000-02-014.15.03.74.23.24.74.6
2000-03-014.05.03.74.33.24.64.5
2000-04-014.05.13.74.33.34.64.4
2000-05-014.05.13.74.33.54.64.3
\n", "
" ], "text/plain": [ "state Arizona California Florida Illinois Michigan New York Texas\n", "Date \n", "2000-01-01 4.1 5.0 3.7 4.2 3.3 4.7 4.6\n", "2000-02-01 4.1 5.0 3.7 4.2 3.2 4.7 4.6\n", "2000-03-01 4.0 5.0 3.7 4.3 3.2 4.6 4.5\n", "2000-04-01 4.0 5.1 3.7 4.3 3.3 4.6 4.4\n", "2000-05-01 4.0 5.1 3.7 4.3 3.5 4.6 4.3" ] }, "execution_count": 48, "metadata": {}, "output_type": "execute_result" } ], "source": [ "unemp.head()" ] }, { "cell_type": "code", "execution_count": 49, "metadata": { "hide-output": false, "slideshow": { "slide_type": "-" } }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
stateArizonaCaliforniaFloridaIllinoisMichiganNew YorkTexas
Date
2000-01-01NaNNaNNaNNaNNaNNaNNaN
2000-02-010.000000.000.00.00000-0.0303030.0000000.000000
2000-03-01-0.024390.000.00.023810.000000-0.021277-0.021739
2000-04-010.000000.020.00.000000.0312500.000000-0.022222
2000-05-010.000000.000.00.000000.0606060.000000-0.022727
\n", "
" ], "text/plain": [ "state Arizona California Florida Illinois Michigan New York \\\n", "Date \n", "2000-01-01 NaN NaN NaN NaN NaN NaN \n", "2000-02-01 0.00000 0.00 0.0 0.00000 -0.030303 0.000000 \n", "2000-03-01 -0.02439 0.00 0.0 0.02381 0.000000 -0.021277 \n", "2000-04-01 0.00000 0.02 0.0 0.00000 0.031250 0.000000 \n", "2000-05-01 0.00000 0.00 0.0 0.00000 0.060606 0.000000 \n", "\n", "state Texas \n", "Date \n", "2000-01-01 NaN \n", "2000-02-01 0.000000 \n", "2000-03-01 -0.021739 \n", "2000-04-01 -0.022222 \n", "2000-05-01 -0.022727 " ] }, "execution_count": 49, "metadata": {}, "output_type": "execute_result" } ], "source": [ "unemp.pct_change().head()" ] }, { "cell_type": "code", "execution_count": 50, "metadata": { "hide-output": false, "slideshow": { "slide_type": "-" } }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
stateArizonaCaliforniaFloridaIllinoisMichiganNew YorkTexas
Date
2000-01-01NaNNaNNaNNaNNaNNaNNaN
2000-02-010.00.00.00.0-0.10.00.0
2000-03-01-0.10.00.00.10.0-0.1-0.1
2000-04-010.00.10.00.00.10.0-0.1
2000-05-010.00.00.00.00.20.0-0.1
\n", "
" ], "text/plain": [ "state Arizona California Florida Illinois Michigan New York Texas\n", "Date \n", "2000-01-01 NaN NaN NaN NaN NaN NaN NaN\n", "2000-02-01 0.0 0.0 0.0 0.0 -0.1 0.0 0.0\n", "2000-03-01 -0.1 0.0 0.0 0.1 0.0 -0.1 -0.1\n", "2000-04-01 0.0 0.1 0.0 0.0 0.1 0.0 -0.1\n", "2000-05-01 0.0 0.0 0.0 0.0 0.2 0.0 -0.1" ] }, "execution_count": 50, "metadata": {}, "output_type": "execute_result" } ], "source": [ "unemp.diff().head()" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "-" } }, "source": [ "Transforms can be split into to several main categories:\n", "\n", "1. *Series transforms*: functions that take in one Series and produce another Series. The index of the input and output does not need to be the same. \n", "1. *Scalar transforms*: functions that take a single value and produce a single value. An example is the `abs` method, or adding a constant to each value of a Series. " ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "### Custom Series Transforms\n", "\n", "pandas also simplifies applying custom Series transforms to a Series or the\n", "columns of a DataFrame. The steps are:\n", "\n", "1. Write a Python function that takes a Series and outputs a new Series. \n", "1. Pass our new function as an argument to the `apply` method (alternatively, the `transform` method). \n", "\n", "\n", "As an example, we will standardize our unemployment data to have mean 0\n", "and standard deviation 1.\n", "\n", "After doing this, we can use an aggregation to determine at which date the\n", "unemployment rate is most different from “normal times” for each state." ] }, { "cell_type": "code", "execution_count": 67, "metadata": { "hide-output": false, "slideshow": { "slide_type": "-" } }, "outputs": [], "source": [ "#\n", "# Step 1: We write the Series transform function that we'd like to use\n", "#\n", "def standardize_data(x):\n", " \"\"\"\n", " Changes the data in a Series to become mean 0 with standard deviation 1\n", " \"\"\"\n", " mu = x.mean()\n", " std = x.std()\n", "\n", " return (x - mu)/std" ] }, { "cell_type": "code", "execution_count": 73, "metadata": { "hide-output": false, "slideshow": { "slide_type": "-" } }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
stateArizonaCaliforniaFloridaIllinoisMichiganNew YorkTexas
Date
2000-01-01-1.076861-0.935545-0.976846-1.337203-1.605740-0.925962-0.849345
2000-02-01-1.076861-0.935545-0.976846-1.337203-1.644039-0.925962-0.849345
2000-03-01-1.125778-0.935545-0.976846-1.286217-1.644039-0.991993-0.926885
2000-04-01-1.125778-0.894853-0.976846-1.286217-1.605740-0.991993-1.004424
2000-05-01-1.125778-0.894853-0.976846-1.286217-1.529141-0.991993-1.081964
\n", "
" ], "text/plain": [ "state Arizona California Florida Illinois Michigan New York \\\n", "Date \n", "2000-01-01 -1.076861 -0.935545 -0.976846 -1.337203 -1.605740 -0.925962 \n", "2000-02-01 -1.076861 -0.935545 -0.976846 -1.337203 -1.644039 -0.925962 \n", "2000-03-01 -1.125778 -0.935545 -0.976846 -1.286217 -1.644039 -0.991993 \n", "2000-04-01 -1.125778 -0.894853 -0.976846 -1.286217 -1.605740 -0.991993 \n", "2000-05-01 -1.125778 -0.894853 -0.976846 -1.286217 -1.529141 -0.991993 \n", "\n", "state Texas \n", "Date \n", "2000-01-01 -0.849345 \n", "2000-02-01 -0.849345 \n", "2000-03-01 -0.926885 \n", "2000-04-01 -1.004424 \n", "2000-05-01 -1.081964 " ] }, "execution_count": 73, "metadata": {}, "output_type": "execute_result" } ], "source": [ "#\n", "# Step 2: Apply our function via the apply method.\n", "#\n", "std_unemp = unemp.apply(standardize_data, axis=\"index\")\n", "std_unemp.head()" ] }, { "cell_type": "code", "execution_count": 74, "metadata": {}, "outputs": [], "source": [ "std_unemp_idx = unemp.apply(standardize_data, axis=\"index\")" ] }, { "cell_type": "code", "execution_count": 75, "metadata": {}, "outputs": [], "source": [ "std_unemp_col = unemp.apply(standardize_data, axis=\"columns\")" ] }, { "cell_type": "code", "execution_count": 76, "metadata": { "hide-output": false, "slideshow": { "slide_type": "-" } }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
stateArizonaCaliforniaFloridaIllinoisMichiganNew YorkTexas
Date
2000-01-011.0768610.9355450.9768461.3372031.6057400.9259620.849345
2000-02-011.0768610.9355450.9768461.3372031.6440390.9259620.849345
2000-03-011.1257780.9355450.9768461.2862171.6440390.9919930.926885
2000-04-011.1257780.8948530.9768461.2862171.6057400.9919931.004424
2000-05-011.1257780.8948530.9768461.2862171.5291410.9919931.081964
\n", "
" ], "text/plain": [ "state Arizona California Florida Illinois Michigan New York \\\n", "Date \n", "2000-01-01 1.076861 0.935545 0.976846 1.337203 1.605740 0.925962 \n", "2000-02-01 1.076861 0.935545 0.976846 1.337203 1.644039 0.925962 \n", "2000-03-01 1.125778 0.935545 0.976846 1.286217 1.644039 0.991993 \n", "2000-04-01 1.125778 0.894853 0.976846 1.286217 1.605740 0.991993 \n", "2000-05-01 1.125778 0.894853 0.976846 1.286217 1.529141 0.991993 \n", "\n", "state Texas \n", "Date \n", "2000-01-01 0.849345 \n", "2000-02-01 0.849345 \n", "2000-03-01 0.926885 \n", "2000-04-01 1.004424 \n", "2000-05-01 1.081964 " ] }, "execution_count": 76, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Takes the absolute value of all elements of a function\n", "abs_std_unemp = std_unemp.abs()\n", "\n", "abs_std_unemp.head()" ] }, { "cell_type": "code", "execution_count": 77, "metadata": { "hide-output": false, "slideshow": { "slide_type": "-" } }, "outputs": [ { "data": { "text/plain": [ "state\n", "Arizona 2009-11-01\n", "California 2010-03-01\n", "Florida 2010-01-01\n", "Illinois 2009-12-01\n", "Michigan 2009-06-01\n", "New York 2009-11-01\n", "Texas 2009-08-01\n", "dtype: datetime64[ns]" ] }, "execution_count": 77, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# find the date when unemployment was \"most different from normal\" for each State\n", "def idxmax(x):\n", " # idxmax of Series will return index of maximal value\n", " return x.idxmax()\n", "\n", "abs_std_unemp.agg(idxmax)" ] }, { "cell_type": "code", "execution_count": 79, "metadata": {}, "outputs": [], "source": [ "def high_or_low(ur):\n", " if ur < 6.5:\n", " return \"low\"\n", " else:\n", " return \"high\"" ] }, { "cell_type": "code", "execution_count": 82, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
stateArizonaCaliforniaFloridaIllinoisMichiganNew YorkTexas
Date
2000-01-01lowlowlowlowlowlowlow
2000-02-01lowlowlowlowlowlowlow
2000-03-01lowlowlowlowlowlowlow
2000-04-01lowlowlowlowlowlowlow
2000-05-01lowlowlowlowlowlowlow
........................
2017-08-01lowlowlowlowlowlowlow
2017-09-01lowlowlowlowlowlowlow
2017-10-01lowlowlowlowlowlowlow
2017-11-01lowlowlowlowlowlowlow
2017-12-01lowlowlowlowlowlowlow
\n", "

216 rows × 7 columns

\n", "
" ], "text/plain": [ "state Arizona California Florida Illinois Michigan New York Texas\n", "Date \n", "2000-01-01 low low low low low low low\n", "2000-02-01 low low low low low low low\n", "2000-03-01 low low low low low low low\n", "2000-04-01 low low low low low low low\n", "2000-05-01 low low low low low low low\n", "... ... ... ... ... ... ... ...\n", "2017-08-01 low low low low low low low\n", "2017-09-01 low low low low low low low\n", "2017-10-01 low low low low low low low\n", "2017-11-01 low low low low low low low\n", "2017-12-01 low low low low low low low\n", "\n", "[216 rows x 7 columns]" ] }, "execution_count": 82, "metadata": {}, "output_type": "execute_result" } ], "source": [ "unemp.applymap(high_or_low)" ] }, { "cell_type": "code", "execution_count": 81, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
stateArizonaCaliforniaFloridaIllinoisMichiganNew YorkTexas
Date
2009-01-01highhighhighhighhighhighlow
2009-02-01highhighhighhighhighhighlow
2009-03-01highhighhighhighhighhighhigh
2009-04-01highhighhighhighhighhighhigh
2009-05-01highhighhighhighhighhighhigh
........................
2017-08-01lowlowlowlowlowlowlow
2017-09-01lowlowlowlowlowlowlow
2017-10-01lowlowlowlowlowlowlow
2017-11-01lowlowlowlowlowlowlow
2017-12-01lowlowlowlowlowlowlow
\n", "

108 rows × 7 columns

\n", "
" ], "text/plain": [ "state Arizona California Florida Illinois Michigan New York Texas\n", "Date \n", "2009-01-01 high high high high high high low\n", "2009-02-01 high high high high high high low\n", "2009-03-01 high high high high high high high\n", "2009-04-01 high high high high high high high\n", "2009-05-01 high high high high high high high\n", "... ... ... ... ... ... ... ...\n", "2017-08-01 low low low low low low low\n", "2017-09-01 low low low low low low low\n", "2017-10-01 low low low low low low low\n", "2017-11-01 low low low low low low low\n", "2017-12-01 low low low low low low low\n", "\n", "[108 rows x 7 columns]" ] }, "execution_count": 81, "metadata": {}, "output_type": "execute_result" } ], "source": [ "unemp.applymap(high_or_low).loc[\"2009-01-01\":, :]" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "### Custom Scalar Transforms\n", "\n", "As you may have predicted, we can also apply custom scalar transforms to our\n", "pandas data.\n", "\n", "To do this, we use the following pattern:\n", "\n", "1. Define a Python function that takes in a scalar and produces a scalar. \n", "1. Pass this function as an argument to the `applymap` Series or DataFrame method. \n", "\n", "There will be an exercise to practice doing this!" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "## Boolean Selection\n", "\n", "We have seen how we can select subsets of data by referring to the index\n", "or column names.\n", "\n", "However, we often want to select based on conditions met by\n", "the data itself.\n", "\n", "Some examples are:\n", "\n", "- Restrict analysis to all individuals older than 18. \n", "- Look at data that corresponds to particular time periods. \n", "- Analyze only data that corresponds to a recession. \n", "- Obtain data for a specific product or customer ID. \n", "\n", "\n", "We will be able to do this by using a Series or list of boolean values\n", "to index into a Series or DataFrame.\n", "\n", "Let’s look at some examples." ] }, { "cell_type": "code", "execution_count": 83, "metadata": { "hide-output": false, "slideshow": { "slide_type": "-" } }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
stateArizonaCaliforniaFloridaIllinoisMichiganNew YorkTexas
Date
2000-01-014.15.03.74.23.34.74.6
2000-02-014.15.03.74.23.24.74.6
2000-03-014.05.03.74.33.24.64.5
2000-04-014.05.13.74.33.34.64.4
2000-05-014.05.13.74.33.54.64.3
\n", "
" ], "text/plain": [ "state Arizona California Florida Illinois Michigan New York Texas\n", "Date \n", "2000-01-01 4.1 5.0 3.7 4.2 3.3 4.7 4.6\n", "2000-02-01 4.1 5.0 3.7 4.2 3.2 4.7 4.6\n", "2000-03-01 4.0 5.0 3.7 4.3 3.2 4.6 4.5\n", "2000-04-01 4.0 5.1 3.7 4.3 3.3 4.6 4.4\n", "2000-05-01 4.0 5.1 3.7 4.3 3.5 4.6 4.3" ] }, "execution_count": 83, "metadata": {}, "output_type": "execute_result" } ], "source": [ "unemp_small = unemp.head() # Create smaller data so we can see what's happening\n", "unemp_small" ] }, { "cell_type": "code", "execution_count": 84, "metadata": { "hide-output": false, "slideshow": { "slide_type": "-" } }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
stateArizonaCaliforniaFloridaIllinoisMichiganNew YorkTexas
Date
2000-01-014.15.03.74.23.34.74.6
2000-02-014.15.03.74.23.24.74.6
2000-03-014.05.03.74.33.24.64.5
\n", "
" ], "text/plain": [ "state Arizona California Florida Illinois Michigan New York Texas\n", "Date \n", "2000-01-01 4.1 5.0 3.7 4.2 3.3 4.7 4.6\n", "2000-02-01 4.1 5.0 3.7 4.2 3.2 4.7 4.6\n", "2000-03-01 4.0 5.0 3.7 4.3 3.2 4.6 4.5" ] }, "execution_count": 84, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# list of booleans selects rows\n", "unemp_small.loc[[True, True, True, False, False], :]" ] }, { "cell_type": "code", "execution_count": 85, "metadata": { "hide-output": false, "slideshow": { "slide_type": "-" } }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
stateArizonaCaliforniaFloridaIllinoisMichiganNew YorkTexas
Date
2000-01-014.15.03.74.23.34.74.6
2000-03-014.05.03.74.33.24.64.5
2000-05-014.05.13.74.33.54.64.3
\n", "
" ], "text/plain": [ "state Arizona California Florida Illinois Michigan New York Texas\n", "Date \n", "2000-01-01 4.1 5.0 3.7 4.2 3.3 4.7 4.6\n", "2000-03-01 4.0 5.0 3.7 4.3 3.2 4.6 4.5\n", "2000-05-01 4.0 5.1 3.7 4.3 3.5 4.6 4.3" ] }, "execution_count": 85, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# second argument selects columns, the ``:`` means \"all\".\n", "# here we use it to select all columns\n", "unemp_small.loc[[True, False, True, False, True], :]" ] }, { "cell_type": "code", "execution_count": 86, "metadata": { "hide-output": false, "slideshow": { "slide_type": "-" } }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
stateArizonaNew YorkTexas
Date
2000-01-014.14.74.6
2000-02-014.14.74.6
2000-03-014.04.64.5
\n", "
" ], "text/plain": [ "state Arizona New York Texas\n", "Date \n", "2000-01-01 4.1 4.7 4.6\n", "2000-02-01 4.1 4.7 4.6\n", "2000-03-01 4.0 4.6 4.5" ] }, "execution_count": 86, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# can use booleans to select both rows and columns\n", "unemp_small.loc[[True, True, True, False, False], [True, False, False, False, False, True, True]]" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "### Creating Boolean DataFrames/Series\n", "\n", "We can use [conditional statements](../python_fundamentals/control_flow.ipynb) to\n", "construct Series of booleans from our data." ] }, { "cell_type": "code", "execution_count": 95, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Date\n", "2000-01-01 False\n", "2000-02-01 False\n", "2000-03-01 False\n", "2000-04-01 True\n", "2000-05-01 True\n", "Name: Texas, dtype: bool" ] }, "execution_count": 95, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# unemp_small.loc[, ]\n", "# unemp_small.loc[\"Texas\"] # Error because TX not in index\n", "unemp_small.loc[:, \"Texas\"] < 4.5" ] }, { "cell_type": "code", "execution_count": 87, "metadata": { "hide-output": false, "slideshow": { "slide_type": "-" } }, "outputs": [ { "data": { "text/plain": [ "Date\n", "2000-01-01 False\n", "2000-02-01 False\n", "2000-03-01 False\n", "2000-04-01 True\n", "2000-05-01 True\n", "Name: Texas, dtype: bool" ] }, "execution_count": 87, "metadata": {}, "output_type": "execute_result" } ], "source": [ "unemp_small[\"Texas\"] < 4.5" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "fragment" } }, "source": [ "Once we have our Series of bools, we can use it to extract subsets of\n", "rows from our DataFrame." ] }, { "cell_type": "code", "execution_count": 89, "metadata": { "hide-output": false, "slideshow": { "slide_type": "-" } }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
stateArizonaCaliforniaFloridaIllinoisMichiganNew YorkTexas
Date
2000-04-014.05.13.74.33.34.64.4
2000-05-014.05.13.74.33.54.64.3
\n", "
" ], "text/plain": [ "state Arizona California Florida Illinois Michigan New York Texas\n", "Date \n", "2000-04-01 4.0 5.1 3.7 4.3 3.3 4.6 4.4\n", "2000-05-01 4.0 5.1 3.7 4.3 3.5 4.6 4.3" ] }, "execution_count": 89, "metadata": {}, "output_type": "execute_result" } ], "source": [ "unemp_small.loc[unemp_small[\"Texas\"] < 4.5, :]" ] }, { "cell_type": "code", "execution_count": 90, "metadata": { "hide-output": false, "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "data": { "text/plain": [ "Date\n", "2000-01-01 True\n", "2000-02-01 True\n", "2000-03-01 True\n", "2000-04-01 True\n", "2000-05-01 True\n", "dtype: bool" ] }, "execution_count": 90, "metadata": {}, "output_type": "execute_result" } ], "source": [ "unemp_small[\"New York\"] > unemp_small[\"Texas\"]" ] }, { "cell_type": "code", "execution_count": 91, "metadata": { "hide-output": false, "slideshow": { "slide_type": "-" } }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
stateArizonaCaliforniaFloridaIllinoisMichiganNew YorkTexas
Date
2000-01-014.15.03.74.23.34.74.6
2000-02-014.15.03.74.23.24.74.6
2000-03-014.05.03.74.33.24.64.5
2000-04-014.05.13.74.33.34.64.4
2000-05-014.05.13.74.33.54.64.3
\n", "
" ], "text/plain": [ "state Arizona California Florida Illinois Michigan New York Texas\n", "Date \n", "2000-01-01 4.1 5.0 3.7 4.2 3.3 4.7 4.6\n", "2000-02-01 4.1 5.0 3.7 4.2 3.2 4.7 4.6\n", "2000-03-01 4.0 5.0 3.7 4.3 3.2 4.6 4.5\n", "2000-04-01 4.0 5.1 3.7 4.3 3.3 4.6 4.4\n", "2000-05-01 4.0 5.1 3.7 4.3 3.5 4.6 4.3" ] }, "execution_count": 91, "metadata": {}, "output_type": "execute_result" } ], "source": [ "big_NY = unemp_small[\"New York\"] > unemp_small[\"Texas\"]\n", "unemp_small.loc[big_NY]" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "#### Multiple Conditions\n", "\n", "In the boolean section of the [basics lecture](../python_fundamentals/basics.ipynb), we saw\n", "that we can use the words `and` and `or` to combine multiple booleans into\n", "a single bool.\n", "\n", "Recall:\n", "\n", "- `True and False -> False` \n", "- `True and True -> True` \n", "- `False and False -> False` \n", "- `True or False -> True` \n", "- `True or True -> True` \n", "- `False or False -> False` \n", "\n", "\n", "We can do something similar in pandas, but instead of\n", "`bool1 and bool2` we write:" ] }, { "cell_type": "markdown", "metadata": { "hide-output": false, "slideshow": { "slide_type": "-" } }, "source": [ "```python\n", "(bool_series1) & (bool_series2)\n", "```\n" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "-" } }, "source": [ "Likewise, instead of `bool1 or bool2` we write:" ] }, { "cell_type": "markdown", "metadata": { "hide-output": false, "slideshow": { "slide_type": "-" } }, "source": [ "```python\n", "(bool_series1) | (bool_series2)\n", "```\n" ] }, { "cell_type": "code", "execution_count": 96, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Date\n", "2000-01-01 True\n", "2000-02-01 True\n", "2000-03-01 True\n", "2000-04-01 True\n", "2000-05-01 True\n", "Name: Texas, dtype: bool" ] }, "execution_count": 96, "metadata": {}, "output_type": "execute_result" } ], "source": [ "unemp_small[\"Texas\"] < 4.7" ] }, { "cell_type": "code", "execution_count": 97, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Date\n", "2000-01-01 False\n", "2000-02-01 False\n", "2000-03-01 True\n", "2000-04-01 True\n", "2000-05-01 True\n", "Name: New York, dtype: bool" ] }, "execution_count": 97, "metadata": {}, "output_type": "execute_result" } ], "source": [ "unemp_small[\"New York\"] < 4.7" ] }, { "cell_type": "code", "execution_count": 98, "metadata": { "hide-output": false, "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "data": { "text/plain": [ "Date\n", "2000-01-01 False\n", "2000-02-01 False\n", "2000-03-01 True\n", "2000-04-01 True\n", "2000-05-01 True\n", "dtype: bool" ] }, "execution_count": 98, "metadata": {}, "output_type": "execute_result" } ], "source": [ "small_NYTX = (unemp_small[\"Texas\"] < 4.7) & (unemp_small[\"New York\"] < 4.7)\n", "small_NYTX" ] }, { "cell_type": "code", "execution_count": 100, "metadata": { "hide-output": false, "slideshow": { "slide_type": "-" } }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
stateArizonaCaliforniaFloridaIllinoisMichiganNew YorkTexas
Date
2000-03-014.05.03.74.33.24.64.5
2000-04-014.05.13.74.33.34.64.4
2000-05-014.05.13.74.33.54.64.3
\n", "
" ], "text/plain": [ "state Arizona California Florida Illinois Michigan New York Texas\n", "Date \n", "2000-03-01 4.0 5.0 3.7 4.3 3.2 4.6 4.5\n", "2000-04-01 4.0 5.1 3.7 4.3 3.3 4.6 4.4\n", "2000-05-01 4.0 5.1 3.7 4.3 3.5 4.6 4.3" ] }, "execution_count": 100, "metadata": {}, "output_type": "execute_result" } ], "source": [ "unemp_small.loc[small_NYTX]" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "#### `isin`\n", "\n", "Sometimes, we will want to check whether a data point takes on one of a\n", "several fixed values.\n", "\n", "We could do this by writing `(df[\"x\"] == val_1) | (df[\"x\"] == val_2)`\n", "(like we did above), but there is a better way: the `.isin` method" ] }, { "cell_type": "code", "execution_count": 109, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "0 False\n", "1 False\n", "2 False\n", "3 False\n", "4 False\n", " ... \n", "10795 False\n", "10796 False\n", "10797 False\n", "10798 False\n", "10799 False\n", "Name: state, Length: 10800, dtype: bool" ] }, "execution_count": 109, "metadata": {}, "output_type": "execute_result" } ], "source": [ "foo = unemp_raw[\"state\"].isin([\"New York\", \"Texas\"])\n", "foo" ] }, { "cell_type": "code", "execution_count": 108, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
DatestateLaborForceUnemploymentRate
302000-01-01New York9148772.04.7
422000-01-01Texas10352120.04.6
802000-02-01New York9150933.04.7
922000-02-01Texas10363975.04.6
1302000-03-01New York9149949.04.6
...............
106922017-10-01Texas13592091.03.9
107302017-11-01New York9709880.04.7
107422017-11-01Texas13593505.03.9
107802017-12-01New York9708580.04.7
107922017-12-01Texas13591013.04.0
\n", "

432 rows × 4 columns

\n", "
" ], "text/plain": [ " Date state LaborForce UnemploymentRate\n", "30 2000-01-01 New York 9148772.0 4.7\n", "42 2000-01-01 Texas 10352120.0 4.6\n", "80 2000-02-01 New York 9150933.0 4.7\n", "92 2000-02-01 Texas 10363975.0 4.6\n", "130 2000-03-01 New York 9149949.0 4.6\n", "... ... ... ... ...\n", "10692 2017-10-01 Texas 13592091.0 3.9\n", "10730 2017-11-01 New York 9709880.0 4.7\n", "10742 2017-11-01 Texas 13593505.0 3.9\n", "10780 2017-12-01 New York 9708580.0 4.7\n", "10792 2017-12-01 Texas 13591013.0 4.0\n", "\n", "[432 rows x 4 columns]" ] }, "execution_count": 108, "metadata": {}, "output_type": "execute_result" } ], "source": [ "unemp_raw.loc[foo]" ] }, { "cell_type": "code", "execution_count": 110, "metadata": { "hide-output": false, "slideshow": { "slide_type": "-" } }, "outputs": [ { "data": { "text/plain": [ "Date\n", "2000-01-01 True\n", "2000-02-01 True\n", "2000-03-01 True\n", "2000-04-01 True\n", "2000-05-01 False\n", "Name: Michigan, dtype: bool" ] }, "execution_count": 110, "metadata": {}, "output_type": "execute_result" } ], "source": [ "unemp_small[\"Michigan\"].isin([3.3, 3.2])" ] }, { "cell_type": "code", "execution_count": 111, "metadata": { "hide-output": false, "slideshow": { "slide_type": "-" } }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
stateArizonaCaliforniaFloridaIllinoisMichiganNew YorkTexas
Date
2000-01-014.15.03.74.23.34.74.6
2000-02-014.15.03.74.23.24.74.6
2000-03-014.05.03.74.33.24.64.5
2000-04-014.05.13.74.33.34.64.4
\n", "
" ], "text/plain": [ "state Arizona California Florida Illinois Michigan New York Texas\n", "Date \n", "2000-01-01 4.1 5.0 3.7 4.2 3.3 4.7 4.6\n", "2000-02-01 4.1 5.0 3.7 4.2 3.2 4.7 4.6\n", "2000-03-01 4.0 5.0 3.7 4.3 3.2 4.6 4.5\n", "2000-04-01 4.0 5.1 3.7 4.3 3.3 4.6 4.4" ] }, "execution_count": 111, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# now select full rows where this Series is True\n", "unemp_small.loc[unemp_small[\"Michigan\"].isin([3.3, 3.2])]" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "#### `.any` and `.all`\n", "\n", "Recall from the boolean section of the Python basics lecture\n", "that the Python functions `any` and `all` are aggregation functions that\n", "take a collection of booleans and return a single boolean.\n", "\n", "`any` returns True whenever at least one of the inputs are True while\n", "`all` is True only when all the inputs are `True`.\n", "\n", "Series and DataFrames with `dtype` bool have `.any` and `.all`\n", "methods that apply this logic to pandas objects.\n", "\n", "Let’s use these methods to count how many months all the states in our\n", "sample had high unemployment.\n", "\n", "As we work through this example, consider the “want\n", "operator”, a helpful concept from Nobel Laureate [Tom Sargent](http://www.tomsargent.com)\n", "for clearly stating the goal of our analysis and\n", "determining the steps necessary to reach the goal.\n", "\n", "We always begin by writing `Want:` followed by what we want to\n", "accomplish.\n", "\n", "In this case, we would write:\n", "\n", "> Want: Count the number of months in which all states in our sample\n", "had unemployment above 6.5%\n", "\n", "After identifying the **want**, we work *backwards* to identify the\n", "steps necessary to accomplish our goal.\n", "\n", "So, starting from the result, we have:\n", "\n", "1. Sum the number of `True` values in a Series indicating dates for\n", " which all states had high unemployment. \n", "1. Build the Series used in the last step by using the `.all` method\n", " on a DataFrame containing booleans indicating whether each state had\n", " high unemployment at each date. \n", "1. Build the DataFrame used in the previous step using a `>`\n", " comparison. \n", "\n", "\n", "Now that we have a clear plan, let’s follow through and *apply* the want\n", "operator:" ] }, { "cell_type": "code", "execution_count": 112, "metadata": { "hide-output": false, "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
stateArizonaCaliforniaFloridaIllinoisMichiganNew YorkTexas
Date
2000-01-01FalseFalseFalseFalseFalseFalseFalse
2000-02-01FalseFalseFalseFalseFalseFalseFalse
2000-03-01FalseFalseFalseFalseFalseFalseFalse
2000-04-01FalseFalseFalseFalseFalseFalseFalse
2000-05-01FalseFalseFalseFalseFalseFalseFalse
\n", "
" ], "text/plain": [ "state Arizona California Florida Illinois Michigan New York Texas\n", "Date \n", "2000-01-01 False False False False False False False\n", "2000-02-01 False False False False False False False\n", "2000-03-01 False False False False False False False\n", "2000-04-01 False False False False False False False\n", "2000-05-01 False False False False False False False" ] }, "execution_count": 112, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Step 3: construct the DataFrame of bools\n", "high = unemp > 6.5\n", "high.head()" ] }, { "cell_type": "code", "execution_count": 113, "metadata": { "hide-output": false, "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "data": { "text/plain": [ "Date\n", "2000-01-01 False\n", "2000-02-01 False\n", "2000-03-01 False\n", "2000-04-01 False\n", "2000-05-01 False\n", "dtype: bool" ] }, "execution_count": 113, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Step 2: use the .all method on axis=1 to get the dates where all states have a True\n", "all_high = high.all(axis=1)\n", "# Could also use\n", "# all_high = high.all(axis=\"columns\")\n", "all_high.head()" ] }, { "cell_type": "code", "execution_count": 114, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
stateArizonaCaliforniaFloridaIllinoisMichiganNew YorkTexas
Date
2009-04-019.410.810.19.813.68.16.6
2009-05-019.711.010.410.214.28.37.6
2009-06-019.911.210.510.414.68.48.0
2009-07-0110.211.410.710.514.58.58.2
2009-08-0110.411.510.810.714.48.78.3
2009-09-0110.611.710.910.814.28.88.3
2009-10-0110.811.811.011.014.18.88.3
2009-11-0110.911.911.211.114.08.98.3
2009-12-0110.912.111.211.313.98.98.3
2010-01-0110.912.211.311.313.98.98.3
2010-02-0110.812.211.211.313.78.88.3
2010-03-0110.712.311.211.113.58.88.3
2010-04-0110.612.211.110.813.28.78.2
2010-05-0110.412.211.010.612.98.68.1
2010-06-0110.312.210.910.312.68.58.0
2010-07-0110.212.210.910.112.38.58.0
2010-08-0110.212.211.010.012.18.58.0
2010-09-0110.112.211.09.912.08.58.1
2010-10-0110.112.311.09.811.88.58.1
2010-11-0110.012.311.09.711.68.48.1
2010-12-019.912.210.89.511.38.48.1
2011-01-019.812.110.79.411.08.38.0
2011-02-019.712.010.59.410.88.27.9
2011-03-019.711.910.49.410.78.17.9
2011-04-019.711.810.39.510.68.17.9
2011-05-019.711.810.29.710.68.17.9
2011-06-019.711.810.29.910.68.27.9
2011-07-019.711.810.110.010.68.37.9
2011-08-019.611.79.910.110.58.37.8
2011-09-019.411.69.710.010.28.47.7
2011-10-019.211.59.59.910.08.57.6
2011-11-019.011.39.39.69.78.57.4
2011-12-018.811.29.19.49.48.67.2
2012-01-018.711.08.99.19.28.67.1
2012-02-018.710.98.89.09.18.67.0
2012-03-018.610.88.78.99.18.76.9
2012-04-018.610.78.78.99.28.76.9
2012-05-018.510.68.79.09.28.76.9
2012-06-018.510.58.69.09.28.76.8
2012-07-018.310.48.59.09.28.66.7
2012-08-018.210.28.49.09.18.56.6
\n", "
" ], "text/plain": [ "state Arizona California Florida Illinois Michigan New York Texas\n", "Date \n", "2009-04-01 9.4 10.8 10.1 9.8 13.6 8.1 6.6\n", "2009-05-01 9.7 11.0 10.4 10.2 14.2 8.3 7.6\n", "2009-06-01 9.9 11.2 10.5 10.4 14.6 8.4 8.0\n", "2009-07-01 10.2 11.4 10.7 10.5 14.5 8.5 8.2\n", "2009-08-01 10.4 11.5 10.8 10.7 14.4 8.7 8.3\n", "2009-09-01 10.6 11.7 10.9 10.8 14.2 8.8 8.3\n", "2009-10-01 10.8 11.8 11.0 11.0 14.1 8.8 8.3\n", "2009-11-01 10.9 11.9 11.2 11.1 14.0 8.9 8.3\n", "2009-12-01 10.9 12.1 11.2 11.3 13.9 8.9 8.3\n", "2010-01-01 10.9 12.2 11.3 11.3 13.9 8.9 8.3\n", "2010-02-01 10.8 12.2 11.2 11.3 13.7 8.8 8.3\n", "2010-03-01 10.7 12.3 11.2 11.1 13.5 8.8 8.3\n", "2010-04-01 10.6 12.2 11.1 10.8 13.2 8.7 8.2\n", "2010-05-01 10.4 12.2 11.0 10.6 12.9 8.6 8.1\n", "2010-06-01 10.3 12.2 10.9 10.3 12.6 8.5 8.0\n", "2010-07-01 10.2 12.2 10.9 10.1 12.3 8.5 8.0\n", "2010-08-01 10.2 12.2 11.0 10.0 12.1 8.5 8.0\n", "2010-09-01 10.1 12.2 11.0 9.9 12.0 8.5 8.1\n", "2010-10-01 10.1 12.3 11.0 9.8 11.8 8.5 8.1\n", "2010-11-01 10.0 12.3 11.0 9.7 11.6 8.4 8.1\n", "2010-12-01 9.9 12.2 10.8 9.5 11.3 8.4 8.1\n", "2011-01-01 9.8 12.1 10.7 9.4 11.0 8.3 8.0\n", "2011-02-01 9.7 12.0 10.5 9.4 10.8 8.2 7.9\n", "2011-03-01 9.7 11.9 10.4 9.4 10.7 8.1 7.9\n", "2011-04-01 9.7 11.8 10.3 9.5 10.6 8.1 7.9\n", "2011-05-01 9.7 11.8 10.2 9.7 10.6 8.1 7.9\n", "2011-06-01 9.7 11.8 10.2 9.9 10.6 8.2 7.9\n", "2011-07-01 9.7 11.8 10.1 10.0 10.6 8.3 7.9\n", "2011-08-01 9.6 11.7 9.9 10.1 10.5 8.3 7.8\n", "2011-09-01 9.4 11.6 9.7 10.0 10.2 8.4 7.7\n", "2011-10-01 9.2 11.5 9.5 9.9 10.0 8.5 7.6\n", "2011-11-01 9.0 11.3 9.3 9.6 9.7 8.5 7.4\n", "2011-12-01 8.8 11.2 9.1 9.4 9.4 8.6 7.2\n", "2012-01-01 8.7 11.0 8.9 9.1 9.2 8.6 7.1\n", "2012-02-01 8.7 10.9 8.8 9.0 9.1 8.6 7.0\n", "2012-03-01 8.6 10.8 8.7 8.9 9.1 8.7 6.9\n", "2012-04-01 8.6 10.7 8.7 8.9 9.2 8.7 6.9\n", "2012-05-01 8.5 10.6 8.7 9.0 9.2 8.7 6.9\n", "2012-06-01 8.5 10.5 8.6 9.0 9.2 8.7 6.8\n", "2012-07-01 8.3 10.4 8.5 9.0 9.2 8.6 6.7\n", "2012-08-01 8.2 10.2 8.4 9.0 9.1 8.5 6.6" ] }, "execution_count": 114, "metadata": {}, "output_type": "execute_result" } ], "source": [ "unemp.loc[all_high]" ] }, { "cell_type": "code", "execution_count": 115, "metadata": { "hide-output": false, "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Out of 216 months, 41 had high unemployment across all states\n" ] } ], "source": [ "# Step 1: Call .sum to add up the number of True values in `all_high`\n", "# (note that True == 1 and False == 0 in Python, so .sum will count Trues)\n", "msg = \"Out of {} months, {} had high unemployment across all states\"\n", "print(msg.format(len(all_high), all_high.sum()))" ] } ], "metadata": { "celltoolbar": "Slideshow", "date": 1595352471.6656835, "download_nb": false, "filename": "basics.rst", "filename_with_path": "pandas/basics", "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.8.8" }, "title": "Basic Functionality" }, "nbformat": 4, "nbformat_minor": 2 }