4-Introduction to Pandas.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to Pandas\n",
    "\n",
    "This notebook provides an introduction to the `pandas` package. The content borrows heavily from the book *Data Science Handbook*, which was written by Jake VanderPlas and is available at https://jakevdp.github.io/PythonDataScienceHandbook/ (accessed 12/17/2019).\n",
    "\n",
    "The following table of contents lists the topics discussed in this notebook. Clicking on any topic will advance the notebook to the associated area.\n",
    "\n",
    "\n",
    "# Table of Contents\n",
    "<a id=\"Table_of_Contents\"> </a>\n",
    "\n",
    "1. [Pandas](#pandas)<br>\n",
    "    1.1 [Pandas Objects](#Pandas_Objects)<br>\n",
    "    1.2 [Importing Data](#Importing_Data_with_Pandas)<br>\n",
    "    1.3 [Indexing and Selecting Data](#Indexing_and_Selecting_with_pandas)<br>\n",
    "    1.4 [Handling Missing Data](#Pandas_Missing_Data)<br>\n",
    "    1.5 [Grouping and Aggregating Data](#Grouping_and_Aggregation_with_Pandas)<br>\n",
    "    1.6 [Pivot Tables](#Pivot_Tables)<br>\n",
    "    1.7 [Combining Datasets](#Combining_Datasets)<br>\n",
    "    \n",
    "#### Disclaimer\n",
    "\n",
    "This notebook is by no means a comprehensive resource for the `pandas` package. Also, it is important to realize that the Python language and the available packages will continue to evolve. That being said, the objects, functions, and methods described in this notebook may one day change. If changes occur, areas of this notebook that use deprecated features may cease to work and will need to be revised or omitted."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pandas\n",
    "<a id=\"pandas\"> </a>\n",
    "\n",
    "The `pandas` package is one of the most popular Python tools for data management and manipulation. `pandas` is built *on top* of `numpy`. Thus, much of the functionality and methods that are available in `numpy` are also available in `pandas`. \n",
    "\n",
    "From https://en.wikipedia.org/wiki/Pandas_(software) (accessed 1/7/2018):\n",
    "\n",
    ">Pandas is a software library written for the Python programming language for data manipulation and analysis. In particular, it offers data structures and operations for manipulating numerical tables and time series. It is free software released under the three-clause BSD license. The name is derived from the term \"panel data\", an econometrics term for multidimensional, structured data sets. Major features of the library are:\n",
    "\n",
    "> - DataFrame object for data manipulation with integrated indexing.\n",
    "> - Tools for reading and writing data between in-memory data structures and different file formats.\n",
    "> - Data alignment and integrated handling of missing data.\n",
    "> - Reshaping and pivoting of data sets.\n",
    "> - Label-based slicing, fancy indexing, and subsetting of large data sets.\n",
    "> - Data structure column insertion and deletion.\n",
    "> - Group by engine allowing split-apply-combine operations on data sets.\n",
    "> - Data set merging and joining.\n",
    "> - Hierarchical axis indexing to work with high-dimensional data in a lower-dimensional data structure.\n",
    "> - Time series-functionality: Date range generation and frequency conversion, moving window statistics, moving window linear regressions, date shifting and lagging.\n",
    "> The library is highly optimized for performance, with critical code paths written in Cython or C.\n",
    "\n",
    "The following code block uses the *import - as* approach to import Pandas. The alias *pd* is a standard convention. We also import NumPy.\n",
    "\n",
    "[Back to Table of Contents](#Table_of_Contents)<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pandas Objects\n",
    "<a id=\"Pandas_Objects\"> </a>\n",
    "\n",
    "Pandas objects can be thought of as enhanced NumPy arrays. The two main Pandas objects are:\n",
    "1. The Pandas `Series`, which is a one-dimensional array of indexed data, and \n",
    "2. The Pandas `DataFrame`, which is two-dimensional array of indexed data.\n",
    "\n",
    "The fact that Pandas objects are indexed allows us to lookup and access values by the index. Also, in contrast to NumPy arrays which are for storing numeric data, Pandas objects can store pretty much any Python data type.\n",
    "\n",
    "[Back to Table of Contents](#Table_of_Contents)<br>\n",
    "\n",
    "\n",
    "### Pandas `Series` Object\n",
    "To demonstrate the Pandas `Series` object, suppose we have the following 24 data points for sales over a 24 month period stored in a list object named `sales`. Also, we have a list object named `month` that stores the month that the sales occured in using the date format YYYY-MM.\n",
    "\n",
    "[Back to Table of Contents](#Table_of_Contents)<br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "month = ['2015-01-31', '2015-02-28', '2015-03-31', '2015-04-30','2015-05-31', '2015-06-30', '2015-07-31', '2015-08-31',\n",
    "         '2015-09-30', '2015-10-31', '2015-11-30', '2015-12-31','2016-01-31', '2016-02-29', '2016-03-31', '2016-04-30',\n",
    "         '2016-05-31', '2016-06-30', '2016-07-31', '2016-08-31','2016-09-30', '2016-10-31', '2016-11-30', '2016-12-31']\n",
    "\n",
    "sales = [872, 873, 990, 1129, 969, 964, 1148, 614, 1068, 1138, 1057,  748, \n",
    "         1255, 1016, 1058, 1064, 1229, 1060, 1144, 1119, 1188,  817,  638, 1205]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following code block uses the two lists to create a Pandas `Series` that is stored in a variable named `sales_series`.\n",
    "\n",
    "[Back to Table of Contents](#Table_of_Contents)<br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following code block shows how we can access individual values, or a range of values, in the series.\n",
    "\n",
    "[Back to Table of Contents](#Table_of_Contents)<br>\n",
    "\n",
    "<b>Get the sales for June 2015<b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Get the sales for June 2015 through December 2015 <b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using NumPy-like syntax, we can do computations on `Series` objects. The following code blocks provides examples.\n",
    "\n",
    "[Back to Table of Contents](#Table_of_Contents)<br>\n",
    "\n",
    "<b>Compute the total sales for June 2015 through December 2015 <b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Compute the mean sales for June 2015 through December 2015 <b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Compute the maximum sales for June 2015 through December 2015 <b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pandas `DataFrame` Object\n",
    "\n",
    "We will now look at Pandas `DataFrame` object. The following cell provides four lists that provide information on the sales of two products, A and B, in three stores, W1, E1, and E2, over 10 years.\n",
    "\n",
    "[Back to Table of Contents](#Table_of_Contents)<br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "stores_list = ['W1', 'W1', 'W1', 'W1', 'W1', 'W1', 'W1', 'W1', 'W1', 'W1', \n",
    "               'W1', 'W1', 'W1', 'W1', 'W1', 'W1', 'W1', 'W1', 'W1', 'W1', \n",
    "               'E1', 'E1', 'E1', 'E1', 'E1', 'E1', 'E1', 'E1', 'E1', 'E1', \n",
    "               'E1', 'E1', 'E1', 'E1', 'E1', 'E1', 'E1', 'E1', 'E1', 'E1', \n",
    "               'E2', 'E2', 'E2', 'E2', 'E2', 'E2', 'E2', 'E2', 'E2', 'E2', \n",
    "               'E2', 'E2', 'E2', 'E2', 'E2', 'E2', 'E2', 'E2', 'E2', 'E2']\n",
    "\n",
    "dates_list = ['12/31/2007', '12/31/2008', '12/31/2009', '12/31/2010', '12/31/2011', '12/31/2012', \n",
    "              '12/31/2013', '12/31/2014', '12/31/2015', '12/31/2016', '12/31/2007', '12/31/2008', \n",
    "              '12/31/2009', '12/31/2010', '12/31/2011', '12/31/2012', '12/31/2013', '12/31/2014', \n",
    "              '12/31/2015', '12/31/2016', '12/31/2007', '12/31/2008', '12/31/2009', '12/31/2010', \n",
    "              '12/31/2011', '12/31/2012', '12/31/2013', '12/31/2014', '12/31/2015', '12/31/2016', \n",
    "              '12/31/2007', '12/31/2008', '12/31/2009', '12/31/2010', '12/31/2011', '12/31/2012', \n",
    "              '12/31/2013', '12/31/2014', '12/31/2015', '12/31/2016', '12/31/2007', '12/31/2008', \n",
    "              '12/31/2009', '12/31/2010', '12/31/2011', '12/31/2012', '12/31/2013', '12/31/2014', \n",
    "              '12/31/2015', '12/31/2016', '12/31/2007', '12/31/2008', '12/31/2009', '12/31/2010', \n",
    "              '12/31/2011', '12/31/2012', '12/31/2013', '12/31/2014', '12/31/2015', '12/31/2016']\n",
    "\n",
    "product_list = ['A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', \n",
    "                'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B', \n",
    "                'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', \n",
    "                'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B', \n",
    "                'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', \n",
    "                'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B']\n",
    "\n",
    "sales_list = [1957, 1968, 1983, 2001, 1894, 1850, 2045, 1860, 1784, 1856, \n",
    "              1891, 1822, 1846, 1903, 1924, 1897, 1890, 1858, 1871, 1880, \n",
    "              1858, 1909, 1977, 1717, 1751, 1797, 1804, 1845, 1895, 1713, \n",
    "              1904, 1812, 1733, 1868, 1872, 1909, 2034, 1856, 1813, 1806, \n",
    "              1862, 1800, 1840, 1882, 1819, 1854, 1716, 1845, 1877, 1879, \n",
    "              1696, 1783, 1799, 1852, 1793, 1877, 1687, 1824, 1839, 1889]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following code block first uses the list to construct a Python dictionary, uses the dictionary to define a Pandas `DataFrame` object named `sales_data`, and uses the `head()` method to print the first 10 rows of the `DataFrame`.\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    <b>The <i>head()</i> function:</b> The <i>head()</i> function is a Pandas object method that prints the first five rows of a Pandas object by default. Specifying an integer argument instructs Pandas to return the specified number of rows from the beginning of the object. Similar to the <i>head()</i> method, the <i>tail()</i> method returns records from the end of a Pandas object.</div>\n",
    "    \n",
    "[Back to Table of Contents](#Table_of_Contents)<br>\n",
    "\n",
    "<b>Create a Python dictionary that will create a data frame contained in a variable called sales_data that will include the Store, Product, Sales, and Year.  Then show the first 5 rows of this dataframe. <b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A key thing to note is that the format of the `DataFrame` object is very similar to what you would see when working with Microsoft Excel worksheets. \n",
    "\n",
    "There are many other ways to create Pandas objects from scratch. However, for the sake of space, we will stop here. See https://jakevdp.github.io/PythonDataScienceHandbook/03.01-introducing-pandas-objects.html or use Google to find other examples. \n",
    "\n",
    "[Back to Table of Contents](#Table_of_Contents)<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Importing Data\n",
    "<a id=\"Importing_Data_with_Pandas\"> </a>\n",
    "\n",
    "One of the most useful applications of Pandas is that it provides users with an easy way to import data from other sources. The following table was copied from https://pandas.pydata.org/pandas-docs/stable/io.html. Note that the hyperlinks will take you to sites descibing the different file formats or methods.\n",
    "\n",
    "<table border=\"1\" class=\"colwidths-given docutils\">\n",
    "<colgroup>\n",
    "<col width=\"12%\" />\n",
    "<col width=\"40%\" />\n",
    "<col width=\"24%\" />\n",
    "<col width=\"24%\" />\n",
    "</colgroup>\n",
    "<thead valign=\"bottom\">\n",
    "<tr class=\"row-odd\"><th class=\"head\">Format Type</th>\n",
    "<th class=\"head\">Data Description</th>\n",
    "<th class=\"head\">Reader</th>\n",
    "<th class=\"head\">Writer</th>\n",
    "</tr>\n",
    "</thead>\n",
    "<tbody valign=\"top\">\n",
    "<tr class=\"row-even\"><td>text</td>\n",
    "<td><a class=\"reference external\" href=\"https://en.wikipedia.org/wiki/Comma-separated_values\">CSV</a></td>\n",
    "<td><a class=\"reference internal\" href=\"https://pandas.pydata.org/pandas-docs/stable/io.html#io-read-csv-table\"><span class=\"std std-ref\">read_csv</span></a></td>\n",
    "<td><a class=\"reference internal\" href=\"https://pandas.pydata.org/pandas-docs/stable/io.html#io-store-in-csv\"><span class=\"std std-ref\">to_csv</span></a></td>\n",
    "</tr>\n",
    "<tr class=\"row-odd\"><td>text</td>\n",
    "<td><a class=\"reference external\" href=\"http://www.json.org/\">JSON</a></td>\n",
    "<td><a class=\"reference internal\" href=\"https://pandas.pydata.org/pandas-docs/stable/io.html#io-json-reader\"><span class=\"std std-ref\">read_json</span></a></td>\n",
    "<td><a class=\"reference internal\" href=\"https://pandas.pydata.org/pandas-docs/stable/io.html#io-json-writer\"><span class=\"std std-ref\">to_json</span></a></td>\n",
    "</tr>\n",
    "<tr class=\"row-even\"><td>text</td>\n",
    "<td><a class=\"reference external\" href=\"https://en.wikipedia.org/wiki/HTML\">HTML</a></td>\n",
    "<td><a class=\"reference internal\" href=\"https://pandas.pydata.org/pandas-docs/stable/io.html#io-read-html\"><span class=\"std std-ref\">read_html</span></a></td>\n",
    "<td><a class=\"reference internal\" href=\"https://pandas.pydata.org/pandas-docs/stable/io.html#io-html\"><span class=\"std std-ref\">to_html</span></a></td>\n",
    "</tr>\n",
    "<tr class=\"row-odd\"><td>text</td>\n",
    "<td>Local clipboard</td>\n",
    "<td><a class=\"reference internal\" href=\"https://pandas.pydata.org/pandas-docs/stable/io.html#io-clipboard\"><span class=\"std std-ref\">read_clipboard</span></a></td>\n",
    "<td><a class=\"reference internal\" href=\"https://pandas.pydata.org/pandas-docs/stable/io.html#io-clipboard\"><span class=\"std std-ref\">to_clipboard</span></a></td>\n",
    "</tr>\n",
    "<tr class=\"row-even\"><td>binary</td>\n",
    "<td><a class=\"reference external\" href=\"https://en.wikipedia.org/wiki/Microsoft_Excel\">MS Excel</a></td>\n",
    "<td><a class=\"reference internal\" href=\"https://pandas.pydata.org/pandas-docs/stable/io.html#io-excel-reader\"><span class=\"std std-ref\">read_excel</span></a></td>\n",
    "<td><a class=\"reference internal\" href=\"https://pandas.pydata.org/pandas-docs/stable/io.html#io-excel-writer\"><span class=\"std std-ref\">to_excel</span></a></td>\n",
    "</tr>\n",
    "<tr class=\"row-odd\"><td>binary</td>\n",
    "<td><a class=\"reference external\" href=\"https://support.hdfgroup.org/HDF5/whatishdf5.html\">HDF5 Format</a></td>\n",
    "<td><a class=\"reference internal\" href=\"https://pandas.pydata.org/pandas-docs/stable/io.html#io-hdf5\"><span class=\"std std-ref\">read_hdf</span></a></td>\n",
    "<td><a class=\"reference internal\" href=\"https://pandas.pydata.org/pandas-docs/stable/io.html#io-hdf5\"><span class=\"std std-ref\">to_hdf</span></a></td>\n",
    "</tr>\n",
    "<tr class=\"row-even\"><td>binary</td>\n",
    "<td><a class=\"reference external\" href=\"https://github.com/wesm/feather\">Feather Format</a></td>\n",
    "<td><a class=\"reference internal\" href=\"https://pandas.pydata.org/pandas-docs/stable/io.html#io-feather\"><span class=\"std std-ref\">read_feather</span></a></td>\n",
    "<td><a class=\"reference internal\" href=\"https://pandas.pydata.org/pandas-docs/stable/io.html#io-feather\"><span class=\"std std-ref\">to_feather</span></a></td>\n",
    "</tr>\n",
    "<tr class=\"row-odd\"><td>binary</td>\n",
    "<td><a class=\"reference external\" href=\"https://parquet.apache.org/\">Parquet Format</a></td>\n",
    "<td><a class=\"reference internal\" href=\"https://pandas.pydata.org/pandas-docs/stable/io.html#io-parquet\"><span class=\"std std-ref\">read_parquet</span></a></td>\n",
    "<td><a class=\"reference internal\" href=\"https://pandas.pydata.org/pandas-docs/stable/io.html#io-parquet\"><span class=\"std std-ref\">to_parquet</span></a></td>\n",
    "</tr>\n",
    "<tr class=\"row-even\"><td>binary</td>\n",
    "<td><a class=\"reference external\" href=\"http://msgpack.org/index.html\">Msgpack</a></td>\n",
    "<td><a class=\"reference internal\" href=\"https://pandas.pydata.org/pandas-docs/stable/io.html#io-msgpack\"><span class=\"std std-ref\">read_msgpack</span></a></td>\n",
    "<td><a class=\"reference internal\" href=\"https://pandas.pydata.org/pandas-docs/stable/io.html#io-msgpack\"><span class=\"std std-ref\">to_msgpack</span></a></td>\n",
    "</tr>\n",
    "<tr class=\"row-odd\"><td>binary</td>\n",
    "<td><a class=\"reference external\" href=\"https://en.wikipedia.org/wiki/Stata\">Stata</a></td>\n",
    "<td><a class=\"reference internal\" href=\"https://pandas.pydata.org/pandas-docs/stable/io.html#io-stata-reader\"><span class=\"std std-ref\">read_stata</span></a></td>\n",
    "<td><a class=\"reference internal\" href=\"https://pandas.pydata.org/pandas-docs/stable/io.html#io-stata-writer\"><span class=\"std std-ref\">to_stata</span></a></td>\n",
    "</tr>\n",
    "<tr class=\"row-even\"><td>binary</td>\n",
    "<td><a class=\"reference external\" href=\"https://en.wikipedia.org/wiki/SAS_(software)\">SAS</a></td>\n",
    "<td><a class=\"reference internal\" href=\"https://pandas.pydata.org/pandas-docs/stable/io.html#io-sas-reader\"><span class=\"std std-ref\">read_sas</span></a></td>\n",
    "<td>&#160;</td>\n",
    "</tr>\n",
    "<tr class=\"row-odd\"><td>binary</td>\n",
    "<td><a class=\"reference external\" href=\"https://docs.python.org/3/library/pickle.html\">Python Pickle Format</a></td>\n",
    "<td><a class=\"reference internal\" href=\"https://pandas.pydata.org/pandas-docs/stable/io.html#io-pickle\"><span class=\"std std-ref\">read_pickle</span></a></td>\n",
    "<td><a class=\"reference internal\" href=\"https://pandas.pydata.org/pandas-docs/stable/io.html#io-pickle\"><span class=\"std std-ref\">to_pickle</span></a></td>\n",
    "</tr>\n",
    "<tr class=\"row-even\"><td>SQL</td>\n",
    "<td><a class=\"reference external\" href=\"https://en.wikipedia.org/wiki/SQL\">SQL</a></td>\n",
    "<td><a class=\"reference internal\" href=\"https://pandas.pydata.org/pandas-docs/stable/io.html#io-sql\"><span class=\"std std-ref\">read_sql</span></a></td>\n",
    "<td><a class=\"reference internal\" href=\"https://pandas.pydata.org/pandas-docs/stable/io.html#io-sql\"><span class=\"std std-ref\">to_sql</span></a></td>\n",
    "</tr>\n",
    "<tr class=\"row-odd\"><td>SQL</td>\n",
    "<td><a class=\"reference external\" href=\"https://en.wikipedia.org/wiki/BigQuery\">Google Big Query</a></td>\n",
    "<td><a class=\"reference internal\" href=\"https://pandas.pydata.org/pandas-docs/stable/io.html#io-bigquery\"><span class=\"std std-ref\">read_gbq</span></a></td>\n",
    "<td><a class=\"reference internal\" href=\"https://pandas.pydata.org/pandas-docs/stable/io.html#io-bigquery\"><span class=\"std std-ref\">to_gbq</span></a></td>\n",
    "</tr>\n",
    "</tbody>\n",
    "</table>\n",
    "\n",
    "[Back to Table of Contents](#Table_of_Contents)<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following code block shows how the read_csv method that is available in Pandas can be used to read a file off the internet that uses semi-colon delimiters, store it in an object named my_data, and use the head() method to print the first fives rows of the DataFrame object.\n",
    "\n",
    "<b>Go out and read in a file from \"https://archive.ics.uci.edu/ml/machine-learning-databases/00409/Daily_Demand_Forecasting_Orders.csv\".  It is delimited with a semicolon.<b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Indexing and Selecting Data\n",
    "<a id=\"Indexing_and_Selecting_with_pandas\"> </a>\n",
    "\n",
    "Although we have already seen some ways to access data in Pandas objects, this section will look at such methods in more detail.\n",
    "\n",
    "[Back to Table of Contents](#Table_of_Contents)<br>\n",
    "\n",
    "\n",
    "### Indexing and Selecting Data in Pandas `Series` Objects\n",
    "\n",
    "Recall the `sales_series` object that we created earlier.\n",
    "\n",
    "[Back to Table of Contents](#Table_of_Contents)<br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's interesting to note that the Pandas `Series` object acts like both a one-dimensional NumPy array and a standard Python dictionary. For example, to get index values for a `Series` object, you can use the `keys()` method as shown below.\n",
    "\n",
    "[Back to Table of Contents](#Table_of_Contents)<br>\n",
    "\n",
    "<b>Return just the index vaues for the sales_series<B>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Also, as shown earlier, we can use NumPy-like slicing as is demonstrated in the following code block.\n",
    "\n",
    "[Back to Table of Contents](#Table_of_Contents)<br>\n",
    "\n",
    "<b>Get the sales for June 2015 through December 2015<b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we can use the boolean array capabilities of NumPy to get subsets of the `Series` object that satisfy a specified condition. As an example, the following code block identifies the months with sales greater than or equal to 1,000.\n",
    "\n",
    "[Back to Table of Contents](#Table_of_Contents)<br>\n",
    "\n",
    "<b>Return only the dates where the sales are at least $1000<b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Indexing and Selecting Data in Pandas `DataFrame` Objects\n",
    "\n",
    "We will now look at accessing data stored in a Pandas `DataFrame` object. Just as a reminder, the following code block prints the first five rows of the `sales_data` object that we created earlier.\n",
    "\n",
    "[Back to Table of Contents](#Table_of_Contents)<br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As shown in the following code block, we can select an entire column of the `DataFrame` object, resulting in a `Series`, by providing the column name in brackets.\n",
    "\n",
    "[Back to Table of Contents](#Table_of_Contents)<br>\n",
    "\n",
    "<b>Bring in the Sales column of the sales_data variable<b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b><b>Bring in the Store column of the sales_data variable<b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Moreover, we can return multiple columns by providing the names of the desired columns as a list. Since we are returning multiple columns, the resulting object is a `DataFrame`.\n",
    "\n",
    "[Back to Table of Contents](#Table_of_Contents)<br>\n",
    "\n",
    "<b>Bring in BOTH Store and Sales columns of the sales_data variable<b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can perform calculations using entire columns.\n",
    "\n",
    "[Back to Table of Contents](#Table_of_Contents)<br>\n",
    "\n",
    "<b>Find the average daily Sales values<b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can extract a subset of the available records by providing a boolean expression in brackets.\n",
    "\n",
    "[Back to Table of Contents](#Table_of_Contents)<br>\n",
    "\n",
    "<b>Return all of the values for all Product A<b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Return all of the data in the sales_data variable where the year is after 2010<B>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}