tools_pandas.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# **Tools - Pandas**\n",
    "*The `pandas` library provides high-performance, easy-to-use data structures and data analysis tools. The main data structure is the `DataFrame`, which you can think of as an in-memory 2D table (like a spreadsheet, with column names and row labels). Many features available in Excel are available programmatically, such as creating pivot tables, computing columns based on other columns, plotting graphs, etc. You can also group rows by column value, or join tables much like in SQL. Pandas is also great at handling time series.*\n",
    "\n",
    "Prerequisites:\n",
    "* NumPy – if you are not familiar with NumPy, we recommend that you go through the [NumPy tutorial](tools_numpy.ipynb) now."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setup\n",
    "First Let's Import `pandas` Most People Call it `pd`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# `Series` objects\n",
    "The `pandas` library contains these useful data structures:\n",
    "* `Series` objects, that we will discuss now. A `Series` object is 1D array, similar to a column in a spreadsheet (with a column name and row labels).\n",
    "* `DataFrame` objects. This is a 2D table, similar to a spreadsheet (with column names and row labels).\n",
    "* `Panel` objects. You can see a `Panel` as a dictionary of `DataFrame`s. These are less used, so we will not discuss them here."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating a `Series`\n",
    "Let's start by creating our first `Series` object!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    2\n",
       "1   -1\n",
       "2    3\n",
       "3    5\n",
       "dtype: int64"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = pd.Series([2, -1, 3, 5])\n",
    "s"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Similar to a 1D `ndarray`\n",
    "`Series` objects behave much like one-dimensional NumPy `ndarray`s, and you can often pass them as parameters to NumPy functions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0      7.389056\n",
       "1      0.367879\n",
       "2     20.085537\n",
       "3    148.413159\n",
       "dtype: float64"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "np.exp(s)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Arithmetic operations on `Series` are also possible, and they apply *elementwise*, just like for `ndarray`s:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    1002\n",
       "1    1999\n",
       "2    3003\n",
       "3    4005\n",
       "dtype: int64"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s + [1000, 2000, 3000, 4000]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similar to NumPy, if you add a single number to a `Series`, that number is added to all items in the `Series`. This is also called *broadcasting*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    1002\n",
       "1     999\n",
       "2    1003\n",
       "3    1005\n",
       "dtype: int64"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s + 1000"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The same is true for all binary operations such as `*` or `/`, and even conditional operations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    False\n",
       "1     True\n",
       "2    False\n",
       "3    False\n",
       "dtype: bool"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s < 0"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Index Labels\n",
    "Each Item in a `Series` object has a **Unique Identifier** Known as *Index Labels*, By Default it is Rank of the Item Which Starts from `0` but You can also Set Them Manually:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Praddyumn     68\n",
       "Lav           83\n",
       "Aman         112\n",
       "Aditya        68\n",
       "dtype: int64"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s2 = pd.Series([68, 83, 112, 68], index=[\"Praddyumn\", \"Lav\", \"Aman\", \"Aditya\"])\n",
    "s2"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also use `Series` Like a Python `dict`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "83"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s2[\"Lav\"]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can still use inteager Location to get the Elements But Make Sure That it Starts from `0`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "68"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s2[0]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To make it Clear to Other Developers and any Other Programm to Understand Weather You are Using `Inteager` Location or `Label` for accessing any Element You can Use `loc` while accessing through `Label` and You can You `iloc` while accessing Through `Inteager` Location.\n",
    "- `loc` = Accessing Through Label\n",
    "- `iloc` = Accession Through Inteager Location"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "68"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s2.loc[\"Praddyumn\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "68"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s2.iloc[0]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Slicing a `Series` also slices the index labels:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Lav      83\n",
       "Aman    112\n",
       "dtype: int64"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s2.iloc[1:3]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This can lead to unexpected results when using the default numeric labels, so be careful:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    1000\n",
       "1    1001\n",
       "2    1002\n",
       "3    1003\n",
       "dtype: int64"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "surprise = pd.Series([1000, 1001, 1002, 1003])\n",
    "surprise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2    1002\n",
       "3    1003\n",
       "dtype: int64"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "surprise_slice = surprise[2:]\n",
    "surprise_slice"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Oh look! The first element has index label `2`. The element with index label `0` is absent from the slice:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Key error: 0\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    surprise_slice[0]\n",
    "except KeyError as e:\n",
    "    print(\"Key error:\", e)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But remember that you can access elements by integer location using the `iloc` attribute. This illustrates another reason why it's always better to use `loc` and `iloc` to access `Series` objects:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1002"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "surprise_slice.iloc[0]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Init from `dict`\n",
    "You can create a `Series` object from a `dict`. The keys will be used as index labels:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Praddyumn    68\n",
       "Lav          83\n",
       "Aman         86\n",
       "Aditya       68\n",
       "dtype: int64"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "weights = {\"Praddyumn\": 68, \"Lav\": 83, \"Aman\": 86, \"Aditya\": 68}\n",
    "s3 = pd.Series(weights)\n",
    "s3"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can control which elements you want to include in the `Series` and in what order by explicitly specifying the desired `index`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Praddyumn    68\n",
       "Aman         86\n",
       "dtype: int64"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s4 = pd.Series(weights, index = [\"Praddyumn\", \"Aman\"])\n",
    "s4"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Automatic alignment\n",
    "When an operation involves multiple `Series` objects, `pandas` automatically aligns items by matching index labels."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index(['Praddyumn', 'Lav', 'Aman', 'Aditya'], dtype='object')\n",
      "Index(['Praddyumn', 'Aman'], dtype='object')\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Praddyumn    136\n",
       "Lav          166\n",
       "Aman         198\n",
       "Aditya       136\n",
       "dtype: int64"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(s3.keys())\n",
    "print(s4.keys())\n",
    "\n",
    "s2 + s3"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The resulting `Series` contains the union of index labels from `s2` and `s3`. Since `\"Lav\"` is missing from `s2` and `\"Aditya\"` is missing from `s3`, these items have a `NaN` result value. (ie. Not-a-Number means *missing*).\n",
    "\n",
    "Automatic alignment is very handy when working with data that may come from various sources with varying structure and missing items. But if you forget to set the right index labels, you can have surprising results:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "s2 = [ 68  83 112  68]\n",
      "s5 = [1000 1000 1000 1000]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0           NaN\n",
       "1           NaN\n",
       "2           NaN\n",
       "3           NaN\n",
       "Aditya      NaN\n",
       "Aman        NaN\n",
       "Lav         NaN\n",
       "Praddyumn   NaN\n",
       "dtype: float64"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s5 = pd.Series([1000, 1000, 1000, 1000])\n",
    "print(\"s2 =\", s2.values)\n",
    "print(\"s5 =\", s5.values)\n",
    "\n",
    "s2 + s5"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pandas could not align the `Series`, since their labels do not match at all, hence the full `NaN` result."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Init with a scalar\n",
    "You can also initialize a `Series` object using a scalar and a list of index labels: all items will be set to the scalar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "life          42\n",
       "universe      42\n",
       "everything    42\n",
       "dtype: int64"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "meaning = pd.Series(42, [\"life\", \"universe\", \"everything\"])\n",
    "meaning"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `Series` name\n",
    "A `Series` can have a `name`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Aman         83\n",
       "Praddyumn    68\n",
       "Name: weights, dtype: int64"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s6 = pd.Series([83, 68], index=[\"Aman\", \"Praddyumn\"], name=\"weights\")\n",
    "s6"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plotting a `Series`\n",
    "Pandas makes it easy to plot `Series` data using matplotlib (for more details on matplotlib, check out the **matplotlib tutorial** Which i Will be Working on in Future. Just import matplotlib and call the `plot()` method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "temperatures = [4.4,5.1,6.1,6.2,6.1,6.1,5.7,5.2,4.7,4.1,3.9,3.5]\n",
    "s7 = pd.Series(temperatures, name=\"Temperature\")\n",
    "s7.plot()\n",
    "plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are *many* options for plotting your data. It is not necessary to list them all here: if you need a particular type of plot (histograms, pie charts, etc.), just look for it in the excellent [Visualization](http://pandas.pydata.org/pandas-docs/stable/visualization.html) section of pandas' documentation, and look at the example code."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Handling time\n",
    "Many datasets have timestamps, and pandas is awesome at manipulating such data:\n",
    "* it can represent periods (such as 2016Q3) and frequencies (such as \"monthly\"),\n",
    "* it can convert periods to actual timestamps, and *vice versa*,\n",
    "* it can resample data and aggregate values any way you like,\n",
    "* it can handle timezones.\n",
    "\n",
    "## Time range\n",
    "Let's start by creating a time series using `pd.date_range()`. This returns a `DatetimeIndex` containing one datetime per hour for 12 hours starting on October 29th 2016 at 5:30pm."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2016-10-29 17:30:00', '2016-10-29 18:30:00',\n",
       "               '2016-10-29 19:30:00', '2016-10-29 20:30:00',\n",
       "               '2016-10-29 21:30:00', '2016-10-29 22:30:00',\n",
       "               '2016-10-29 23:30:00', '2016-10-30 00:30:00',\n",
       "               '2016-10-30 01:30:00', '2016-10-30 02:30:00',\n",
       "               '2016-10-30 03:30:00', '2016-10-30 04:30:00'],\n",
       "              dtype='datetime64[ns]', freq='H')"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dates = pd.date_range(\"2016/10/29 5:30pm\", periods=12, freq=\"H\")\n",
    "dates"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `DateTimeIndex` can also be used as an `Index` in Pandas `Series`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2016-10-29 17:30:00    4.4\n",
       "2016-10-29 18:30:00    5.1\n",
       "2016-10-29 19:30:00    6.1\n",
       "2016-10-29 20:30:00    6.2\n",
       "2016-10-29 21:30:00    6.1\n",
       "2016-10-29 22:30:00    6.1\n",
       "2016-10-29 23:30:00    5.7\n",
       "2016-10-30 00:30:00    5.2\n",
       "2016-10-30 01:30:00    4.7\n",
       "2016-10-30 02:30:00    4.1\n",
       "Freq: H, dtype: float64"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "temp_series = pd.Series(temperatures, dates)\n",
    "temp_series.head(n=10)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's plot this `Series`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "temp_series.plot(kind=\"barh\")\n",
    "plt.grid(True)\n",
    "plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Resampling\n",
    "Pandas lets us resample a time series very simply. Just call the `resample()` method and specify a new frequency:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<pandas.core.resample.DatetimeIndexResampler object at 0x7f39675ec9d0>"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "temp_series_freq_2H = temp_series.resample(\"2H\")\n",
    "temp_series_freq_2H"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The resampling operation is actually a deferred operation, which is why we did not get a `Series` object, but a `DatetimeIndexResampler` object instead. To actually perform the resampling operation, we can simply call the `mean()` method: Pandas will compute the mean of every pair of consecutive hours:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2016-10-29 16:00:00    4.40\n",
       "2016-10-29 18:00:00    5.60\n",
       "2016-10-29 20:00:00    6.15\n",
       "2016-10-29 22:00:00    5.90\n",
       "2016-10-30 00:00:00    4.95\n",
       "2016-10-30 02:00:00    4.00\n",
       "2016-10-30 04:00:00    3.50\n",
       "Freq: 2H, dtype: float64"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "temp_series_freq_2H = temp_series_freq_2H.mean()\n",
    "temp_series_freq_2H"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets Plot the Result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "temp_series_freq_2H.plot(kind=\"barh\")\n",
    "plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note how the values have automatically been aggregated into 2-hour periods. If we look at the 6-8pm period, for example, we had a value of `5.1` at 6:30pm, and `6.1` at 7:30pm. After resampling, we just have one value of `5.6`, which is the mean of `5.1` and `6.1`. Rather than computing the mean, we could have used any other aggregation function, for example we can decide to keep the minimum value of each period:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2016-10-29 16:00:00    4.4\n",
       "2016-10-29 18:00:00    5.1\n",
       "2016-10-29 20:00:00    6.1\n",
       "2016-10-29 22:00:00    5.7\n",
       "2016-10-30 00:00:00    4.7\n",
       "2016-10-30 02:00:00    3.9\n",
       "2016-10-30 04:00:00    3.5\n",
       "Freq: 2H, dtype: float64"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "temp_series_freq_2H = temp_series.resample(\"2H\").min()\n",
    "temp_series_freq_2H"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or, equivalently, we could use the `apply()` method instead:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2016-10-29 16:00:00    4.4\n",
       "2016-10-29 18:00:00    5.1\n",
       "2016-10-29 20:00:00    6.1\n",
       "2016-10-29 22:00:00    5.7\n",
       "2016-10-30 00:00:00    4.7\n",
       "2016-10-30 02:00:00    3.9\n",
       "2016-10-30 04:00:00    3.5\n",
       "Freq: 2H, dtype: float64"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "temp_series_freq_2H = temp_series.resample(\"2H\").apply(np.min)\n",
    "temp_series_freq_2H"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Upsampling and interpolation\n",
    "This was an example of downsampling. We can also upsample (ie. increase the frequency), but this creates holes in our data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2016-10-29 17:30:00    4.4\n",
       "2016-10-29 17:45:00    NaN\n",
       "2016-10-29 18:00:00    NaN\n",
       "2016-10-29 18:15:00    NaN\n",
       "2016-10-29 18:30:00    5.1\n",
       "2016-10-29 18:45:00    NaN\n",
       "2016-10-29 19:00:00    NaN\n",
       "2016-10-29 19:15:00    NaN\n",
       "2016-10-29 19:30:00    6.1\n",
       "2016-10-29 19:45:00    NaN\n",
       "Freq: 15T, dtype: float64"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "temp_series_freq_15min = temp_series.resample(\"15min\").mean()\n",
    "temp_series_freq_15min.head(n=10)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One Solution is to fill the gaps by interpolating. We can just call `interpolate()` method. The default is to use Interpolation, but we can also select another methode, such as cubic interpolation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2016-10-29 17:30:00    4.400\n",
       "2016-10-29 17:45:00    4.575\n",
       "2016-10-29 18:00:00    4.750\n",
       "2016-10-29 18:15:00    4.925\n",
       "2016-10-29 18:30:00    5.100\n",
       "2016-10-29 18:45:00    5.350\n",
       "2016-10-29 19:00:00    5.600\n",
       "2016-10-29 19:15:00    5.850\n",
       "2016-10-29 19:30:00    6.100\n",
       "2016-10-29 19:45:00    6.125\n",
       "Freq: 15T, dtype: float64"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "temp_series_freq_15min = temp_series.resample(\"15min\").interpolate(methode=\"cubic\")\n",
    "temp_series_freq_15min.head(n=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "temp_series.plot(label=\"Period: 1 hour\", kind=\"kde\")\n",
    "temp_series_freq_15min.plot(label=\"Period: 15 minutes\", kind=\"kde\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Timezones\n",
    "By default datetimes are *naive*: they are not aware of timezones, so 2016-10-30 02:30 might mean October 30th 2016 at 2:30am in Paris or in New York. We can make datetimes timezone *aware* by calling the `tz_localize()` method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2016-10-29 17:30:00-04:00    4.4\n",
       "2016-10-29 18:30:00-04:00    5.1\n",
       "2016-10-29 19:30:00-04:00    6.1\n",
       "2016-10-29 20:30:00-04:00    6.2\n",
       "2016-10-29 21:30:00-04:00    6.1\n",
       "2016-10-29 22:30:00-04:00    6.1\n",
       "2016-10-29 23:30:00-04:00    5.7\n",
       "2016-10-30 00:30:00-04:00    5.2\n",
       "2016-10-30 01:30:00-04:00    4.7\n",
       "2016-10-30 02:30:00-04:00    4.1\n",
       "2016-10-30 03:30:00-04:00    3.9\n",
       "2016-10-30 04:30:00-04:00    3.5\n",
       "dtype: float64"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "temp_series_ny = temp_series.tz_localize(\"America/New_York\")\n",
    "temp_series_ny"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that `-04:00` is now appended to all the datetimes. This means that these datetimes refer to [UTC](https://en.wikipedia.org/wiki/Coordinated_Universal_Time) - 4 hours.\n",
    "\n",
    "We can convert these datetimes to Kolkata time like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2016-10-29 23:30:00+02:00    4.4\n",
       "2016-10-30 00:30:00+02:00    5.1\n",
       "2016-10-30 01:30:00+02:00    6.1\n",
       "2016-10-30 02:30:00+02:00    6.2\n",
       "2016-10-30 02:30:00+01:00    6.1\n",
       "2016-10-30 03:30:00+01:00    6.1\n",
       "2016-10-30 04:30:00+01:00    5.7\n",
       "2016-10-30 05:30:00+01:00    5.2\n",
       "2016-10-30 06:30:00+01:00    4.7\n",
       "2016-10-30 07:30:00+01:00    4.1\n",
       "2016-10-30 08:30:00+01:00    3.9\n",
       "2016-10-30 09:30:00+01:00    3.5\n",
       "dtype: float64"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "temp_series_paris = temp_series_ny.tz_convert(\"Europe/Paris\")\n",
    "temp_series_paris"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You may have noticed that the UTC offset changes from `+02:00` to `+01:00`: this is because France switches to winter time at 3am that particular night (time goes back to 2am). Notice that 2:30am occurs twice! Let's go back to a naive representation (if you log some data hourly using local time, without storing the timezone, you might get something like this):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2016-10-29 23:30:00    4.4\n",
       "2016-10-30 00:30:00    5.1\n",
       "2016-10-30 01:30:00    6.1\n",
       "2016-10-30 02:30:00    6.2\n",
       "2016-10-30 02:30:00    6.1\n",
       "2016-10-30 03:30:00    6.1\n",
       "2016-10-30 04:30:00    5.7\n",
       "2016-10-30 05:30:00    5.2\n",
       "2016-10-30 06:30:00    4.7\n",
       "2016-10-30 07:30:00    4.1\n",
       "2016-10-30 08:30:00    3.9\n",
       "2016-10-30 09:30:00    3.5\n",
       "dtype: float64"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "temp_series_paris_naive = temp_series_paris.tz_localize(None)\n",
    "temp_series_paris_naive"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now `02:30` is really ambiguous. If we try to localize these naive datetimes to the Paris timezone, we get an error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pytz.exceptions.AmbiguousTimeError'>\n",
      "Cannot infer dst time from 2016-10-30 02:30:00, try using the 'ambiguous' argument\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    temp_series_paris_naive.tz_localize(\"Europe/Paris\")\n",
    "except Exception as e:\n",
    "    print(type(e))\n",
    "    print(e)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Fortunately using the `ambiguous` argument we can tell pandas to infer the right DST (Daylight Saving Time) based on the order of the ambiguous timestamps:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2016-10-29 23:30:00+02:00    4.4\n",
       "2016-10-30 00:30:00+02:00    5.1\n",
       "2016-10-30 01:30:00+02:00    6.1\n",
       "2016-10-30 02:30:00+02:00    6.2\n",
       "2016-10-30 02:30:00+01:00    6.1\n",
       "2016-10-30 03:30:00+01:00    6.1\n",
       "2016-10-30 04:30:00+01:00    5.7\n",
       "2016-10-30 05:30:00+01:00    5.2\n",
       "2016-10-30 06:30:00+01:00    4.7\n",
       "2016-10-30 07:30:00+01:00    4.1\n",
       "2016-10-30 08:30:00+01:00    3.9\n",
       "2016-10-30 09:30:00+01:00    3.5\n",
       "dtype: float64"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "temp_series_paris_naive.tz_localize(\"Europe/Paris\", ambiguous=\"infer\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Periods\n",
    "The `pd.period_range()` function returns a `PeriodIndex` instead of a `DatetimeIndex`. For example, let's get all quarters in 2016 and 2017:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "PeriodIndex(['2016Q1', '2016Q2', '2016Q3', '2016Q4', '2017Q1', '2017Q2',\n",
       "             '2017Q3', '2017Q4'],\n",
       "            dtype='period[Q-DEC]')"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "quarters = pd.period_range(\"2016Q1\", periods=8, freq=\"Q\")\n",
    "quarters"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Adding a number `N` to a `PeriodIndex` shifts the periods by `N` times the `PeriodIndex`'s frequency:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "PeriodIndex(['2016Q4', '2017Q1', '2017Q2', '2017Q3', '2017Q4', '2018Q1',\n",
       "             '2018Q2', '2018Q3'],\n",
       "            dtype='period[Q-DEC]')"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "quarters + 3"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `asfreq()` method lets us change the frequency of the `PeriodIndex`. All periods are lengthened or shortened accordingly. For example, let's convert all the quarterly periods to monthly periods (zooming in):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "PeriodIndex(['2016-03', '2016-06', '2016-09', '2016-12', '2017-03', '2017-06',\n",
       "             '2017-09', '2017-12'],\n",
       "            dtype='period[M]')"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "quarters.asfreq(\"M\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By Default `asfreq` zooms on end of each period. But we can tell it to Zoom at end of each Period Instead:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "PeriodIndex(['2016-01', '2016-04', '2016-07', '2016-10', '2017-01', '2017-04',\n",
       "             '2017-07', '2017-10'],\n",
       "            dtype='period[M]')"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "quarters.asfreq(\"M\", how=\"start\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And We can Zoom Out:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "PeriodIndex(['2016', '2016', '2016', '2016', '2017', '2017', '2017', '2017'], dtype='period[A-DEC]')"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "quarters.asfreq(\"A\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Of Course We can Create a `Series` With `PeriodIndex`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2016Q1    300\n",
       "2016Q2    320\n",
       "2016Q3    290\n",
       "2016Q4    390\n",
       "2017Q1    320\n",
       "2017Q2    360\n",
       "2017Q3    310\n",
       "2017Q4    410\n",
       "Freq: Q-DEC, dtype: int64"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "quarterly_revenue = pd.Series([300, 320, 290, 390, 320, 360, 310, 410], index=quarters)\n",
    "quarterly_revenue"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjEAAAGtCAYAAADnIyVRAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAAA9hAAAPYQGoP6dpAABi30lEQVR4nO3deXiTVdo/8G+WJl2T7httaaFQKLTsSxU3VhWRbcZxBgEVFxRxe8fXwXHU0R+Dr7O4ixuKjguOjoigiKACAm0phUIpO6Ub3SilSdesz++PNKGVVpo2yZPl+7muXJc2yfPcCXB6n3Puc45EEAQBRERERB5GKnYARERERL3BJIaIiIg8EpMYIiIi8khMYoiIiMgjMYkhIiIij8QkhoiIiDwSkxgiIiLySHKxA+gNs9mMyspKhISEQCKRiB0OERER9YAgCGhsbER8fDyk0r6Po3hkElNZWYnExESxwyAiIqJeKC8vR0JCQp+v45FJTEhICADLl6BSqUSOhoiIiHpCq9UiMTHR9nu8rzwyibFOIalUKiYxREREHsZRpSAs7CUiIiKPxCSGiIiIPBKTGCIiIvJITGKIiIjIIzGJISIiIo/EJIaIiIg8EpMYIiIi8khMYoiIiMgjMYkhIiIij8QkhoiIiDwSkxgiIiLySExiiIiIyCMxiSEiIiKPxCSGiIiIXOLuD/c59HpMYoiIiMjpGtsM2Hum3qHXZBJDRERETrev5AJMZsGh12QSQ0RERE6XXXze4ddkEkNEREROl32aSQwRERF5GE2rAUWVGodfl0kMEREROVXemXqYBSA5ItCh12USQ0RERE5lrYcZmxzu0OsyiSEiIiKnstbDjE9hEkNEREQeoqFFj6PVWgDAuOQwh16bSQwRERE5Te6ZeggCkBodjKgQf4dem0kMEREROY11KmniAMdOJQFMYoiIiMiJctqLerMGRDr82kxiiIiIyCnON+lwrLoRAEdiiIiIyINYD3xMiwlBRLDS4ddnEkNEREROYd0fJmtghFOuzySGiIiInMKZRb0AkxgiIiJygnONOpysbYJEAkxI4UgMEREReQjrqqQhsSqEBSmccg8mMURERORwF5dWO2cUBmASQ0RERE7g7KJegEkMEREROViNtg3F55ohkQDjHXxydUdMYoiIiMihrFNJw+JVUAf6Oe0+TGKIiIjIoaxLq51ZDwMwiSEiIiIHy3FBPQzQxyTm+eefh0QiwcMPP2z7WVtbG5YtW4aIiAgEBwdj/vz5qKmp6fS+srIyzJw5E4GBgYiOjsZjjz0Go9HYl1CIiIjIDVRpWlFyvgVSCTDWifUwQB+SmLy8PLz11lvIzMzs9PNHHnkEGzduxOeff44dO3agsrIS8+bNsz1vMpkwc+ZM6PV67NmzBx988AHWrl2Lp556qvefgoiIiNyCdSopo58aKn/n1cMAvUximpqasGDBArzzzjsICwuz/Vyj0WDNmjX417/+hcmTJ2PMmDF4//33sWfPHuTk5AAAvv/+exw5cgQfffQRRo4ciRtuuAHPPfccXn/9dej1esd8KiIiIhKF7agBJ08lAb1MYpYtW4aZM2di6tSpnX6en58Pg8HQ6edDhgxBUlISsrOzAQDZ2dnIyMhATEyM7TUzZsyAVqtFUVFRl/fT6XTQarWdHkREROR+cs64pqgXAOT2vmHdunXYv38/8vLyLnmuuroaCoUCoaGhnX4eExOD6upq22s6JjDW563PdWXVqlX461//am+oRERE5EIVF1pQXt8KmVSCcU6uhwHsHIkpLy/HQw89hI8//hj+/v7OiukSK1asgEajsT3Ky8tddm8iIiLqGetUUmaCGkFKu8dJ7GZXEpOfn4/a2lqMHj0acrkccrkcO3bswCuvvAK5XI6YmBjo9Xo0NDR0el9NTQ1iY2MBALGxsZesVrL+v/U1v6RUKqFSqTo9iIiIyL1ku+C8pI7sSmKmTJmCwsJCFBQU2B5jx47FggULbP/t5+eHH374wfae48ePo6ysDFlZWQCArKwsFBYWora21vaarVu3QqVSIT093UEfi4iIiFxJEATknHbN/jBWdo31hISEYPjw4Z1+FhQUhIiICNvPlyxZgkcffRTh4eFQqVRYvnw5srKyMHHiRADA9OnTkZ6ejoULF+KFF15AdXU1nnzySSxbtgxKpdJBH4uIiIhcqby+FZWaNvjJJBjTP+zyb3AAh09Yvfjii5BKpZg/fz50Oh1mzJiBN954w/a8TCbDpk2bcN999yErKwtBQUFYvHgxnn32WUeHQkRERC6SXVwHABiREIpAhfPrYQBAIgiC4JI7OZBWq4VarYZGo2F9DBERkRt4eN0BfFVQieWTU/E/09O6fI2jf3/z7CQiIiLqE0EQXF7UCzCJISIioj46U9eMGq0OCpkUo11UDwMwiSEiIqI+yimuBwCMSgqFv5/MZfdlEkNERER9Yp1KmujCqSSASQwRERH1gSAItp16XbU/jBWTGCIiIuq10+eaUNekg1IuxaikUJfem0kMERER9Vp2ez3MmP5hUMpdVw8DMIkhIiKiPrAdNeDiehiASQwRERH1kiAIyLEW9bq4HgZgEkNERES9dKKmCeeb9Qjwk2FEQqjL788khoiIiHol+7TlvKSxyWFQyF2fUjCJISIiol6xbnLn6v1hrJjEEBERkd3MZgE5Z8TZ5M6KSQwRERHZ7Vh1IxpaDAhUyJCZoBYlBiYxREREZDfrUQPjksPhJxMnnWASQ0RERHazLq129VEDHTGJISIiIruYzAJyi8Xb5M6KSQwRERHZ5WiVFto2I4KVcgyLV4kWB5MYIiIisov11OrxKeGQi1QPAzCJISIiIjtlu8FUEsAkhsjnNbTo8dC6A/j55DmxQyEiD2A0mZF3xrLJnZhFvQCTGCKf9+necmwoqMRfvjoMQRDEDoeI3FxRpRaNOiNU/nIMjROvHgZgEkPk86zDwiXnW3CgvEHcYIjI7VnbjPEpEZBJJaLGwiSGyIcZTGbsK6m3/f9XB86KGA0ReQJrUa/YU0kAkxgin3aoQoMWvQmS9s7UxoOV0BvN4gZFRG7LYDIjr73jI3ZRL8AkhsinWXfcnDo0BpHBSlxoMWDnCRb4ElHXCs9aOj6hgX4YEhsidjhMYoh8mXVYeFJqJGaPjAcArOeUEhF1w9pmTEgJh1TkehiASQyRz9IbzdhXenGZ5NxR/QAAW4/WQNNqEDM0InJTOW6yP4wVkxgiH3WwogFtBjMigxUYFB2MYfEqDIoOht5oxneHq8QOj4jcjN5oxr6SCwCArIGRIkdjwSSGyEfZhoUHREAikUAikWDuaMtozJf7OaVERJ0dqmhAq8GEiCAFBscEix0OACYxRD7Ltkyyw7Dw7JGWJCb3TD3ONrSKEhcRuSdrmzGxvePjDpjEEPmgNoMJ+WWWYeGJHZKYfqEBmDggHAD3jCGizqyb3FnbCHfAJIbIBxWUN0BvNCMqRImBUUGdnrMW+K4/cJbHEBARAEBnNCG/1FoP4x5FvQCTGCKf1HEq6ZfDwjdkxEEhl+JUbROKKrVihEdEbuZAWQN0to6Pe9TDAExiiHySdVi4qx6Vyt8P04bGAOCeMURkkVPsfvUwAJMYIp/TZjChoKwBQOd6mI6sU0obCiphNPEYAiJfd7Go133qYQAmMUQ+J7/0AvQmM2JV/kiOCOzyNVcPjkJYoB/qmnTY3d54EZFvajOYcKC94+Mum9xZMYkh8jE5HaaSuhsWVsilmDWi/RiC/RUui42I3M/+9o5PjEqJlMigy7/BhZjEEPmYrvaH6Yp1SmlLUQ2adUanx0VE7qnjUQPuVA8DMIkh8ikteiMOVjQAuPwyyZGJoUiJDEKrwYQtRdUuiI6I3NGvLQQQG5MYIh+yr+QCDCYB/UIDkBAW8KuvlUgkmDPy4p4xROR7WvUmFJQ3AOh+IYCYmMQQ+RB7l0nOGWWpi9l9qg412janxkZE7mdfaT0MJgHxan8khXe9EEBMTGKIfIi9w8L9I4Iwpn8YzALwdUGlM0MjIjdkW1r9KwsBxMQkhshHNOmMOFShAWDf3PacUZxSIvJVHYt63RGTGCIfkVdSD5NZQFJ4IPqF/no9TEc3ZcTBTybBkSotjlc3OjFCInInzR06Pu5YDwPYmcSsXr0amZmZUKlUUKlUyMrKwubNm23PV1dXY+HChYiNjUVQUBBGjx6N//73v52uUV9fjwULFkClUiE0NBRLlixBU1OTYz4NEXUrp5c7boYFKXBtWjQAjsYQ+ZK8knoYzQISwgKQ6Ib1MICdSUxCQgKef/555OfnY9++fZg8eTJmz56NoqIiAMCiRYtw/PhxfP311ygsLMS8efNwyy234MCBA7ZrLFiwAEVFRdi6dSs2bdqEnTt34p577nHspyKiS+T0YZnkPNsxBGdhNvNkayJfkO3mU0mAnUnMrFmzcOONN2LQoEEYPHgwVq5cieDgYOTk5AAA9uzZg+XLl2P8+PEYMGAAnnzySYSGhiI/Px8AcPToUXz33Xd49913MWHCBEyaNAmvvvoq1q1bh8pKFg0SOYu2zYDCs+31MAMi7X7/dUOiEeIvR5WmDTlneAwBkS+wjt664/4wVr2uiTGZTFi3bh2am5uRlZUFALjiiivw2Wefob6+HmazGevWrUNbWxuuvfZaAEB2djZCQ0MxduxY23WmTp0KqVSK3Nzcbu+l0+mg1Wo7PYio5/LO1MMsACmRQYhV+9v9fn8/GW7KjAMArN/PKSUib9fYoePjrvUwQC+SmMLCQgQHB0OpVGLp0qVYv3490tPTAQD/+c9/YDAYEBERAaVSiXvvvRfr169HamoqAEvNTHR0dKfryeVyhIeHo7q6+x1BV61aBbVabXskJibaGzaRT3PECbRzRyUAADYfrkar3uSQuIjIPeWVWDo+/SMCEW/HQgBXszuJSUtLQ0FBAXJzc3Hfffdh8eLFOHLkCADgL3/5CxoaGrBt2zbs27cPjz76KG655RYUFhb2KcgVK1ZAo9HYHuXl5X26HpGvye6wyV1vje0fhn6hAWjSGbHtaI2jQiMiN9TTM9bEJrf3DQqFwjayMmbMGOTl5eHll1/G//7v/+K1117D4cOHMWzYMADAiBEj8PPPP+P111/Hm2++idjYWNTW1na6ntFoRH19PWJjY7u9p1KphFKptDdUIgKgaTHgSJVlCrYvDZJUKsHcUf3w2k+nsP7AWdsp10Tkfdz5vKSO+rxPjNlshk6nQ0tLi+WC0s6XlMlkMJvNAICsrCw0NDTYCn0B4Mcff4TZbMaECRP6GgoRdSH3zHkIAjAwKgjRKvvrYTqybny348Q5nG/SOSI8InIzmlYDiir73vFxBbuSmBUrVmDnzp0oKSlBYWEhVqxYge3bt2PBggUYMmQIUlNTce+992Lv3r04ffo0/vnPf2Lr1q2YM2cOAGDo0KG4/vrrcffdd2Pv3r3YvXs3HnjgAdx6662Ij2evjsgZHNmjSo0ORmaCGiazgI0HuaKQyBvtPVMPQQAGOKDj42x2JTG1tbVYtGgR0tLSMGXKFOTl5WHLli2YNm0a/Pz88O233yIqKgqzZs1CZmYmPvzwQ3zwwQe48cYbbdf4+OOPMWTIEEyZMgU33ngjJk2ahLffftvhH4yILC4W9TqmR2U72ZpnKRF5JUe3Gc5kV03MmjVrfvX5QYMGXbJD7y+Fh4fjk08+see2RNRLF5r1ONZ+VICjGqRZI+Kx8tujOFjegNPnmjAwKtgh1yUi9+AJm9xZ8ewkIi+W274x3eCYYEQGO6Y4PipEiasGWTbM28BjCIi8yoVmPY62LwTwhJEYJjFEXsxZyyTnWk+2LjgLQeAxBETeIvdMPQBgUHQwokLcf1UwkxgiL+aI/WG6Mj09FkEKGcrrW5FfesGh1yYi8eQ4qc1wFiYxRF6qrkmHEzWWE+InOLhBClDIcP1wyzEEX3JKichrZHvAeUkdMYkh8lK5xZZh4SGxIQgPUjj8+vNGW6aUvjlUBZ2RxxAQebrzTTocr3HsQgBnYxJD5KWyi+sAOK9HNXFABGJUSmhaDfjp2Dmn3IOIXCfHyR0fZ2ASQ+SlnH32iUwqubhnzIEKp9yDiFzH0+phACYxRF6pVtuG0+eaIZEAE1Kc1yBZjyH46dg5NLTonXYfInI+Zy0EcCYmMUReKKd9mWR6nArqQD+n3WdonApDYkOgN5nxTWGV0+5DRM5V29iGU7VNkEiAiQPCxQ6nx5jEEHkhZ08ldWTdM+YrrlIi8ljWepihsSqEBnpGPQzAJIbIK+U48NDHy5k9sh8kEiCv5ALK61ucfj8icjxXthmOxCSGyMtUa9pwpq4ZUgkwLsX5w8Kxan9c0d7wcTSGyDPluHD01pGYxBB5GevS6uH91FD5O68epqO5oxIAAOsP8BgCIk9To21DsQs7Po7EJIbIy+Sctsxtu7JHdf3wWPj7SVFc14yDFRqX3ZeI+s5aQzcsXg11gGs6Po7CJIbIy9iWSbpwbjtYKcf09FgAnFIi8jSedtRAR0xiiLzI2YZWlNW3QCaVYFyya4eF57YfQ7DxYCUMJrNL701EvZdzxjPrYQAmMURexdqjyuinRrBS7tJ7X5UaichgBc436/HzSR5DQOQJKhtaUXre0vEZmxwmdjh2YxJD5EXEHBaWy6SYNSIeAPDlfk4pEXkCa5sxvJ8aIS5aCOBITGKIvIhtrweRhoWtG99tPVKDxjaDKDEQUc9li9xm9BWTGCIvUV7fgrMNrfCTiTcsnNFPjYFRQdAZzdh8uFqUGIio5zx1kzsrJjFEXsI6LDwiIRSBCtfWw1hJJBIeQ0DkIcrrW1BxoRVyqQRj+3tePQzAJIbIa7jLCbSzR1qSmOzi86jStIoaCxF1z9pmZCaoEeTihQCOwiSGyAsIguA2w8KJ4YEYnxIOQQA2FFSKGgsRdS/Hg/eHsWISQ+QFSs+3oErTBoVMijFuMCxsnVJav5/HEBC5I0EQOhT1RoocTe8xiSHyAtbGaGRSKPz9ZCJHA9yYEQeFTIrjNY04UqUVOxwi+oWyekvHx08mcYuOT28xiSHyAtludgKtOsAPU4ZGA2CBL5E7srYZIxNDEaAQv+PTW0xiiDxcx2FhsYt6O7JOKW0oqITJzCklInfi6fvDWDGJIfJwxXXNONeog0IuxaikULHDsbk2LRqhgX6obdRhz+k6scMhonaCINhGYlx5UKwzMIkh8nDWxmhMUphb1MNYKeRS3JQZB8BS4EtE7qG4rhm17R2f0UmeWw8DMIkh8njZbrK0uivWKaXviqrRojeKHA0RARd36R3tJgsB+oJJDJEHEwQBuW5YD2M1OikMSeGBaNGb8H1RjdjhEBEujt66Y5thLyYxRB7sZG0T6pr08PeTYkSiWuxwLiGRSDDHumcMVykRic6yMWY9AM8v6gWYxBB5NOuw8Nj+4VDK3XNY2Dql9PPJc6htbBM5GiLfdqq2CXVNOijlUox0o4UAvcUkhsiDZXvAtuEpkUEYlRQKswBsPFgldjhEPs3W8UkOc9uOjz2YxBB5KLP54nlJ7j63bTuG4ECFyJEQ+TZv2R/GikkMkYc6XtOICy0GBCpkyExwv3qYjm7KjIdcKsHhs1qcrGkUOxwin2Tp+FjqYdy949NTTGKIPNTFYeFw+Mnc+59yeJAC16ZFAWCBL5FYTtQ2or5ZjwA/GTITQsUOxyHcu+Ujom6523lJlzN3VAIAyzEEZh5DQORy1jZjbHIYFHLv+PXvHZ+CyMeYzQJyz7Qvk3Tjot6OpgyNRohSjrMNrdhbUi92OEQ+J8eNN8bsLSYxRB7oSJUWmlYDgpVyDI9XiR1Oj/j7yXBjBo8hIBJDx46Pt9TDAExiiDyStUc1LjkMcjevh+nIuvHdt4VVaDOYRI6GyHccrdaiocWAIIUMGf3ceyGAPTyn9SMiG08dFp6QEo5+oQFo1Bnxw9FascMh8hnWephxKe6/EMAe3vNJiHyEqWM9zIBIkaOxj1QqweyR8QC4SonIlbzpqIGOmMQQeZiiSg0a24wI8Zcj3UPqYTqybny3/Xgt6pv1IkdD5P0sHR/PHL29HCYxRB7GOiw8ISUcMqlE5GjsNygmBMP7qWA0C/jmUKXY4RB5vSOVWkvHRylHepzndXx+jV1JzOrVq5GZmQmVSgWVSoWsrCxs3ry502uys7MxefJkBAUFQaVS4eqrr0Zra6vt+fr6eixYsAAqlQqhoaFYsmQJmpqaHPNpiHyApxw18GvmjLSMxnzJKSUip8surgMAjE8J96iFAD1h16dJSEjA888/j/z8fOzbtw+TJ0/G7NmzUVRUBMCSwFx//fWYPn069u7di7y8PDzwwAOQSi/eZsGCBSgqKsLWrVuxadMm7Ny5E/fcc49jPxWRlzKazMgruQDAs4eFbx4ZD6kEOFDWgDN1zWKHQ+TVPOGg2N6SCILQp60zw8PD8fe//x1LlizBxIkTMW3aNDz33HNdvvbo0aNIT09HXl4exo4dCwD47rvvcOONN6KiogLx8fE9uqdWq4VarYZGo4FK5V1DY0S/5kDZBcx9Yw9CA/2w/8lpkHrgdJLVovf2YueJc3hoyiA8Mm2w2OEQeSWjyYyRz25Fk86ITcsnYbjIy6sd/fu71+NKJpMJ69atQ3NzM7KyslBbW4vc3FxER0fjiiuuQExMDK655hrs2rXL9p7s7GyEhobaEhgAmDp1KqRSKXJzc7u9l06ng1ar7fQg8kXWE2gnpIR7dAIDAPPaC3y/KjiLPvalSAS7T9Vh6b/zcbah9fIvJtEcrtSiSWeEyl+OoV5WDwP0IokpLCxEcHAwlEolli5divXr1yM9PR3FxcUAgGeeeQZ33303vvvuO4wePRpTpkzByZMnAQDV1dWIjo7udD25XI7w8HBUV1d3e89Vq1ZBrVbbHomJifaGTeQVrMPCnlwPYzV9WAwCFTKUnm/B/rIGscMhO1xo1mP5pwfwXVE1/vbtUbHDoV9hWwgwIMIjFwJcjt1JTFpaGgoKCpCbm4v77rsPixcvxpEjR2A2mwEA9957L+644w6MGjUKL774ItLS0vDee+/1KcgVK1ZAo9HYHuXl5X26HpEnMpjM2OcF9TBWgQo5rh8WCwBYf6BC5GjIHiu/PWpbHv/NoSocq+bouLuyjt562/4wVnYnMQqFAqmpqRgzZgxWrVqFESNG4OWXX0ZcnOVMlPT09E6vHzp0KMrKygAAsbGxqK3tvEun0WhEfX09YmNju72nUqm0rYiyPoh8zaGKBrQaTAgPUmBwdIjY4TiE9RiCTYeqoDeaRY6GemLPqTp8kV8BiQS27etf3nZS5KioK5aOj2cdFGuvPq+1MpvN0Ol0SE5ORnx8PI4fP97p+RMnTqB///4AgKysLDQ0NCA/P9/2/I8//giz2YwJEyb0NRQir3ZxKsnz62GsrkyNRHSIEg0tBmw/zmMI3F2bwYQn1hcCABZN7I9/3jICEgmw+XA1iio1IkdHv3SoQoMWvQlhgX5Ii/GOjs8v2ZXErFixAjt37kRJSQkKCwuxYsUKbN++HQsWLIBEIsFjjz2GV155BV988QVOnTqFv/zlLzh27BiWLFkCwDIqc/311+Puu+/G3r17sXv3bjzwwAO49dZbe7wyichXZXvB/jC/JOtwDMFXBdwzxt29+uNJlJxvQazKH3+ckYbBMSG4KdPy5/cSR2PcTo5tIUCE13R8fkluz4tra2uxaNEiVFVVQa1WIzMzE1u2bMG0adMAAA8//DDa2trwyCOPoL6+HiNGjMDWrVsxcOBA2zU+/vhjPPDAA5gyZQqkUinmz5+PV155xbGfisjL6Iymi/UwXpTEAJYppXd+PoNtR2uhaTVAHeAndkjUhWPVWry1w7KA49nZwxDib/lzemjKIHxzqBJbj9SgsEKDjATvOSHZ03nz/jBWdiUxa9asuexr/vSnP+FPf/pTt8+Hh4fjk08+see2RD7vYLkGOqMZkcFKpEYHix2OQ6XHqZAWE4LjNY3YXFiFW8cniR0S/YLJLOBP/y2E0Szg+mGxmD7sYg1janQwbh4Rj68KKvHSthNYc/s4ESMlK53RhH2l3l0PA/DsJCKP0LEeRiLxrmFhiURiK/DlMQTu6ePcUhSUNyBEKcczNw+75PkHpwyCVAL8cKwWB8sbXB8gXeJQhQZtBjMigxUY5GUdn46YxBB5AOvZJ97ao5o9Mh4SCbD3TD3K61vEDoc6qNK04oXvLAs2/veGIYhV+1/ymgFRwbZE9MVtJ1waH3Wt4/4w3tbx6YhJDJGbazOYbJvBeVNRb0fxoQGYmGL5bF8f5MnW7uTpDUVo0hkxpn8YFvzKVN+DkwdBJpVg+/Fz2F92wYURUle8aWPMX8MkhsjNHShrgN5oRnSIEgMig8QOx2nmjm6fUtpfwWMI3MR3h6vx/ZEayKUS/G1uxq+ucEmODML89j/DF7dyNEZMbQYT8su8cyHALzGJIXJzth03B3r3sPANw2OhlEtx+lwzDp/lDrBi07YZ8PTXhwEAS68ZiLTYy+8zsnzyIMilEvx8ss62yRq5nrXjExWixMAo7+34AExiiNxezmnv3jbcKsTfD9PSYwAAX/IYAtH9/bvjqNHqkBIZhAcmp/boPYnhgfjt2AQArI0RU06Howa8ueMDMIkhcmutehMOlFuGhb19bhsA5rVPR2w8WAmjiccQiCW/tB4f5ZYCAFbOHQ5/P1mP37vsulT4ySTYfeo8ctt/mZJreePGmN1hEkPkxvJLL8BgEhCn9kf/iECxw3G6qwZFISJIgbomPX4+VSd2OD5JbzRjxZeFEATgt2MScMXASLvenxAWiFvGJgLgaIwY2gwmFLQvBPDW1YwdMYkhcmO+NCwMAH4yKWaNaD+GgHvGiOLtnadxoqYJEUEKPHHj0F5dY9l1qVDIpMgprsee00xGXSm/9AL0JjNiVf5I9oGOD5MYIjdmGxb2gR6VlXW/kS1F1WjSGUWOxrcUn2vCKz+eAgA8NSsdYUGKXl0nPjQAt463jMa8tPUkV5u5UMejBnyh48MkhshNNeuMtt1Pvb2ot6MRCWoMiAxCm8GMLYerxQ7HZwiCgCfWF0JvNOPqwVG4eUTfDuW9/9pUKORS7C2px+5TrI1xlY6jt76ASQyRm9pXegFGs4B+oQFIDPf+YWGrjscQrOeUkst8nl+BnOJ6+PtJsXLO8D734mPV/vhD++Z4/9p6nKMxLtCiN+JgRQMA3yjqBZjEELktXziBtjtzRlqSmN2n61CtaRM5Gu9X16TDym+OAgAenTbYYUnz/dcOhFIuxf6yBuw8ydoYZ9tXYlkIYOn4BIgdjkswiSFyU742LNxRUkQgxvYPgyAAXx/kaIyzPbfpCDStBqTHqXDnlSkOu260yh+3TewPAPjX1hMcjXGyjkurfaEeBmASQ+SWmnRGFJ7VAPDNkRig4zEETGKcafvxWmwoqIRUAjw/PwNymWN/LSy9ZiD8/aQ4WN6A7cfPOfTa1FlOse+N3jKJIXJDeWfqYTIL6B8RiPhQ3xgW/qWZGXFQyKQ4Vt2Io1U8hsAZWvRGPPmV5WiBO65MQWZCqMPvERWixKKsZACWfWM4GuMcTTojDlVYOj4TB4SLHI3rMIkhckO2YeEU3+lR/VJooALXDYkCwD1jnOWlbSdRcaEV/UID8Oi0wU67z71XD0CgQoZDFRr8cLTWaffxZXkllo5PYngAEsJ8ZyEAkxgiN+SLw8JdmTvKcg7PhoJKmMzswTvS4bMavPtzMQDg/80ZjiCl3Gn3ighWYvEVyQBYG+MsvnLG2i8xiSFyM9o2Aw77eD2M1XVDoqAO8EO1ts2W2FHfGU2WowXMAnBTZhyuGxLt9Hvec9UABClkOFKlxZaiGqffz9dk+2jHh0kMkZvZW1wPswAMiAxCjMpf7HBEpZTLMDMzDgD3jHGktXtKUHhWA5W/HE/NSnfJPcOCFLijfeXTS9tOwMyRNYfp2PHxlf1hrJjEELkZa49qgo81Rt2Z277x3ebCKrTqTSJH4/nK61vwz+8tBzM+ceNQRIe4LlG+66oUhCjlOFbdiO+KuBuzo+SdsXR8kiMCEaf2rYUATGKI3Iwvb3LXlbH9w5AQFoBmvQlbj3Iaoi8EQcBfNhxGq8GE8SnhttOmXSU0UIE7JnE0xtF8uc1gEkPkRhpa9DhabVlO7EvLJH+NRCKxjcas318hcjSebdOhKmw/fg4KmRR/m5sBqdT1G6ItmZSCEH85TtQ04ZvCKpff3xt13OTO1zCJIXIjuWfqIQhAanSwS4f53Z31LKWdJ+twrlEncjSeSdNiwF83FgEAll2XitToYFHiUAf44a5JAwAAL/9wkqvO+kjTYsCR9n2UfG1lEsAkhsitZPvoMsnLGRgVjBEJapjMAjYdqhQ7HI+0avNR1DXpkRodjKXXDhA1ljsmJUMd4IdTtU388+yj3DPnIQjAwKggRPvgQgAmMURuJMeHh4UvZy5Ptu613OLzWJdXDgBYNS8DSrlM1HhU/n64+ypLbczL207CaDKLGo8n8+WpJIBJDJHbON+kw7HqRgCsh+nKrBHxkEklOFShwanaJrHD8Rg6owkr1hcCAH4/Pgnjkt3j79btV6YgNNAPxXXN+PogR2N6y5eLegEmMURuY++ZegBAWkwIIoKVIkfjfiKClbhmMI8hsNcbP51G8blmRIUo8acbhogdjk2wUo57rrZMa73yA0djeqO+Wd+h48MkhohE5Ks7btrDOqX0VcFZLs/tgVO1jXhj+ykAwDOzhkEd4CdyRJ0tzkpGeJACJedbOE3YC3vPWNqMwTHBiPTRjg+TGCI3YR0W5lRS96alxyBYKUfFhVbsK70gdjhuzWwWsOLLQhhMAqYMicaNGbFih3SJIKUc91pHY348CQNHY+xysc3w3Y4PkxgiN3CuUYeTtU2QSIAJPnxy9eX4+8lww3DLL2P23H/durxy5JVcQKBChmfnDIdE4vo9YXpiYVZ/RAYrUF7fii+5D5BdbKO3TGKISEy57cPCQ2JVCAtSiByNe7NOKX1zqBJtBh5D0JVabRtWbT4KAPjj9DT0C3XfregDFXIsvWYgAOCVH05Bb+RoTE/UNelwosZS4O7LR5QwiSFyA9wfpucmDohAnNof2jYjth+vFTsct/TXjUfQ2GZEZoIai69IFjucy7ptYn9EhShxtqEVn+eXix2OR7BuxzAkNgThPtzxYRJD5AZY1NtzUqkEN4+MBwB8uZ9TSr+07UgNvimsgkwqwap5GZCJcLSAvfz9ZLj/WstozOs/noLOyBG2y8lhmwGASQyR6Gq0bSg+1wyJBBjvJnt4uLt5oxIAAD8dr8WFZr3I0biPJp0RT204DMByYvSweLXIEfXc78cnIUalRKWmDf/J42jM5bCo14JJDJHIrD2qYfEqqAPdawmsu0qLDcHQOBUMJoGHCHbwz++Po1LThsTwADw8ZbDY4djF30+GZdelAgBe/+k0651+Ra22DafbOz4TfXwhAJMYIpHlcIVBr8zjMQSdFJQ3YO2eEgDAyjkZCFCIe7RAb/xuXCLi1P6o1rZh3d4yscNxW9bp5/Q4dnyYxBCJzNe3De+tm0fGQyoB8ksvoOx8i9jhiMpgMmPFl4UQBMvqravbdzb2NEr5xdGYN7ZzNKY7OcWW3b3Z8WESQySqKk0rSs63QCqB25xp4yliVP64MjUSAEdj1uw6g6NVWoQG+uHJmUPFDqdPbhmbiH6hAaht1OHjXI7GdIUHxV7EJIZIRNZRmIx+aoT4+/awcG90PIZAEHzzGILS8814adsJAMCTM9M9/twthVyKByZbRmNWbz+NVj1HYzqq1rThTF0zpBJgPHf3ZhJDJCZbj4pTSb0yY1gsAvxkOFPXjILyBrHDcTlBEPDkV4fRZjDjioERmD+6n9ghOcRvxiQgMTwAdU06fJRTKnY4biW7uA4AMLyfGip2fJjEEImJ24b3TZBSjhnDYgD45snWXxWcxc8n66CUS/G3uRlue7SAvfxkUiy/bhAA4M0dp9GiN4ockfvgxpidMYkhEknFhRaU17dCJpWwHqYP5rRPKW08VOVTBwjWN+vx3CbL0QIPThmE5MggkSNyrLmj+6F/RCDON+vxYTZHY6ysRb0cvbVgEkMkEmuPKjNBjSClXORoPNek1EhEBitR36zHzhPnxA7HZVZ+cxT1zXqkxYTgnvaToL2Jn0yK5ZMtozFv7TiNJh1HY842tKKsvoUdnw6YxBCJhFNJjiGXSXHziPZjCHxkSmn3qTr8d38FJBJg1fwM+Mm8symfMzIeKZFBuNBiwAfte+D4so4LAYLZ8QFgZxKzevVqZGZmQqVSQaVSISsrC5s3b77kdYIg4IYbboBEIsFXX33V6bmysjLMnDkTgYGBiI6OxmOPPQajkRk2+RZBEJBr3euBw8J9Nq+9oHXrkRpo2wwiR+NcbQYTnlhfCABYNLE/RieFiRyR88hlUjw0xTIa8/bOYjR6+Z/t5XBPqUvZlcQkJCTg+eefR35+Pvbt24fJkydj9uzZKCoq6vS6l156qcsCM5PJhJkzZ0Kv12PPnj344IMPsHbtWjz11FN9+xREHqa8vhVnG1rhJ5NgbH8OC/fVsHgVBkUHQ28047vCarHDcapXfjiJ0vMtiFX5448z0sQOx+lmjYjHwKggaFoNeH93idjhiIq7e1/KriRm1qxZuPHGGzFo0CAMHjwYK1euRHBwMHJycmyvKSgowD//+U+89957l7z/+++/x5EjR/DRRx9h5MiRuOGGG/Dcc8/h9ddfh17PQ9zId1iXSY5MDPXI7eHdjUQisRX4fnmgQuRonOdolRZv7ywGADw7e5hP7C0kk0rw0FTLOVDv/lwMTatvjsaU17fgbEMr5FIJxiZ77+ibvXo9kWoymbBu3To0NzcjKysLANDS0oI//OEPeP311xEbG3vJe7Kzs5GRkYGYmBjbz2bMmAGtVnvJaE5HOp0OWq2204PIk/EEWsezJjE5xfU429AqcjSOZzILWPFlIYxmAdcPi8X0YZe2sd5qZkYcBkUHQ9tmxHu7zogdjiisbcaIxFAEKlgPY2V3ElNYWIjg4GAolUosXboU69evR3p6OgDgkUcewRVXXIHZs2d3+d7q6upOCQwA2/9XV3c/BLxq1Sqo1WrbIzEx0d6widyGIAgs6nWCfqEBmJBimZrbUOB9Bb4f5ZSioLwBwUo5nrl5mNjhuJRMKsHD7aMx7+06A02L743GsM3omt1JTFpaGgoKCpCbm4v77rsPixcvxpEjR/D111/jxx9/xEsvveTwIFesWAGNRmN7lJeXO/weRK5Scr4FNVodFDIpRvfnsLAjWQt81+/3rmMIKhta8cJ3xwAAj1+fhli1v8gRud4Nw2MxJDYEjToj3t1VLHY4LiUIAot6u2F3EqNQKJCamooxY8Zg1apVGDFiBF5++WX8+OOPOH36NEJDQyGXyyGXW4a75s+fj2uvvRYAEBsbi5qamk7Xs/5/V9NPVkql0rYiyvog8lTWxmhUUij8/VgP40jXD4+DQi7FydomFFV6x7SzIAh4akMRmvUmjE4KxYIJ/cUOSRRSqQQPT7WsVHp/dwkuNPtOHWXp+RZUa9ssHR8vXo3WG33eXMBsNkOn0+FPf/oTDh06hIKCAtsDAF588UW8//77AICsrCwUFhaitrbW9v6tW7dCpVLZpqSIvJ1tWJg9KodTB/hh2lDvOoZgS1E1th2tgVwqwap5mZBKveNogd6Ynh6L9DgVmnRGvPOz74zGWNsMLgS4lF1JzIoVK7Bz506UlJSgsLAQK1aswPbt27FgwQLExsZi+PDhnR4AkJSUhJSUFADA9OnTkZ6ejoULF+LgwYPYsmULnnzySSxbtgxKpWefvErUEx2HhVnU6xzWAt8NByth9PBjCLRtBjy1wbLoYek1A5EWGyJyROLqOBqzdk8JzjfpRI7INWxtBjs+l7AriamtrcWiRYuQlpaGKVOmIC8vD1u2bMG0adN69H6ZTIZNmzZBJpMhKysLt912GxYtWoRnn322V8ETeZrT55pR16SDUi7FqKRQscPxStcMjkJYoB/ONeqwu73x91QvfHcMtY06pEQG4YHJqWKH4xampcdgeD8VWvQmvO0DozFcCPDr7FqntWbNGrsu3lVhXf/+/fHtt9/adR0ib2FtjMb0D4NSzmFhZ1DIpbgpMx7/zinFVwfO4prBUWKH1Cv7SurxUU4ZAGDl3OGsn2onkUjwyNTBWPLBPny4pxR3XzUAkcHeO5J/+lwzzjXqoGDHp0veeeAGkZvKOc0elSvMbV+l9N3hajR74MGBeqMZK760HC3w2zEJuGJgpMgRuZfJQ6IxIkGNVoMJb+04LXY4TmXdpXdMUhgT2S4wiSFyEUEQbA0S57ada1RiKJIjAtFqMOH7I553DMFbO07jZG0TIoIUeOLGoWKH43YkEgkenmbZN+bfOaWobWwTOSLnsY7esoaua0xiiFzkRE0TzjfrEeAnw4iEULHD8WqdjiHY71mrlIrPNeHVn04BAJ6alY6wIIXIEbmnawdHYVRSKNoMZry53TtrYywHxXI1469hEkPkItZRmLHJYVDI+U/P2ea2JzG7T9WhVusZPXVBEPDE+kLojWZcPTgKN4+IFzsktyWRSPBo+2jMR7mlqPGQP2N7nKxtQl2THv5+UoxIVIsdjltiS0rkIlxa7Vr9I4IwOikUZgH4+mCl2OH0yOf5Fcgproe/nxQr5wyHROK7e8L0xKTUSIztHwa90Yw32kevvImt49M/nAsBusEkhsgFzGYBOWc4LOxqc0cnAADWe8DGd3VNOqz85igA4NFpg5EYHihyRO6v42jMp3vLUaXxroM/L3Z8wkWOxH0xiSFygWPVjWhoMSBQIUNGPw4Lu8pNGXHwk0lQVKnFiZpGscP5Vc9tOgJNqwHpcSrceWWK2OF4jKyBERifEg69yYzXvWg0xmy+uBCAHZ/uMYkhcgHrCoNxyeHwk/GfnauEBSlwbVo0APcejdl+vBYbCiohlQDPz8+AnH9HeqzjaMxneeU42+AdozHHaxpxob3jk8mFAN3ivxQiF2CPSjzWAt8NB87CbHa/k61b9EY8+dVhAMAdV6bwF1YvTBwQgawBETCYBLz2o3eMxlinksay4/Or+M0QOZnJ3GGZJIt6XW7ykGiE+MtRqWmz1SW5k5e2nUTFhVb0Cw2wjSiQ/R5p/+4+31eO8voWkaPpuxy2GT3CJIbIyY5WaaFtMyJYKceweJXY4fgcfz8ZZmbEAXC/k60Pn9Xg3fbzf/7fnOEIUtp1Egx1MD4lHFcNioTR7PmjMWazgNwz9QBY1Hs5TGKInMw6LDw+JZy1DiKxTiltLqxGm8EkcjQWRpPlaAGzANyUGYfrhkSLHZLHe3iqZTTmi/0VKD3fLHI0vXekSgtNqwHBSjkXAlwGW1QiJ+OwsPjGJYejX2gAGnVGbDtaI3Y4AIC1e0pQeFYDlb8cT81KFzscrzCmfxiuGRwFk1nAqx48GpNjWwgQxo7PZfDbIXIio8mMve3DwizqFY9UKsGcUZbdb9e7wTEE5fUt+Of3JwAAT9w4FNEh/iJH5D2stTFf7q/AmTrPHI3hQoCeYxJD5ERFlVo06oxQ+csxNI71MGKyTintOHEO55t0osUhCAL+suEwWg0mjE8Jxy1jE0WLxRuNTAzF5CHRMAvAqz+cFDscu5k61MNkDeDp5ZfDJIbIiaz7w4xPiYBMyi3kxZQaHYKMfmoYzQI2HaoSLY5Nh6qw/fg5KGRS/G1uBqT8e+FwD08dBAD4quAsTp9rEjka+xRVatDYZkSIvxzpXAhwWUxiiJzIWtTLYWH3YB2NEWvjO02LAX/dWAQAuP+6gUiNDhYlDm+XmRCKqUNjYBaAVzxsNMbaZkxICWfHpweYxBA5icFkxr4S67Awkxh3MGtEPGRSCQrKG1AsQg991eajqGvSY2BUEO67dqDL7+9LrKMxXx+sxEk3P3KiI+voLQ+K7RkmMUROUnhWg2a9CWGBfhgSGyJ2OAQgKkSJqwZZ6gy+KnDtydY5xeexLq8cALBqXiZPJXay4f3UmDEsBoIAvOQhozFGkxl5XAhgFyYxRE5ycVg4gnUPbsQ6pfTVgbMQBNccQ9BmMOGJ9YUAgN+PT8L4FG5g5grWfWO+LazCsWqtyNFcnrXjow7ww9BY1sP0BJMYIifJsQ0L8xeWO5meHosghQxl9S3IL73gknu+sf00is81IypEiT/dMMQl9yRgaJwKN2bEQhCAl7e5/2iMdSppQko4Oz49xCSGyAn0RjP2lVh+QWYN5DJJdxKgkOH64ZZjCFxR4HuyphGrt1s2Xntm1jCoA/ycfk+66KEpgyGRAJsPV+NIpXuPxnAhgP2YxBA5waGKBrQaTIgIUmBwDFeguBvrlNKmQ1XQGZ13DIHZLGDFl4UwmARMGRKNGzNinXYv6lpabIjt7KyXtp0QOZrude74MInpKSYxRE5g7VFNHBABiYTDwu4ma2AEYlRKaFoN2H78nNPu82leGfaVXkCgQoZn5wzn3wWRPDx1ECQS4PsjNTh8ViN2OF0qPGvp+IQHKTA4mgsBeopJDJETZLMexq3JpBLMHtm+Z4yTjiGo0bbh+W+PAQD+OD0N/UIDnHIfurzU6BDMHmE5dsJdR2M67g/DepieYxJD5GA6o8lWMMphYfdlnVL68VgtNC0Gh1//rxuL0KgzIjNBjcVXJDv8+mSfB6cMglQCbDtai4PlDWKHc4lsnpfUK0xiiBysoKwBOqMZUSFKDIxiPYy7GhqnwpDYEOhNZnxT6NhjCLYeqcG3hdWQSSVYNS+DO6+6gQFRwZjTnri622iMzmi6WA/DTe7swiSGyME67rjJGgj31nHPGEdp0hnx1IbDAIC7rkrBsHi1w65NffPg5EGQSSX46fg57C9zzfL6njhYroHOaEZksIJHUdiJSQyRg9mWSbJH5fZuHhkPiQTYW1KP8voWh1zzH1uOo0rThsTwADw8ZbBDrkmOkRwZhHm20Rj32TfGVg/Djo/dmMQQOVCbwYQDZQ0AWNTrCeLUAbiivQZhQ0HfR2MKyhvwQXYJAGDlnAwEKHi0gLtZPnkQ5FIJdp44h/zSerHDAQBkF9cBYMenN5jEEDnQ/tIL0JvMiFEpkRIZJHY41ANz2lcpfdnHYwgMJjP+9N9DEATLNNXVg6McFSI5UFJEIH4zJgEA8OJW8Udj2gwm7G/v+LCo135MYogcyHrUQBaHhT3GDRlx8PeTovhcMw5V9H4PkXd/PoNj1Y0IDfTDkzOHOjBCcrRl16XCTybBrlN1yG3/NyuW/WUXoDeaER2ixAB2fOzGJIbIgbhM0vMEK+WYnm7ZSbe3xxCUnm+2rXh5cmY6IoKVDouPHC8xPBC/HZsIAHhR5JVKOcUXT61mx8d+TGKIHKRVb0JB+/4TEzm37VGsq5Q2HqyEwWS2672CIODP6w9DZzTjioERmD+6nzNCJAdbdl0qFDIpcorrsed0nWhx5HTY3ZvsxySGyEH2ldbDYBIQr/ZHUnig2OGQHa4aFImIIAXON+ux66R9v9DWHziLXafqoJRL8be5GexNe4h+oQH43TjLaMxLW0/2qR6qt1r1Jhwo5/4wfcEkhshBrPUwEzks7HHkMilmtW9L/6UdU0r1zXo8t+kIAMuOsMmsafAo9183EAq5FHtL6rHntOtrY/JLL8BgEhCn9kf/CHZ8eoNJDJGDcH8YzzavfRro+6JqNLb17BiCld8cxYUWA9JiQnDP1QOcGR45QZw6AH8YnwQA+NfWEy4fjem4tJodn95hEkPkAM06o21lC+e2PVNGPzUGRAVBZzTju8PVl3397lN1+O/+CkgkwKr5GfCTsTn1RPddOxBKuRT5pRfws51TiX1lLeqdyIUAvcZ/dUQOkFdSD6NZQEJYABJZD+ORJBKJbTfXry6z8V2bwYQn1hcCABZN7I/RSWFOj4+cI0blj9sm9gfg2tGYZp3RdhAlR297j0kMkQNkF3MqyRvMbt/4bs/p86jStHb7uld+OInS8y2IVfnjjzPSXBUeOcnSawbC30+KgvIGbD9+ziX33Fd6AUazgH6h7Pj0BZMYIgfouNcDea7E8ECMTw6HIABfF1R2+ZqjVVq8vbMYAPDX2cMQ4u/nyhDJCaJClFiUlQzAsm+MK0ZjbDV0bDP6hEkMUR81thlw+KylHoYNkueb217g29XGdyazgBVfFsJoFjBjWAxmDIt1dXjkJPdcPQABfjIcqtDgh6O1Tr9fDkdvHYJJDFEf5ZXUw2QWkBwRiDh1gNjhUB/dODwOCpkUx6obcaRS2+m5j3JKUVDegGClHH+9ebhIEZIzRAYrsfiKZADOH41p0hlR2N7xYVFv3zCJIeqjbO646VXUgX6YMjQaQOcC38qGVrzw3TEAwOPXpyFW7S9KfOQ891w9AEEKGYoqtfj+SI3T7pN3xtLxSQoPRL9Qdnz6gkkMUR/xvCTvM6d9ldKGgrMwmQUIgoCnNhShWW/C6KRQLJjQX+QIyRnCgxS4/cpkAMBL207CbHbOaAwXAjiOXUnM6tWrkZmZCZVKBZVKhaysLGzevBkAUF9fj+XLlyMtLQ0BAQFISkrCgw8+CI2m86mwZWVlmDlzJgIDAxEdHY3HHnsMRqPRcZ+IyIU0rQYUtU85sEHyHtelRSM00A81Wh2yT5/HlqJqbDtaA7lUglXzMiGVcmMyb3X3VQMQrJTjaJUWW4ouv19Qb7Co13Hk9rw4ISEBzz//PAYNGgRBEPDBBx9g9uzZOHDgAARBQGVlJf7xj38gPT0dpaWlWLp0KSorK/HFF18AAEwmE2bOnInY2Fjs2bMHVVVVWLRoEfz8/PC3v/3NKR+QyJn2nqmHIAADooIQreL0grdQyKWYmRGHj3PL8GF2ie1gz6XXDERabIi4wZFThQYqcOeVyXjlx1N4adtJzBgW69Ck1dLx4caYjiIR+li9FB4ejr///e9YsmTJJc99/vnnuO2229Dc3Ay5XI7NmzfjpptuQmVlJWJiYgAAb775Jh5//HGcO3cOCoWiR/fUarVQq9XQaDRQqVR9CZ+oT57deATv7T6DP0xIwt/mZogdDjlQfmk95q/Otv1/SmQQNj90Ffz9ZCJGRa6gaTFg0gs/orHNiNf+MAo3ZcY77NrbjtTgrg/3ISUyCD/98VqHXddTOPr3d69rYkwmE9atW4fm5mZkZWV1+RprkHK5ZcAnOzsbGRkZtgQGAGbMmAGtVouioqJu76XT6aDVajs96FLaNgOe3nAY/9p6wmlzudQZ57a91+iksE6nka+cO5wJjI9QB/phyaQUAJbaGJMD21Nrm8FRGMewO4kpLCxEcHAwlEolli5divXr1yM9Pf2S19XV1eG5557DPffcY/tZdXV1pwQGgO3/q6u7n3tctWoV1Gq17ZGYmGhv2F7vZE0j5ry2Gx9kl+KVH07ipR9Oih2S12to0eNYtSWhZoPkfSQSCW4db2lrfjc2EVcMjBQ5InKlOyelQOUvx6naJmw61PXGh73BehjHsjuJSUtLQ0FBAXJzc3Hfffdh8eLFOHLkSKfXaLVazJw5E+np6XjmmWf6HOSKFSug0Whsj/Ly8j5f05t8W1iF2a/vRnFdM8KDLFNyr/xwEl91sVkXOU5OsaUeZlB0MKJClGKHQ05w79UD8fnSLKycyz1hfI3K3w93X2U5mfzlHxwzGtPQosdRW8cnvM/Xo14kMQqFAqmpqRgzZgxWrVqFESNG4OWXX7Y939jYiOuvvx4hISFYv349/PwubskdGxuLmprOa++t/x8b2/3Ol0ql0rYiyvogwGgyY9Xmo7j/4/1o0ZtwxcAIbH3katx7jeUf3v9+cQj5pfUiR+m9cri02uvJpBKMSw6HnCdU+6Tbr0xGaKAfis814+uDfe8U5rYvBBgYFYToEC4EcIQ+/8s0m83Q6XQALCMw06dPh0KhwNdffw1//85/SFlZWSgsLERt7cUtnbdu3QqVStXllBR1r75Zj9vfz8NbOyxnuNxz9QB8eOd4RAQr8fiMIZieHgO9yYx7PsxHeX2LyNF6J25yR+TdQvz9cM/V7aMx207CaDL36XqcSnI8u5KYFStWYOfOnSgpKUFhYSFWrFiB7du3Y8GCBbYEprm5GWvWrIFWq0V1dTWqq6thMpkAANOnT0d6ejoWLlyIgwcPYsuWLXjyySexbNkyKJUcju+pwgoNZr26C7tO1SFQIcNrfxiFJ24caustSqUSvHTrSAyLV+F8sx5LPshDY5tB5Ki9y/kmHY7XNAJgEkPkzRZnJSM8SIGS8y1dnqdlj4vnJbG+ylHsSmJqa2uxaNEipKWlYcqUKcjLy8OWLVswbdo07N+/H7m5uSgsLERqairi4uJsD2sNi0wmw6ZNmyCTyZCVlYXbbrsNixYtwrPPPuuUD+eNvsivwPw39+BsQyuSIwKx/v4ru1z+F6iQ493FYxEdosSJmiYs//RAn3sRdFHuGcs03ZDYEFsdEhF5nyClHPe2j8a8+uMpGHrZjp5v0uFYtbXjw3oYR7Frs7s1a9Z0+9y1117bowOz+vfvj2+//dae2xIAvdGM5zYdwb9zSgEAU4ZE41+/Gwl1gF+374lTB+DdxWNxy1vZ2H78HFZ+exRPzxrmqpC9GqeSiHzHwqz+eOfnYpTVt+DL/RX43bgku6+xt73jkxYTgohgzjw4CqvVPECNtg2/fycH/84phUQCPDJ1MN5ZNPZXExirzIRQvHjLSADA+7tLbEkQ9Q3PSyLyHYEKOZZeMxCAZTRGb7R/NObi/jAchXEkJjFuLq+kHje9ugv5pRcQ4i/HmsVj8dDUQXZtg31DRhwem5EGAHjm6yL8fPKcs8L1CbWNbThV2wSJBJiQwgaJyBcsmNAfkcFKVFxoxRf5FXa/n0W9zsEkxk0JgoAPs0vw+7dzcK5Rh7SYEGx8YBImD4m5/Ju7cP+1AzFvdD+YzALu/3g/TtU2Ojhi35FTbBkWHhqrQmgg62GIfEGAQob7r7WMxrz+0ynojKYev/dcow4nbR0fJjGOxCTGDbUZTPifzw/iqQ1FMJoFzBoRj/XLrkByZFCvrymRSLBqXgbGJYehsc2IO9fuQ32z3oFR+w7uD0Pkm/4wIQkxKiXONrTiP/t6PhpjbTOGxKoQxoUADsUkxs2U17dg/uo9+HL/WcikEjw5cyheuXUkAhV21WB3SSmX4a2FY5EUHoiy+hYs/Xe+Xb0Jssg5zfOSiHyRv58M91+bCgB4/cdTaDP0rP3M4RlrTsMkxo38fPIcZr22C0WVWkQEKfDvJeNx11UDIJE47hj48CAF3rt9LEL85dhbUo8nvjzco1VlZFGjbUNxXTOkEmAc62GIfM7vxiUiTu2Pam0bPsvr2RE4LOp1HiYxbkAQBLyx/RQWv7cXDS0GjEhQY+PySU47cC41OgSv/2E0ZFIJ/ru/Aqt3nHbKfbyRtThvWLy6R6vDiMi7+PvJcP917aMxP11+NKZG24bic82sh3ESJjEia9IZcd9H+/HCd8dhFiyn5X52bxbiQwOcet+rB0fhmVmWox5e+O44vjtc5dT7eQvWwxDRLWMT0C80ALWNOnySW/arr7W2GcPiVVAHsuPjaExiRHSqtgmzX9uF74qq4SeT4G9zM/B/v8mEv5/MJfdfmJWM269IBgA8/FkBCis0LrmvJ8vm3DaRz1PKZVjWPhrzxvbTaNV3PxrDehjnYhIjki1F1Zjz+m6cPteMWJU/Prs3C3+YYP8ukH315MyhuGZwFNoMZtz1YR6qNW0uj8FTVDa0ovR8C2RSCcYmh4kdDhGJ6DdjEpAQFoC6Jh0+zu1+E1Hu7u1cTGJczGQW8Pctx3Dvv/PRpDNifEo4Ni6fhNFJ4vxSlMukePUPozA4Jhg1Wh2WfJCHFr1RlFjcnbUxGt5PjRB/DgsT+TKFXIoHJw8CAKzefrrLdrNK04qS8y1cCOBETGJcqKFFjzvW5uH1nyyFtHdemYKP75qAqBBxz9FQ+fthzeJxiAhSoKhSi4fXFcBs5oqlX+JUEhF1NHd0PySFB+J8sx7/zr50NMba8cnop4aKHR+nYBLjIkcqtZj12i7sPHEO/n5SvHzrSDw1Kx1+Mvf4I0gMD8Tbi8ZAIZPi+yM1eGHLcbFDcjss6iWijvxkUjw4xTIa8+aO02jSdR6NsU0lsc1wGvf4DerlvjpwFvNW70Z5fSuSwgOx/v4rMXtkP7HDusSY/uF44TeZACz/IP+zr2d7IPiC8voWVFxohVwqwdj+rIchIos5I+OREhmECy0GfLCnpNNzOWc4eutsTGKcyGAy468bi/DwZwVoM5hxbVoUNj4wCUPjVGKH1q05o/rhwcmWqvs/ry+0jT74OutUUmaCGkHKvu+eTETeQS6T4sEpljbznZ+L0dhmAABUXGhBeX1r+0IA1sM4C5MYJ6ltbMOCd3Lx/u4SAMDyyalYs3icR+wT8PDUwZiZGQeDScDSj/JRUtcsdkiiy+EJtETUjZtH9MOAqCA0tBiwtr3Nt04lZSaoEcyOj9MwiXGC/NILmPXqLuwtqUewUo63F47B/0xPg0zquOMDnEkqleCfvx2BEYmhaGgx4M4P8qBpMYgdlmgEQeiw14NzdlEmIs8lk0rwUHttzDs/F0PbZuBCABdhEuNAgiDg49xS3Pp2Nmq0OqRGB2PDA1di+rBYsUOzm7+fDO8sGoN4tT+KzzXj/k/yYTCZxQ5LFGX1LajUtMFPJsEY1sMQURduyozHoOhgaNuMeG/XGeQW1wPg6K2zMYlxkDaDCY//9xD+vP4wDCYBNwyPxVfLrsTAqGCxQ+u16BB/vLt4HAIVMuw+dR5Pf13kk4dFWoeFRyWGIUDhmt2UicizyKQSPDT14kqlsw2t7Pi4AJMYBzjb0Ipb3srGf/ZVQCoB/nTDELyxYLRXzIOmx6vwyq2jIJEAn+SW2Wp8fAlPoCWinrhxeBzSYkLQZrCMWo9ICEWgwvN/D7gzJjF9tOdUHWa9uguHKjQIC/TDh3dOwNJrBkIi8Yz6l56Ymh6DP984FADw/745gh+P1YgckesIgsC9HoioR6RSCR5uH40BOJXkCkxiekkQBLy98zRuW5OL+mY9hvdT4esHJmHSIO8s/FwyKQW/H58IswAs/+QAjlVrxQ7JJc7UNaO2UQeFXCra0RBE5DlmDIvFiAQ1JBJgytAYscPxehzn6oVmnRH/+99D+OZQFQBg/ugErJw73GWnT4tBIpHg2dnDUXq+BXtOn8eStfvw1bIrRT8ywdmsU0mjk0K9+s+XiBxDKpXgwyUTcPZCK9Lj3XdPMG/BkRg7nalrxtw3duObQ1WQSyV4bvYw/OO3mT7xC85PJsXqBWMwIDIIZxtacc+/96HN0P0R9N7AOpXEpdVE1FPqAD8mMC7CJMYO247U4OZXd+FETROiQ5T47N6JWJiV7FX1L5ejDvTDmtvHQR3ghwNlDXjsi0Neu2LJsj+MZZkki3qJiNwPk5geMJsF/GvrCdz14T406owY2z8Mm5ZPwpj+vvmLLSUyCG/eNgZyqQQbD1bi5R9Oih2SU5yqbUJdkw5KuRQjk0LFDoeIiH6BScxlaFoNuOvDfXil/Rf14qz++OTuiYhW+YscmbiyBkbg/80ZDgB4adtJbCg4K3JEjmfdpXdschiUcu+fLiQi8jQs7P0Vx6q1uPff+Sg93wKlXIqVczPwmzEJYoflNm4dn4Tiuma8vbMYj31xCInhgV61gofbhhMRuTeOxHTj64OVmPv6HpSeb0G/0AD8974rmMB04fHrh2Dq0BjojWbc8+E+VFxoETskhzCbO9bDMIkhInJHTGJ+wWgyY+U3R/DgpwfQajDhqkGR2LR8Eob3U4sdmluSSSV4+daRGBqnQl2THkvW7rMdRe/JTtQ2or5ZjwA/GTITQsUOh4iIusAkpoO6Jh1uW5OLd34+AwC479qBWHvHeIQFKUSOzL0FKeVYs3gsokKUOF7TiAc/PQCT2bNXLOWcvlgPo5DznwkRkTti69yuoLwBs17dhZziegQpZFi9YDQev34IZFLfWT7dF/GhAXh30Vgo5VL8dPwcVn5zVOyQ+sRWD8Ntw4mI3BaTGACf5ZXhljezUaVpw4CoIGx44ErckBEndlgeZ0RiKP51y0gAwHu7z+CjnFJxA+ols1lA7hlLPQyLeomI3JdPJzE6owkrvizE4/8thN5kxrT0GGxYdiVSo0PEDs1jzcyMwx+nDwYAPP11EXadrBM5IvsdrdaiocWAIIWMtVBERG7MZ5OYKk0rbnkrB5/uLYNEAjw2Iw1v3TYGIf5+Yofm8ZZdl4q5o/rBZBZw38f5OFXbJHZIdrEeNTAuJRx+Mp/9J0JE5PZ8soXOKT6PWa/uwsHyBqgD/PD+7eOw7LpUSFn/4hASiQTPz8/A2P5haGwzYskHeahv1osdVo9Zl1ZzKomIyL35VBIjCALW7DqDBe/moq5Jj6FxKmx8YBKuTYsWOzSvo5TL8NbCMUgMD0Dp+RYs/Xc+dEb3PyzSZBaQe4ZFvUREnsBnkphWvQkPf1aA5zYdgcksYPbIeHx53xVIiggUOzSvFRGsxJrF4xCilGNvST3+vP6w2x8WeaRSi8Y2I0KUcqTH8RRaIiJ35hNJTNn5Fsx9Yzc2FFRCJpXg6VnpeOl3IxGg4Hk4zjY4JgSvLRgNqQT4Ir8Cb+0sFjukX5VdbClEHp8SDjnrYYiI3JrXt9I/Ha/FTa/+jGPVjYgMVuCTuybgjitTIJGw/sVVrhkchWduHgYA+L/vjuG7w9UiR9Q9a1Evp5KIiNyf1yYxZrOAV384iTvX5kHbZsSopFBsWn4VJrBYUxSLspKxOKs/BAF45LMCHD6rETukSxhNZuSVXADA85KIiDyBVyYx2jYD7v0oH//cegKCACyYkIR190xErNpf7NB82l9uSsfVg6PQajBhyQd5qNa0iR1SJ4crtWjSGaEO8GM9DBGRB/C6JOZkTSPmvLYbW4/UQCGX4oX5mVg5NwNKOetfxCaXSfHaH0ZhUHQwarQ63PVhHlr0RrHDsrFOJY1PCedyeyIiD+BVScy3hVWY/fpuFNc1I17tj8/vzcIt4xLFDos6UPn7Yc3icQgPUuDwWS0e/ewgzG5yWKTtvCROJREReQSvSGKMJjNWbT6K+z/ejxa9CVcMjMDG5ZMwIjFU7NCoC0kRgXhr4RgoZFJ8V1SNf3x/XOyQYDCZsa+kfZM7FvUSEXkEu5KY1atXIzMzEyqVCiqVCllZWdi8ebPt+ba2NixbtgwREREIDg7G/PnzUVNT0+kaZWVlmDlzJgIDAxEdHY3HHnsMRmPvpxTqm/W4/f08vLXDsnT3nqsH4MM7xyMiWNnra5LzjUsOx/PzMwAAb2w/jS/yK0SN51CFBi16E8IC/ZAWw7OziIg8gV1JTEJCAp5//nnk5+dj3759mDx5MmbPno2ioiIAwCOPPIKNGzfi888/x44dO1BZWYl58+bZ3m8ymTBz5kzo9Xrs2bMHH3zwAdauXYunnnqqV8EXndVg1qu7sOtUHQL8ZHj196PwxI1Dub+Hh5g3OgEPXJcKAFjx5SHsbT85Wgw57VNJEwdEsB6GiMhDSIQ+bqEaHh6Ov//97/jNb36DqKgofPLJJ/jNb34DADh27BiGDh2K7OxsTJw4EZs3b8ZNN92EyspKxMTEAADefPNNPP744zh37hwUCkWP7qnVaqFWqzHgj1/AJPNHckQg3lo4Fmmx7EF7GrNZwAOf7se3hdUIC/TDV8uuRP+IIJfHcdu7udh1qg5/vXkYFl+R7PL7ExH5Auvvb41GA5Wq76tAez1kYTKZsG7dOjQ3NyMrKwv5+fkwGAyYOnWq7TVDhgxBUlISsrOzAQDZ2dnIyMiwJTAAMGPGDGi1WttoTld0Oh20Wm2nBwAYjGZMGRKNDQ9MYgLjoaRSCf7525HITFDjQosBd67Ng6bV4NIYdEYT9pWyHoaIyNPYncQUFhYiODgYSqUSS5cuxfr165Geno7q6mooFAqEhoZ2en1MTAyqqy07tFZXV3dKYKzPW5/rzqpVq6BWq22PxETLiqP7rx2IdxaNhTrAz96PQW4kQCHDu4vGIk7tj9PnmvHAJ/thMJlddv9DFRq0GcyIDFZgUHSwy+5LRER9Y3cSk5aWhoKCAuTm5uK+++7D4sWLceTIEWfEZrNixQpoNBrbo7y8HABw/3WprF/wEtEqf7y7eCwCFTL8fLIOz3xd5LLDIq37w0wYEMHjKIiIPIjdSYxCoUBqairGjBmDVatWYcSIEXj55ZcRGxsLvV6PhoaGTq+vqalBbGwsACA2NvaS1UrW/7e+pitKpdK2Isr6IO8zLF6Nl343EhIJ8HFuGdbuKXHJfa1JDI8aICLyLH1exmM2m6HT6TBmzBj4+fnhhx9+sD13/PhxlJWVISsrCwCQlZWFwsJC1NbW2l6zdetWqFQqpKen9zUU8gLTh8VixQ1DAADPbTqCn47VXuYdfdNmMCG/zHJeEje5IyLyLHJ7XrxixQrccMMNSEpKQmNjIz755BNs374dW7ZsgVqtxpIlS/Doo48iPDwcKpUKy5cvR1ZWFiZOnAgAmD59OtLT07Fw4UK88MILqK6uxpNPPolly5ZBqeS+LmRx91UDcLq2GZ/tK8fyTw/gi/uyMCTWOaNvBeUN0BvNiApRYmCU61dFERFR79mVxNTW1mLRokWoqqqCWq1GZmYmtmzZgmnTpgEAXnzxRUilUsyfPx86nQ4zZszAG2+8YXu/TCbDpk2bcN999yErKwtBQUFYvHgxnn32Wcd+KvJoEokEz80ZjtL6ZuQU12PJ2n34atmViApxfKJrnUrKYj0MEZHH6fM+MWJw9Dpzck8NLXrMfWMPztQ1Y1RSKD69eyL8/Rx7kOctb2Vj75l6rJqXgd+PT3LotYmIqDO32SeGyNlCAxVYs9iyhP5AWQP+94tDDl2x1GYwoaCsAQCLeomIPBGTGHJrA6KCsXrBaMilEnx9sBKv/HDKYdfOL70AvcmMWJVl12ciIvIsTGLI7V2RGon/N2c4AODFbSew8WClQ65rPS8payDrYYiIPBGTGPIIt45Pwl2TUgAAf/z8IA60L4vui45FvURE5HmYxJDHWHHjUEwZEg2d0Yy7P8zH2YbWXl+rRW/EwYoGADwviYjIUzGJIY8hk0rw8u9HYUhsCOqadFiyNg9NOmOvrrWv5AIMJgH9QgOQEBbg4EiJiMgVmMSQRwlWyrHm9nGIDFbiWHUjHvr0AExm+1csZRdfPGqA9TBERJ6JSQx5nH6hAXhn0Rgo5VL8cKwWq749avc1Ohb1EhGRZ2ISQx5pVFIY/nnLCADAu7vO4JPcsh6/t0lnxKEKDQBg4oBwp8RHRETOxySGPNZNmfF4dNpgAMBTGw5j96m6Hr0vr6QeJrOAxPAAJIRxfxgiIk/FJIY82vLJqZg9Mh5Gs4D7PsrH6XNNl31PDpdWExF5BSYx5NEkEgn+b34mRieFQttmxJK1ebjQrP/V97AehojIOzCJIY/n7yfD24vGIiEsACXnW7D0o3zojeYuX6ttM6DwrKUeJmtApCvDJCIiB2MSQ14hMliJNYvHIVgpR+6Zejz5VWGXh0XmnamHWQBSIoMQq/YXIVIiInIUJjHkNdJiQ/DqH0ZBKgH+s68Cb+8svuQ11qMGuCqJiMjzMYkhr3JdWjSeuikdAPD8d8ewpai60/MdN7kjIiLPxiSGvM7iK5KxcGJ/CALw8LoCHG6vgdG0GHCkSguAK5OIiLwBkxjyOhKJBE/PSsdVgyLRajDhrg/2oUbbhtwz5yEIwMCoIESrWA9DROTpmMSQV5LLpHjtD6ORGh2Mam0b7vpgH346XguAU0lERN6CSQx5LXWAH95bPA5hgX4oPKvBp3vLAXB/GCIib8EkhrxaUkQg3l40FgrZxb/qHIkhIvIOTGLI641LDseqeRkAgJGJoYgMVoocEREROYJc7ACIXGH+mASkx6sQHcIEhojIWzCJIZ8xNE4ldghERORAnE4iIiIij8QkhoiIiDwSkxgiIiLySExiiIiIyCMxiSEiIiKPxCSGiIiIPBKTGCIiIvJITGKIiIjIIzGJISIiIo/EJIaIiIg8EpMYIiIi8khMYoiIiMgjMYkhIiIij+SRp1gLggAA0Gq1IkdCREREPWX9vW39Pd5XHpnEnD9/HgCQmJgociRERERkr8bGRqjV6j5fxyOTmPDwcABAWVmZQ74EbzNu3Djk5eWJHYZb4nfTPX43XdNqtUhMTER5eTlUKpXY4bgV/p3pHr+brgmCgDFjxiA+Pt4h1/PIJEYqtZTyqNVqNipdkMlk/F66we+me/xufp1KpeL38wv8O9M9fjfdUygUtt/jfcXCXi+0bNkysUNwW/xuusfvhuzFvzPd43fTPUd+NxLBUdU1LqTVaqFWq6HRaJjpEpFTsb0hcl8eORKjVCrx9NNPQ6lUih0KEXk5tjdE7ssjR2KIiIiIPHIkhoiIiIhJDBEREXkkJjFERETkkZjEeKjy8nLceeediI+Ph0KhQP/+/fHQQw/ZdjM2GAx4/PHHkZGRgaCgIMTHx2PRokWorKwUOXLnu9x3AwDPPPMMhgwZgqCgIISFhWHq1KnIzc0VMWrX6Ml309HSpUshkUjw0ksvuTZQchtsa7rHtqZ7rmprmMR4oOLiYowdOxYnT57Ep59+ilOnTuHNN9/EDz/8gKysLNTX16OlpQX79+/HX/7yF+zfvx9ffvkljh8/jptvvlns8J2qJ98NAAwePBivvfYaCgsLsWvXLiQnJ2P69Ok4d+6cyJ/AeXr63VitX78eOTk5DttZkzwP25rusa3pnkvbGsGNlZWVCXfccYcQFxcn+Pn5CUlJScKDDz4o1NXV2V7z3//+V5g2bZoQHh4uABAOHDggXsAucv311wsJCQlCS0tLp59XVVUJgYGBwtKlS7t83969ewUAQmlpqSvCFEVvvxuNRiMAELZt2+aKMEVhz3dTUVEh9OvXTzh8+LDQv39/4cUXX3RxtK7FtqZrbGu6x7ame65sa9x2JKanmVxzczMmTZqE//u//xM5Yteor6/Hli1bcP/99yMgIKDTc7GxsViwYAE+++yzLk8I1Wg0kEgkCA0NdVG0rtXb70av1+Ptt9+GWq3GiBEjXBmyy9jz3ZjNZixcuBCPPfYYhg0bJlLErsO2pmtsa7rHtqZ7rm5r3PbspGXLlkGhUOD777+3fRFJSUkYNWoUBg4ciD//+c9YvXo1Fi5cCAAoKSkRMVrXOXnyJARBwNChQ7t8fujQobhw4QLOnTuH6Oho28/b2trw+OOP4/e//73X7jpq73ezadMm3HrrrWhpaUFcXBy2bt2KyMhIF0ftGvZ8N2vWrIFcLseDDz7o4ijFwbama2xruse2pnuubmvcciSmLz0AX3G5z65QKGz/bTAYcMstt0AQBKxevdrZoYmup9/Nddddh4KCAuzZswfXX389brnlFtTW1roiRNFc7rspLy/Hyy+/jLVr10IikbgoKvGwrbk8tjXdY1vTPVe1NW6ZxNiTyfma1NRUSCQSHD16tMvnjx49iqioKNswrrVRKS0txdatW722ZwTY/90EBQUhNTUVEydOtPUI1qxZ48KIXaen383PP/+M2tpaJCUlQS6XQy6Xo7S0FP/zP/+D5ORk1wbtAmxruse2pntsa7rn6rbGLZMYK3t6AL4iIiIC06ZNwxtvvIHW1tZOz1VXV+Pjjz/G7bffDuBio3Ly5Els27YNERERIkTsOvZ8N10xm83Q6XROjlIcPf1uFi5ciEOHDqGgoMD2iI+Px2OPPYYtW7aIFL3zsa25FNua7rGt6Z7L2xq7yoBdpK6uTpBIJMLKlSu7fP7uu+8WoqKiOv3szJkzPrNi4MSJE0JkZKRw1VVXCTt27BDKysqEzZs3C8OHDxdGjhwpNDY2Cnq9Xrj55puFhIQEoaCgQKiqqrI9dDqd2B/BaXry3TQ1NQkrVqwQsrOzhZKSEmHfvn3CHXfcISiVSuHw4cNifwSn6cl30xVvXp3EtubXsa3pHtua7rmyrXHLJEYQBGH69OlCv379ul2i9dhjj3X6uS81LIJg+byLFy8WYmJiBIlEIgAQ5s2bJzQ3N9ueB9Dl46effhI3eCe73HfT2toqzJ07V4iPjxcUCoUQFxcn3HzzzcLevXtFjtz5LvfddMWbkxhBYFtzOWxruse2pnuuamvcNonpaSZ3/vx54cCBA8I333wjABDWrVsnHDhwQKiqqhL5E7jWU089JQQHBwvZ2dlih+J2+N10j98N2xp78e9M9/jddM9Z343bJjGC0LNM7v333++yB/D000+LF7hI3nvvPeHFF18UTCaT2KG4HX433eN3w7bGXvw70z1+N91zxncjEQTPWTv49NNP41//+he2bt2KiRMnih0OEXkptjVEnsGjkhgAeP/996HRaPDggw9CKnXrxVVE5MHY1hC5P49LYoiIiIgAN98nhoiIiKg7TGKIiIjIIzGJISIiIo8kShKzatUqjBs3DiEhIYiOjsacOXNw/PjxTq9pa2vDsmXLEBERgeDgYMyfPx81NTWdXvPggw9izJgxUCqVGDlyZJf3EgQB//jHPzB48GAolUr069cPK1eudNZHIyI346r25plnnoFEIrnkERQU5MyPR+TTREliduzYgWXLliEnJwdbt26FwWDA9OnT0dzcbHvNI488go0bN+Lzzz/Hjh07UFlZiXnz5l1yrTvvvBO/+93vur3XQw89hHfffRf/+Mc/cOzYMXz99dcYP368Uz4XEbkfV7U3f/zjH1FVVdXpkZ6ejt/+9rdO+2xEPs9hO870QW1trQBA2LFjhyAIgtDQ0CD4+fkJn3/+ue01R48eFQB0udvf008/LYwYMeKSnx85ckSQy+XCsWPHnBY7EXkWZ7U3v1RQUCAAEHbu3Omw2ImoM7eoidFoNACA8PBwAEB+fj4MBgOmTp1qe82QIUOQlJSE7OzsHl9348aNGDBgADZt2oSUlBQkJyfjrrvuQn19vWM/ABF5DGe1N7/07rvvYvDgwbjqqqv6FjARdUv0JMZsNuPhhx/GlVdeieHDhwOwHNetUCgQGhra6bUxMTGorq7u8bWLi4tRWlqKzz//HB9++CHWrl2L/Px8/OY3v3HkRyAiD+HM9qajtrY2fPzxx1iyZElfQyaiXyEXO4Bly5bh8OHD2LVrl8OvbTabodPp8OGHH2Lw4MEAgDVr1mDMmDE4fvw40tLSHH5PInJfzmxvOlq/fj0aGxuxePFip96HyNeJOhLzwAMPYNOmTfjpp5+QkJBg+3lsbCz0ej0aGho6vb6mpgaxsbE9vn5cXBzkcrktgQGAoUOHAgDKysr6FjwReRRntzcdvfvuu7jpppsQExPTl5CJ6DJESWIEQcADDzyA9evX48cff0RKSkqn58eMGQM/Pz/88MMPtp8dP34cZWVlyMrK6vF9rrzyShiNRpw+fdr2sxMnTgAA+vfv38dPQUSewFXtjdWZM2fw008/cSqJyAVEmU5atmwZPvnkE2zYsAEhISG2eWe1Wo2AgACo1WosWbIEjz76KMLDw6FSqbB8+XJkZWV1OlH21KlTaGpqQnV1NVpbW1FQUAAASE9Ph0KhwNSpUzF69GjceeedeOmll2A2m7Fs2TJMmzat0+gMEXkvV7U3Vu+99x7i4uJwww03uPRzEvkkMZZEAejy8f7779te09raKtx///1CWFiYEBgYKMydO1eoqqrqdJ1rrrmmy+ucOXPG9pqzZ88K8+bNE4KDg4WYmBjh9ttvF86fP++iT0pEYnNle2MymYSEhAThiSeecNGnI/JtPMWaiIiIPJLoS6yJiIiIeoNJDBEREXkkJjFERETkkZjEEBERkUdiEkNEREQeiUkMEREReSQmMUREROSRmMQQERGRR2ISQ0RERB6JSQwRERF5JCYxRERE5JH+PxaTQOpwl8u7AAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "quarterly_revenue.plot(kind=\"line\")\n",
    "plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can convert periods to timestamps by calling `to_timestamp`. By default this will give us the first day of each period, but by setting `how` and `freq`, we can get the last hour of each period:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2016-03-31 23:59:59.999999999    300\n",
       "2016-06-30 23:59:59.999999999    320\n",
       "2016-09-30 23:59:59.999999999    290\n",
       "2016-12-31 23:59:59.999999999    390\n",
       "2017-03-31 23:59:59.999999999    320\n",
       "2017-06-30 23:59:59.999999999    360\n",
       "2017-09-30 23:59:59.999999999    310\n",
       "2017-12-31 23:59:59.999999999    410\n",
       "dtype: int64"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "last_hours = quarterly_revenue.to_timestamp(how=\"end\", freq=\"H\")\n",
    "last_hours"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And back to periods by calling `to_period`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2016Q1    300\n",
       "2016Q2    320\n",
       "2016Q3    290\n",
       "2016Q4    390\n",
       "2017Q1    320\n",
       "2017Q2    360\n",
       "2017Q3    310\n",
       "2017Q4    410\n",
       "Freq: Q-DEC, dtype: int64"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "last_hours.to_period()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pandas also provides many other time-related functions that we recommend you check out in the [documentation](http://pandas.pydata.org/pandas-docs/stable/timeseries.html). To whet your appetite, here is one way to get the last business day of each month in 2016, at 9am:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "PeriodIndex(['2016-01-29 09:00', '2016-02-29 09:00', '2016-03-31 09:00',\n",
       "             '2016-04-29 09:00', '2016-05-31 09:00', '2016-06-30 09:00',\n",
       "             '2016-07-29 09:00', '2016-08-31 09:00', '2016-09-30 09:00',\n",
       "             '2016-10-31 09:00', '2016-11-30 09:00', '2016-12-30 09:00'],\n",
       "            dtype='period[H]')"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "months_2016 = pd.period_range(\"2016\", periods=12, freq=\"M\")\n",
    "one_day_after_last_days = months_2016.asfreq(\"D\") + 1\n",
    "last_bdays = one_day_after_last_days.to_timestamp() - pd.tseries.offsets.BDay()\n",
    "last_bdays.to_period(\"H\") + 9"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# `DataFrame` objects\n",
    "A DataFrame object represents a spreadsheet, with cell values, column names and row index labels. You can define expressions to compute columns based on other columns, create pivot-tables, group rows, draw graphs, etc. You can see `DataFrame`s as dictionaries of `Series`.\n",
    "\n",
    "## Creating a `DataFrame`\n",
    "You can create a DataFrame by passing a dictionary of `Series` objects:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>weight</th>\n",
       "      <th>birthyear</th>\n",
       "      <th>children</th>\n",
       "      <th>hobby</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Aman</th>\n",
       "      <td>68</td>\n",
       "      <td>1985</td>\n",
       "      <td>NaN</td>\n",
       "      <td>Biking</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Lav</th>\n",
       "      <td>83</td>\n",
       "      <td>1984</td>\n",
       "      <td>3.0</td>\n",
       "      <td>Dancing</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Praddyumn</th>\n",
       "      <td>112</td>\n",
       "      <td>1992</td>\n",
       "      <td>0.0</td>\n",
       "      <td>Coding</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           weight  birthyear  children    hobby\n",
       "Aman           68       1985       NaN   Biking\n",
       "Lav            83       1984       3.0  Dancing\n",
       "Praddyumn     112       1992       0.0   Coding"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "people_dict = {\n",
    "    \"weight\": pd.Series([68, 83, 112], index=[\"Aman\", \"Lav\", \"Praddyumn\"]),\n",
    "    \"birthyear\": pd.Series([1984, 1985, 1992], index=[\"Lav\", \"Aman\", \"Praddyumn\"], name=\"year\"),\n",
    "    \"children\": pd.Series([0, 3], index=[\"Praddyumn\", \"Lav\"]),\n",
    "    \"hobby\": pd.Series([\"Biking\", \"Dancing\", \"Coding\"], index=[\"Aman\", \"Lav\", \"Praddyumn\"]),\n",
    "}\n",
    "people = pd.DataFrame(people_dict)\n",
    "people"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A few things to note:\n",
    "* the `Series` were automatically aligned based on their index,\n",
    "* missing values are represented as `NaN`,\n",
    "* `Series` names are ignored (the name `\"year\"` was dropped),\n",
    "* `DataFrame`s are displayed nicely in Jupyter notebooks and Visual Studio Code, woohoo!"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can access columns pretty much as you would expect. They are returned as `Series` objects:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Aman         1985\n",
       "Lav          1984\n",
       "Praddyumn    1992\n",
       "Name: birthyear, dtype: int64"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "people[\"birthyear\"]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also get Multiple Columns at Once:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>birthyear</th>\n",
       "      <th>hobby</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Aman</th>\n",
       "      <td>1985</td>\n",
       "      <td>Biking</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Lav</th>\n",
       "      <td>1984</td>\n",
       "      <td>Dancing</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Praddyumn</th>\n",
       "      <td>1992</td>\n",
       "      <td>Coding</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           birthyear    hobby\n",
       "Aman            1985   Biking\n",
       "Lav             1984  Dancing\n",
       "Praddyumn       1992   Coding"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "people[[\"birthyear\", \"hobby\"]]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you pass a list of columns and/or index row labels to the `DataFrame` constructor, it will guarantee that these columns and/or rows will exist, in that order, and no other column/row will exist. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>birthyear</th>\n",
       "      <th>weight</th>\n",
       "      <th>height</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Praddyumn</th>\n",
       "      <td>1992.0</td>\n",
       "      <td>112.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Aman</th>\n",
       "      <td>1985.0</td>\n",
       "      <td>68.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Aditya</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           birthyear  weight height\n",
       "Praddyumn     1992.0   112.0    NaN\n",
       "Aman          1985.0    68.0    NaN\n",
       "Aditya           NaN     NaN    NaN"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d2 = pd.DataFrame(\n",
    "    people_dict,\n",
    "    columns=[\"birthyear\", \"weight\", \"height\"],\n",
    "    index=[\"Praddyumn\", \"Aman\", \"Aditya\"]\n",
    ")\n",
    "d2"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another convenient way to create a `DataFrame` is to pass all the values to the constructor as an `ndarray`, or a list of lists, and specify the column names and row index labels separately:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>birthyear</th>\n",
       "      <th>children</th>\n",
       "      <th>hobby</th>\n",
       "      <th>weight</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Aman</th>\n",
       "      <td>1985</td>\n",
       "      <td>NaN</td>\n",
       "      <td>Biking</td>\n",
       "      <td>68</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Lav</th>\n",
       "      <td>1984</td>\n",
       "      <td>3.0</td>\n",
       "      <td>Dancing</td>\n",
       "      <td>83</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Praddyumn</th>\n",
       "      <td>1992</td>\n",
       "      <td>0.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>112</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           birthyear  children    hobby  weight\n",
       "Aman            1985       NaN   Biking      68\n",
       "Lav             1984       3.0  Dancing      83\n",
       "Praddyumn       1992       0.0      NaN     112"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "values = [\n",
    "    [1985, np.nan, \"Biking\", 68],\n",
    "    [1984, 3,      \"Dancing\", 83],\n",
    "    [1992, 0,      np.nan, 112]\n",
    "]\n",
    "d3 = pd.DataFrame(\n",
    "    values,\n",
    "    columns=[\"birthyear\", \"children\", \"hobby\", \"weight\"],\n",
    "    index=[\"Aman\", \"Lav\", \"Praddyumn\"]\n",
    ")\n",
    "d3"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To specify missing values, you can either use `np.nan` or NumPy's masked arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>birthyear</th>\n",
       "      <th>children</th>\n",
       "      <th>hobby</th>\n",
       "      <th>weight</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Aman</th>\n",
       "      <td>1985</td>\n",
       "      <td>NaN</td>\n",
       "      <td>Biking</td>\n",
       "      <td>68</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Lav</th>\n",
       "      <td>1984</td>\n",
       "      <td>3</td>\n",
       "      <td>Dancing</td>\n",
       "      <td>83</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Praddyumn</th>\n",
       "      <td>1992</td>\n",
       "      <td>0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>112</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          birthyear children    hobby weight\n",
       "Aman           1985      NaN   Biking     68\n",
       "Lav            1984        3  Dancing     83\n",
       "Praddyumn      1992        0      NaN    112"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "masked_array = np.ma.asarray(values, dtype=object)\n",
    "masked_array[(0, 2), (1, 2)] = np.ma.masked\n",
    "d3 = pd.DataFrame(\n",
    "        masked_array,\n",
    "        columns=[\"birthyear\", \"children\", \"hobby\", \"weight\"],\n",
    "        index=[\"Aman\", \"Lav\", \"Praddyumn\"]\n",
    ")\n",
    "d3"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Instead of `ndarray` You can also pass a `DataFrame` Object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>hobby</th>\n",
       "      <th>children</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Aman</th>\n",
       "      <td>Biking</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Praddyumn</th>\n",
       "      <td>NaN</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            hobby children\n",
       "Aman       Biking      NaN\n",
       "Praddyumn     NaN        0"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d4 = pd.DataFrame(d3, columns=[\"hobby\", \"children\"], index=[\"Aman\", \"Praddyumn\"])\n",
    "d4"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is also possible to create a `DataFrame` with a dictionary (or list) of dictionaries (or list):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>birthyear</th>\n",
       "      <th>hobby</th>\n",
       "      <th>weight</th>\n",
       "      <th>children</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Aman</th>\n",
       "      <td>1985</td>\n",
       "      <td>Biking</td>\n",
       "      <td>68</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Lav</th>\n",
       "      <td>1984</td>\n",
       "      <td>Dancing</td>\n",
       "      <td>83</td>\n",
       "      <td>3.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Praddyumn</th>\n",
       "      <td>1992</td>\n",
       "      <td>NaN</td>\n",
       "      <td>112</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           birthyear    hobby  weight  children\n",
       "Aman            1985   Biking      68       NaN\n",
       "Lav             1984  Dancing      83       3.0\n",
       "Praddyumn       1992      NaN     112       0.0"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "people = pd.DataFrame({\n",
    "    \"birthyear\": {\"Aman\":1985, \"Lav\": 1984, \"Praddyumn\": 1992},\n",
    "    \"hobby\": {\"Aman\":\"Biking\", \"Lav\": \"Dancing\"},\n",
    "    \"weight\": {\"Aman\":68, \"Lav\": 83, \"Praddyumn\": 112},\n",
    "    \"children\": {\"Lav\": 3, \"Praddyumn\": 0}\n",
    "})\n",
    "people"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Multi-indexing\n",
    "If all columns are tuples of the same size, then they are understood as a multi-index. The same goes for row index labels. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead tr th {\n",
       "        text-align: left;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th colspan=\"2\" halign=\"left\">public</th>\n",
       "      <th colspan=\"2\" halign=\"left\">private</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th>birthyear</th>\n",
       "      <th>hobby</th>\n",
       "      <th>weight</th>\n",
       "      <th>children</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th rowspan=\"2\" valign=\"top\">Paris</th>\n",
       "      <th>Aman</th>\n",
       "      <td>1985</td>\n",
       "      <td>Biking</td>\n",
       "      <td>68</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Lav</th>\n",
       "      <td>1984</td>\n",
       "      <td>Dancing</td>\n",
       "      <td>83</td>\n",
       "      <td>3.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>London</th>\n",
       "      <th>Praddyumn</th>\n",
       "      <td>1992</td>\n",
       "      <td>NaN</td>\n",
       "      <td>112</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                    public          private         \n",
       "                 birthyear    hobby  weight children\n",
       "Paris  Aman           1985   Biking      68      NaN\n",
       "       Lav            1984  Dancing      83      3.0\n",
       "London Praddyumn      1992      NaN     112      0.0"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d5 = pd.DataFrame(\n",
    "    {\n",
    "        (\"public\", \"birthyear\"): {\n",
    "            (\"Paris\", \"Aman\"): 1985,\n",
    "            (\"Paris\", \"Lav\"): 1984,\n",
    "            (\"London\", \"Praddyumn\"): 1992,\n",
    "        },\n",
    "        (\"public\", \"hobby\"): {\n",
    "            (\"Paris\", \"Aman\"): \"Biking\",\n",
    "            (\"Paris\", \"Lav\"): \"Dancing\",\n",
    "        },\n",
    "        (\"private\", \"weight\"): {\n",
    "            (\"Paris\", \"Aman\"): 68,\n",
    "            (\"Paris\", \"Lav\"): 83,\n",
    "            (\"London\", \"Praddyumn\"): 112,\n",
    "        },\n",
    "        (\"private\", \"children\"): {\n",
    "            (\"Paris\", \"Aman\"): np.nan,\n",
    "            (\"Paris\", \"Lav\"): 3,\n",
    "            (\"London\", \"Praddyumn\"): 0,\n",
    "        },\n",
    "    }\n",
    ")\n",
    "d5"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can now get a `DataFrame` containing all the `\"public\"` columns very simply:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th>birthyear</th>\n",
       "      <th>hobby</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th rowspan=\"2\" valign=\"top\">Paris</th>\n",
       "      <th>Aman</th>\n",
       "      <td>1985</td>\n",
       "      <td>Biking</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Lav</th>\n",
       "      <td>1984</td>\n",
       "      <td>Dancing</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>London</th>\n",
       "      <th>Praddyumn</th>\n",
       "      <td>1992</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                  birthyear    hobby\n",
       "Paris  Aman            1985   Biking\n",
       "       Lav             1984  Dancing\n",
       "London Praddyumn       1992      NaN"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d5[\"public\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th>weight</th>\n",
       "      <th>children</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th rowspan=\"2\" valign=\"top\">Paris</th>\n",
       "      <th>Aman</th>\n",
       "      <td>68</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Lav</th>\n",
       "      <td>83</td>\n",
       "      <td>3.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>London</th>\n",
       "      <th>Praddyumn</th>\n",
       "      <td>112</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                  weight  children\n",
       "Paris  Aman           68       NaN\n",
       "       Lav            83       3.0\n",
       "London Praddyumn     112       0.0"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d5[\"private\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Paris   Aman          Biking\n",
       "        Lav          Dancing\n",
       "London  Praddyumn        NaN\n",
       "Name: (public, hobby), dtype: object"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d5[\"public\", \"hobby\"]  # Same result as d5[\"public\"][\"hobby\"]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dropping a level\n",
    "Let's look at `d5` again:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead tr th {\n",
       "        text-align: left;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th colspan=\"2\" halign=\"left\">public</th>\n",
       "      <th colspan=\"2\" halign=\"left\">private</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th>birthyear</th>\n",
       "      <th>hobby</th>\n",
       "      <th>weight</th>\n",
       "      <th>children</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th rowspan=\"2\" valign=\"top\">Paris</th>\n",
       "      <th>Aman</th>\n",
       "      <td>1985</td>\n",
       "      <td>Biking</td>\n",
       "      <td>68</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Lav</th>\n",
       "      <td>1984</td>\n",
       "      <td>Dancing</td>\n",
       "      <td>83</td>\n",
       "      <td>3.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>London</th>\n",
       "      <th>Praddyumn</th>\n",
       "      <td>1992</td>\n",
       "      <td>NaN</td>\n",
       "      <td>112</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                    public          private         \n",
       "                 birthyear    hobby  weight children\n",
       "Paris  Aman           1985   Biking      68      NaN\n",
       "       Lav            1984  Dancing      83      3.0\n",
       "London Praddyumn      1992      NaN     112      0.0"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d5"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are two levels of columns, and two levels of indices. We can drop a column level by calling `droplevel()` (the same goes for indices):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th>birthyear</th>\n",
       "      <th>hobby</th>\n",
       "      <th>weight</th>\n",
       "      <th>children</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th rowspan=\"2\" valign=\"top\">Paris</th>\n",
       "      <th>Aman</th>\n",
       "      <td>1985</td>\n",
       "      <td>Biking</td>\n",
       "      <td>68</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Lav</th>\n",
       "      <td>1984</td>\n",
       "      <td>Dancing</td>\n",
       "      <td>83</td>\n",
       "      <td>3.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>London</th>\n",
       "      <th>Praddyumn</th>\n",
       "      <td>1992</td>\n",
       "      <td>NaN</td>\n",
       "      <td>112</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                  birthyear    hobby  weight  children\n",
       "Paris  Aman            1985   Biking      68       NaN\n",
       "       Lav             1984  Dancing      83       3.0\n",
       "London Praddyumn       1992      NaN     112       0.0"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d5.columns = d5.columns.droplevel(level = 0)\n",
    "d5"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Transposing\n",
    "You can Swap(Transpose) columns and Indices Using `T` Attribute:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead tr th {\n",
       "        text-align: left;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr>\n",
       "      <th></th>\n",
       "      <th colspan=\"2\" halign=\"left\">Paris</th>\n",
       "      <th>London</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th></th>\n",
       "      <th>Aman</th>\n",
       "      <th>Lav</th>\n",
       "      <th>Praddyumn</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>birthyear</th>\n",
       "      <td>1985</td>\n",
       "      <td>1984</td>\n",
       "      <td>1992</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>hobby</th>\n",
       "      <td>Biking</td>\n",
       "      <td>Dancing</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>weight</th>\n",
       "      <td>68</td>\n",
       "      <td>83</td>\n",
       "      <td>112</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>children</th>\n",
       "      <td>NaN</td>\n",
       "      <td>3.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            Paris             London\n",
       "             Aman      Lav Praddyumn\n",
       "birthyear    1985     1984      1992\n",
       "hobby      Biking  Dancing       NaN\n",
       "weight         68       83       112\n",
       "children      NaN      3.0       0.0"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d6 = d5.T\n",
    "d6"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Stacking and unstacking levels\n",
    "Calling the `stack()` method will push the lowest column level after the lowest index:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th>London</th>\n",
       "      <th>Paris</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th rowspan=\"3\" valign=\"top\">birthyear</th>\n",
       "      <th>Aman</th>\n",
       "      <td>NaN</td>\n",
       "      <td>1985</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Lav</th>\n",
       "      <td>NaN</td>\n",
       "      <td>1984</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Praddyumn</th>\n",
       "      <td>1992</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th rowspan=\"2\" valign=\"top\">hobby</th>\n",
       "      <th>Aman</th>\n",
       "      <td>NaN</td>\n",
       "      <td>Biking</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Lav</th>\n",
       "      <td>NaN</td>\n",
       "      <td>Dancing</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th rowspan=\"3\" valign=\"top\">weight</th>\n",
       "      <th>Aman</th>\n",
       "      <td>NaN</td>\n",
       "      <td>68</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Lav</th>\n",
       "      <td>NaN</td>\n",
       "      <td>83</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Praddyumn</th>\n",
       "      <td>112</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th rowspan=\"2\" valign=\"top\">children</th>\n",
       "      <th>Lav</th>\n",
       "      <td>NaN</td>\n",
       "      <td>3.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Praddyumn</th>\n",
       "      <td>0.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                    London    Paris\n",
       "birthyear Aman         NaN     1985\n",
       "          Lav          NaN     1984\n",
       "          Praddyumn   1992      NaN\n",
       "hobby     Aman         NaN   Biking\n",
       "          Lav          NaN  Dancing\n",
       "weight    Aman         NaN       68\n",
       "          Lav          NaN       83\n",
       "          Praddyumn    112      NaN\n",
       "children  Lav          NaN      3.0\n",
       "          Praddyumn    0.0      NaN"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d7 = d6.stack()\n",
    "d7"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that many `NaN` values appeared. This makes sense because many new combinations did not exist before (eg. there was no `Lav` in `London`).\n",
    "\n",
    "Calling `unstack()` will do the reverse, once again creating many `NaN` values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead tr th {\n",
       "        text-align: left;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr>\n",
       "      <th></th>\n",
       "      <th colspan=\"3\" halign=\"left\">London</th>\n",
       "      <th colspan=\"3\" halign=\"left\">Paris</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th></th>\n",
       "      <th>Aman</th>\n",
       "      <th>Lav</th>\n",
       "      <th>Praddyumn</th>\n",
       "      <th>Aman</th>\n",
       "      <th>Lav</th>\n",
       "      <th>Praddyumn</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>birthyear</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>1992</td>\n",
       "      <td>1985</td>\n",
       "      <td>1984</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>children</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>3.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>hobby</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>Biking</td>\n",
       "      <td>Dancing</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>weight</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>112</td>\n",
       "      <td>68</td>\n",
       "      <td>83</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          London                  Paris                   \n",
       "            Aman  Lav Praddyumn    Aman      Lav Praddyumn\n",
       "birthyear    NaN  NaN      1992    1985     1984       NaN\n",
       "children     NaN  NaN       0.0     NaN      3.0       NaN\n",
       "hobby        NaN  NaN       NaN  Biking  Dancing       NaN\n",
       "weight       NaN  NaN       112      68       83       NaN"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d8 = d7.unstack()\n",
    "d8"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If We call `unstack` again we will end up with a `Series` object:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "London  Aman       birthyear        NaN\n",
       "                   children         NaN\n",
       "                   hobby            NaN\n",
       "                   weight           NaN\n",
       "        Lav        birthyear        NaN\n",
       "                   children         NaN\n",
       "                   hobby            NaN\n",
       "                   weight           NaN\n",
       "        Praddyumn  birthyear       1992\n",
       "                   children         0.0\n",
       "                   hobby            NaN\n",
       "                   weight           112\n",
       "Paris   Aman       birthyear       1985\n",
       "                   children         NaN\n",
       "                   hobby         Biking\n",
       "                   weight            68\n",
       "        Lav        birthyear       1984\n",
       "                   children         3.0\n",
       "                   hobby        Dancing\n",
       "                   weight            83\n",
       "        Praddyumn  birthyear        NaN\n",
       "                   children         NaN\n",
       "                   hobby            NaN\n",
       "                   weight           NaN\n",
       "dtype: object"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d9 = d8.unstack()\n",
    "d9"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `stack()` and `unstack()` methods let you select the `level` to stack/unstack. You can even stack/unstack multiple levels at once:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead tr th {\n",
       "        text-align: left;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr>\n",
       "      <th></th>\n",
       "      <th colspan=\"3\" halign=\"left\">London</th>\n",
       "      <th colspan=\"3\" halign=\"left\">Paris</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th></th>\n",
       "      <th>Aman</th>\n",
       "      <th>Lav</th>\n",
       "      <th>Praddyumn</th>\n",
       "      <th>Aman</th>\n",
       "      <th>Lav</th>\n",
       "      <th>Praddyumn</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>birthyear</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>1992</td>\n",
       "      <td>1985</td>\n",
       "      <td>1984</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>children</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>3.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>hobby</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>Biking</td>\n",
       "      <td>Dancing</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>weight</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>112</td>\n",
       "      <td>68</td>\n",
       "      <td>83</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          London                  Paris                   \n",
       "            Aman  Lav Praddyumn    Aman      Lav Praddyumn\n",
       "birthyear    NaN  NaN      1992    1985     1984       NaN\n",
       "children     NaN  NaN       0.0     NaN      3.0       NaN\n",
       "hobby        NaN  NaN       NaN  Biking  Dancing       NaN\n",
       "weight       NaN  NaN       112      68       83       NaN"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d10 = d9.unstack(level = (0,1))\n",
    "d10"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Most methods return modified copies\n",
    "As you may have noticed, the `stack()` and `unstack()` methods do not modify the object they apply to. Instead, they work on a copy and return that copy. This is true of most methods in pandas."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Accessing rows\n",
    "Let's go back to the `people` `DataFrame`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>birthyear</th>\n",
       "      <th>hobby</th>\n",
       "      <th>weight</th>\n",
       "      <th>children</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Aman</th>\n",
       "      <td>1985</td>\n",
       "      <td>Biking</td>\n",
       "      <td>68</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Lav</th>\n",
       "      <td>1984</td>\n",
       "      <td>Dancing</td>\n",
       "      <td>83</td>\n",
       "      <td>3.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Praddyumn</th>\n",
       "      <td>1992</td>\n",
       "      <td>NaN</td>\n",
       "      <td>112</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           birthyear    hobby  weight  children\n",
       "Aman            1985   Biking      68       NaN\n",
       "Lav             1984  Dancing      83       3.0\n",
       "Praddyumn       1992      NaN     112       0.0"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "people"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `loc` attribute lets you access rows instead of columns. The result is a `Series` object in which the `DataFrame`'s column names are mapped to row index labels:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "birthyear    1992\n",
       "hobby         NaN\n",
       "weight        112\n",
       "children      0.0\n",
       "Name: Praddyumn, dtype: object"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "people.loc[\"Praddyumn\"]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can Also use the `iloc` attribute to access the rows using an `inteager`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "birthyear    1992\n",
       "hobby         NaN\n",
       "weight        112\n",
       "children      0.0\n",
       "Name: Praddyumn, dtype: object"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "people.iloc[2]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also get a slice of rows, and this returns a `DataFrame` object:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>birthyear</th>\n",
       "      <th>hobby</th>\n",
       "      <th>weight</th>\n",
       "      <th>children</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Lav</th>\n",
       "      <td>1984</td>\n",
       "      <td>Dancing</td>\n",
       "      <td>83</td>\n",
       "      <td>3.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Praddyumn</th>\n",
       "      <td>1992</td>\n",
       "      <td>NaN</td>\n",
       "      <td>112</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           birthyear    hobby  weight  children\n",
       "Lav             1984  Dancing      83       3.0\n",
       "Praddyumn       1992      NaN     112       0.0"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "people.iloc[1:3]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, you can pass a boolean array to get the matching rows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>birthyear</th>\n",
       "      <th>hobby</th>\n",
       "      <th>weight</th>\n",
       "      <th>children</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Aman</th>\n",
       "      <td>1985</td>\n",
       "      <td>Biking</td>\n",
       "      <td>68</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Praddyumn</th>\n",
       "      <td>1992</td>\n",
       "      <td>NaN</td>\n",
       "      <td>112</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           birthyear   hobby  weight  children\n",
       "Aman            1985  Biking      68       NaN\n",
       "Praddyumn       1992     NaN     112       0.0"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "people[np.array([True, False, True])]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is most useful when combined with boolean expressions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>birthyear</th>\n",
       "      <th>hobby</th>\n",
       "      <th>weight</th>\n",
       "      <th>children</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Aman</th>\n",
       "      <td>1985</td>\n",
       "      <td>Biking</td>\n",
       "      <td>68</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Lav</th>\n",
       "      <td>1984</td>\n",
       "      <td>Dancing</td>\n",
       "      <td>83</td>\n",
       "      <td>3.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      birthyear    hobby  weight  children\n",
       "Aman       1985   Biking      68       NaN\n",
       "Lav        1984  Dancing      83       3.0"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "people[people[\"birthyear\"] < 1990]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Adding and removing columns\n",
    "You can generally treat `DataFrame` objects like dictionaries of `Series`, so the following work fine:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>birthyear</th>\n",
       "      <th>hobby</th>\n",
       "      <th>weight</th>\n",
       "      <th>children</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Aman</th>\n",
       "      <td>1985</td>\n",
       "      <td>Biking</td>\n",
       "      <td>68</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Lav</th>\n",
       "      <td>1984</td>\n",
       "      <td>Dancing</td>\n",
       "      <td>83</td>\n",
       "      <td>3.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Praddyumn</th>\n",
       "      <td>1992</td>\n",
       "      <td>NaN</td>\n",
       "      <td>112</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           birthyear    hobby  weight  children\n",
       "Aman            1985   Biking      68       NaN\n",
       "Lav             1984  Dancing      83       3.0\n",
       "Praddyumn       1992      NaN     112       0.0"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "people"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>hobby</th>\n",
       "      <th>weight</th>\n",
       "      <th>age</th>\n",
       "      <th>over 30</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Aman</th>\n",
       "      <td>Biking</td>\n",
       "      <td>68</td>\n",
       "      <td>37</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Lav</th>\n",
       "      <td>Dancing</td>\n",
       "      <td>83</td>\n",
       "      <td>38</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Praddyumn</th>\n",
       "      <td>NaN</td>\n",
       "      <td>112</td>\n",
       "      <td>30</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             hobby  weight  age  over 30\n",
       "Aman        Biking      68   37     True\n",
       "Lav        Dancing      83   38     True\n",
       "Praddyumn      NaN     112   30    False"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "people[\"age\"] = 2022 - people[\"birthyear\"]\n",
    "people[\"over 30\"] = people[\"age\"] > 30\n",
    "birthyears = people.pop(\"birthyear\")\n",
    "del people[\"children\"]\n",
    "\n",
    "people"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Aman         1985\n",
       "Lav          1984\n",
       "Praddyumn    1992\n",
       "Name: birthyear, dtype: int64"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "birthyears"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When You are Creating a New Column then, it must have same number of rows Missing Rows are Filled with `NaN` and extra Rows are Ignored."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>hobby</th>\n",
       "      <th>weight</th>\n",
       "      <th>age</th>\n",
       "      <th>over 30</th>\n",
       "      <th>pets</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Aman</th>\n",
       "      <td>Biking</td>\n",
       "      <td>68</td>\n",
       "      <td>37</td>\n",
       "      <td>True</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Lav</th>\n",
       "      <td>Dancing</td>\n",
       "      <td>83</td>\n",
       "      <td>38</td>\n",
       "      <td>True</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Praddyumn</th>\n",
       "      <td>NaN</td>\n",
       "      <td>112</td>\n",
       "      <td>30</td>\n",
       "      <td>False</td>\n",
       "      <td>5.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             hobby  weight  age  over 30  pets\n",
       "Aman        Biking      68   37     True   NaN\n",
       "Lav        Dancing      83   38     True   0.0\n",
       "Praddyumn      NaN     112   30    False   5.0"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "people[\"pets\"] = pd.Series({\"Lav\": 0, \"Praddyumn\": 5, \"Aditya\": 1}) # Aman is Missing and Aditya is Ignored\n",
    "people"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When adding a new column, it is added at the end (on the right) by default. You can also insert a column anywhere else using the `insert()` method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>hobby</th>\n",
       "      <th>height</th>\n",
       "      <th>weight</th>\n",
       "      <th>age</th>\n",
       "      <th>over 30</th>\n",
       "      <th>pets</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Aman</th>\n",
       "      <td>Biking</td>\n",
       "      <td>172</td>\n",
       "      <td>68</td>\n",
       "      <td>37</td>\n",
       "      <td>True</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Lav</th>\n",
       "      <td>Dancing</td>\n",
       "      <td>181</td>\n",
       "      <td>83</td>\n",
       "      <td>38</td>\n",
       "      <td>True</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Praddyumn</th>\n",
       "      <td>NaN</td>\n",
       "      <td>185</td>\n",
       "      <td>112</td>\n",
       "      <td>30</td>\n",
       "      <td>False</td>\n",
       "      <td>5.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             hobby  height  weight  age  over 30  pets\n",
       "Aman        Biking     172      68   37     True   NaN\n",
       "Lav        Dancing     181      83   38     True   0.0\n",
       "Praddyumn      NaN     185     112   30    False   5.0"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "people.insert(1, \"height\", [172, 181, 185])\n",
    "people"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Assigning new columns\n",
    "You can also create new columns by calling the `assign()` method. Note that this returns a new `DataFrame` object, the original is not modified:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>hobby</th>\n",
       "      <th>height</th>\n",
       "      <th>weight</th>\n",
       "      <th>age</th>\n",
       "      <th>over 30</th>\n",
       "      <th>pets</th>\n",
       "      <th>body_mass_index</th>\n",
       "      <th>has_pets</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Aman</th>\n",
       "      <td>Biking</td>\n",
       "      <td>172</td>\n",
       "      <td>68</td>\n",
       "      <td>37</td>\n",
       "      <td>True</td>\n",
       "      <td>NaN</td>\n",
       "      <td>22.985398</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Lav</th>\n",
       "      <td>Dancing</td>\n",
       "      <td>181</td>\n",
       "      <td>83</td>\n",
       "      <td>38</td>\n",
       "      <td>True</td>\n",
       "      <td>0.0</td>\n",
       "      <td>25.335002</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Praddyumn</th>\n",
       "      <td>NaN</td>\n",
       "      <td>185</td>\n",
       "      <td>112</td>\n",
       "      <td>30</td>\n",
       "      <td>False</td>\n",
       "      <td>5.0</td>\n",
       "      <td>32.724617</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             hobby  height  weight  age  over 30  pets  body_mass_index  \\\n",
       "Aman        Biking     172      68   37     True   NaN        22.985398   \n",
       "Lav        Dancing     181      83   38     True   0.0        25.335002   \n",
       "Praddyumn      NaN     185     112   30    False   5.0        32.724617   \n",
       "\n",
       "           has_pets  \n",
       "Aman          False  \n",
       "Lav           False  \n",
       "Praddyumn      True  "
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "people.assign(\n",
    "    body_mass_index = people[\"weight\"] / (people[\"height\"] / 100) ** 2,\n",
    "    has_pets = people[\"pets\"] > 0\n",
    ")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that you cannot access columns created within the same assignment:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Key Error: 'body_mass_index'\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    people.assign(\n",
    "        body_mass_index=people[\"weight\"] / (people[\"height\"] / 100) ** 2,\n",
    "        overweight=people[\"body_mass_index\"] > 25,\n",
    "    )\n",
    "except KeyError as e:\n",
    "    print(f\"Key Error: {e}\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The solution is to split this assignment in two consecutive assignments:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>hobby</th>\n",
       "      <th>height</th>\n",
       "      <th>weight</th>\n",
       "      <th>age</th>\n",
       "      <th>over 30</th>\n",
       "      <th>pets</th>\n",
       "      <th>body_mass_index</th>\n",
       "      <th>overweight</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Aman</th>\n",
       "      <td>Biking</td>\n",
       "      <td>172</td>\n",
       "      <td>68</td>\n",
       "      <td>37</td>\n",
       "      <td>True</td>\n",
       "      <td>NaN</td>\n",
       "      <td>22.985398</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Lav</th>\n",
       "      <td>Dancing</td>\n",
       "      <td>181</td>\n",
       "      <td>83</td>\n",
       "      <td>38</td>\n",
       "      <td>True</td>\n",
       "      <td>0.0</td>\n",
       "      <td>25.335002</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Praddyumn</th>\n",
       "      <td>NaN</td>\n",
       "      <td>185</td>\n",
       "      <td>112</td>\n",
       "      <td>30</td>\n",
       "      <td>False</td>\n",
       "      <td>5.0</td>\n",
       "      <td>32.724617</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             hobby  height  weight  age  over 30  pets  body_mass_index  \\\n",
       "Aman        Biking     172      68   37     True   NaN        22.985398   \n",
       "Lav        Dancing     181      83   38     True   0.0        25.335002   \n",
       "Praddyumn      NaN     185     112   30    False   5.0        32.724617   \n",
       "\n",
       "           overweight  \n",
       "Aman            False  \n",
       "Lav              True  \n",
       "Praddyumn        True  "
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d6 = people.assign(body_mass_index = people[\"weight\"] / (people[\"height\"] / 100) ** 2)\n",
    "d6.assign(overweight = d6[\"body_mass_index\"] > 25)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Having to create a temporary variable `d6` is not very convenient. You may want to just chain the assigment calls, but it does not work because the `people` object is not actually modified by the first assignment:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Key error: 'body_mass_index'\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    (\n",
    "        people.assign(\n",
    "            body_mass_index=people[\"weight\"] / (people[\"height\"] / 100) ** 2\n",
    "        ).assign(overweight=people[\"body_mass_index\"] > 25)\n",
    "    )\n",
    "except KeyError as e:\n",
    "    print(\"Key error:\", e)\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But fear not, there is a simple solution. You can pass a function to the `assign()` method (typically a `lambda` function), and this function will be called with the `DataFrame` as a parameter:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>hobby</th>\n",
       "      <th>height</th>\n",
       "      <th>weight</th>\n",
       "      <th>age</th>\n",
       "      <th>over 30</th>\n",
       "      <th>pets</th>\n",
       "      <th>body_mass_index</th>\n",
       "      <th>overweight</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Aman</th>\n",
       "      <td>Biking</td>\n",
       "      <td>172</td>\n",
       "      <td>68</td>\n",
       "      <td>37</td>\n",
       "      <td>True</td>\n",
       "      <td>NaN</td>\n",
       "      <td>22.985398</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Lav</th>\n",
       "      <td>Dancing</td>\n",
       "      <td>181</td>\n",
       "      <td>83</td>\n",
       "      <td>38</td>\n",
       "      <td>True</td>\n",
       "      <td>0.0</td>\n",
       "      <td>25.335002</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Praddyumn</th>\n",
       "      <td>NaN</td>\n",
       "      <td>185</td>\n",
       "      <td>112</td>\n",
       "      <td>30</td>\n",
       "      <td>False</td>\n",
       "      <td>5.0</td>\n",
       "      <td>32.724617</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             hobby  height  weight  age  over 30  pets  body_mass_index  \\\n",
       "Aman        Biking     172      68   37     True   NaN        22.985398   \n",
       "Lav        Dancing     181      83   38     True   0.0        25.335002   \n",
       "Praddyumn      NaN     185     112   30    False   5.0        32.724617   \n",
       "\n",
       "           overweight  \n",
       "Aman            False  \n",
       "Lav              True  \n",
       "Praddyumn        True  "
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(\n",
    "    people.assign(\n",
    "        body_mass_index=lambda df: df[\"weight\"] / (df[\"height\"] / 100) ** 2\n",
    "    ).assign(overweight=lambda df: df[\"body_mass_index\"] > 25)\n",
    ")\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Evaluating an expression\n",
    "A great feature supported by pandas is expression evaluation. This relies on the `numexpr` library which must be installed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Aman         False\n",
       "Lav           True\n",
       "Praddyumn     True\n",
       "dtype: bool"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "people.eval(\"weight / (height/100) ** 2 > 25\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Assignment expressions are also supported. Let's set `inplace=True` to directly modify the `DataFrame` rather than getting a modified copy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>hobby</th>\n",
       "      <th>height</th>\n",
       "      <th>weight</th>\n",
       "      <th>age</th>\n",
       "      <th>over 30</th>\n",
       "      <th>pets</th>\n",
       "      <th>body_mass_index</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Aman</th>\n",
       "      <td>Biking</td>\n",
       "      <td>172</td>\n",
       "      <td>68</td>\n",
       "      <td>37</td>\n",
       "      <td>True</td>\n",
       "      <td>NaN</td>\n",
       "      <td>22.985398</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Lav</th>\n",
       "      <td>Dancing</td>\n",
       "      <td>181</td>\n",
       "      <td>83</td>\n",
       "      <td>38</td>\n",
       "      <td>True</td>\n",
       "      <td>0.0</td>\n",
       "      <td>25.335002</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Praddyumn</th>\n",
       "      <td>NaN</td>\n",
       "      <td>185</td>\n",
       "      <td>112</td>\n",
       "      <td>30</td>\n",
       "      <td>False</td>\n",
       "      <td>5.0</td>\n",
       "      <td>32.724617</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             hobby  height  weight  age  over 30  pets  body_mass_index\n",
       "Aman        Biking     172      68   37     True   NaN        22.985398\n",
       "Lav        Dancing     181      83   38     True   0.0        25.335002\n",
       "Praddyumn      NaN     185     112   30    False   5.0        32.724617"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "people.eval(\"body_mass_index = weight / (height/100) ** 2\", inplace=True)\n",
    "people"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can use a local or global variable in an expression by prefixing it with `'@'`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>hobby</th>\n",
       "      <th>height</th>\n",
       "      <th>weight</th>\n",
       "      <th>age</th>\n",
       "      <th>over 30</th>\n",
       "      <th>pets</th>\n",
       "      <th>body_mass_index</th>\n",
       "      <th>overweight</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Aman</th>\n",
       "      <td>Biking</td>\n",
       "      <td>172</td>\n",
       "      <td>68</td>\n",
       "      <td>37</td>\n",
       "      <td>True</td>\n",
       "      <td>NaN</td>\n",
       "      <td>22.985398</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Lav</th>\n",
       "      <td>Dancing</td>\n",
       "      <td>181</td>\n",
       "      <td>83</td>\n",
       "      <td>38</td>\n",
       "      <td>True</td>\n",
       "      <td>0.0</td>\n",
       "      <td>25.335002</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Praddyumn</th>\n",
       "      <td>NaN</td>\n",
       "      <td>185</td>\n",
       "      <td>112</td>\n",
       "      <td>30</td>\n",
       "      <td>False</td>\n",
       "      <td>5.0</td>\n",
       "      <td>32.724617</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             hobby  height  weight  age  over 30  pets  body_mass_index  \\\n",
       "Aman        Biking     172      68   37     True   NaN        22.985398   \n",
       "Lav        Dancing     181      83   38     True   0.0        25.335002   \n",
       "Praddyumn      NaN     185     112   30    False   5.0        32.724617   \n",
       "\n",
       "           overweight  \n",
       "Aman            False  \n",
       "Lav             False  \n",
       "Praddyumn        True  "
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "overweight_threshold = 30\n",
    "people.eval(\"overweight = body_mass_index > @overweight_threshold\", inplace=True)\n",
    "people"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Querying a `DataFrame`\n",
    "The `query()` method lets you filter a `DataFrame` based on a query expression:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>hobby</th>\n",
       "      <th>height</th>\n",
       "      <th>weight</th>\n",
       "      <th>age</th>\n",
       "      <th>over 30</th>\n",
       "      <th>pets</th>\n",
       "      <th>body_mass_index</th>\n",
       "      <th>overweight</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Lav</th>\n",
       "      <td>Dancing</td>\n",
       "      <td>181</td>\n",
       "      <td>83</td>\n",
       "      <td>38</td>\n",
       "      <td>True</td>\n",
       "      <td>0.0</td>\n",
       "      <td>25.335002</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       hobby  height  weight  age  over 30  pets  body_mass_index  overweight\n",
       "Lav  Dancing     181      83   38     True   0.0        25.335002       False"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "people.query(\"age > 30 and pets == 0\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sorting a `DataFrame`\n",
    "You can sort a `DataFrame` by calling its `sort_index` method. By default it sorts the rows by their index label, in ascending order, but let's reverse the order:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>hobby</th>\n",
       "      <th>height</th>\n",
       "      <th>weight</th>\n",
       "      <th>age</th>\n",
       "      <th>over 30</th>\n",
       "      <th>pets</th>\n",
       "      <th>body_mass_index</th>\n",
       "      <th>overweight</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Praddyumn</th>\n",
       "      <td>NaN</td>\n",
       "      <td>185</td>\n",
       "      <td>112</td>\n",
       "      <td>30</td>\n",
       "      <td>False</td>\n",
       "      <td>5.0</td>\n",
       "      <td>32.724617</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Lav</th>\n",
       "      <td>Dancing</td>\n",
       "      <td>181</td>\n",
       "      <td>83</td>\n",
       "      <td>38</td>\n",
       "      <td>True</td>\n",
       "      <td>0.0</td>\n",
       "      <td>25.335002</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Aman</th>\n",
       "      <td>Biking</td>\n",
       "      <td>172</td>\n",
       "      <td>68</td>\n",
       "      <td>37</td>\n",
       "      <td>True</td>\n",
       "      <td>NaN</td>\n",
       "      <td>22.985398</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             hobby  height  weight  age  over 30  pets  body_mass_index  \\\n",
       "Praddyumn      NaN     185     112   30    False   5.0        32.724617   \n",
       "Lav        Dancing     181      83   38     True   0.0        25.335002   \n",
       "Aman        Biking     172      68   37     True   NaN        22.985398   \n",
       "\n",
       "           overweight  \n",
       "Praddyumn        True  \n",
       "Lav             False  \n",
       "Aman            False  "
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "people.sort_index(ascending=False)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that `sort_index` returned a sorted *copy* of the `DataFrame`. To modify `people` directly, we can set the `inplace` argument to `True`. Also, we can sort the columns instead of the rows by setting `axis=1`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>age</th>\n",
       "      <th>body_mass_index</th>\n",
       "      <th>height</th>\n",
       "      <th>hobby</th>\n",
       "      <th>over 30</th>\n",
       "      <th>overweight</th>\n",
       "      <th>pets</th>\n",
       "      <th>weight</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Aman</th>\n",
       "      <td>37</td>\n",
       "      <td>22.985398</td>\n",
       "      <td>172</td>\n",
       "      <td>Biking</td>\n",
       "      <td>True</td>\n",
       "      <td>False</td>\n",
       "      <td>NaN</td>\n",
       "      <td>68</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Lav</th>\n",
       "      <td>38</td>\n",
       "      <td>25.335002</td>\n",
       "      <td>181</td>\n",
       "      <td>Dancing</td>\n",
       "      <td>True</td>\n",
       "      <td>False</td>\n",
       "      <td>0.0</td>\n",
       "      <td>83</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Praddyumn</th>\n",
       "      <td>30</td>\n",
       "      <td>32.724617</td>\n",
       "      <td>185</td>\n",
       "      <td>NaN</td>\n",
       "      <td>False</td>\n",
       "      <td>True</td>\n",
       "      <td>5.0</td>\n",
       "      <td>112</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           age  body_mass_index  height    hobby  over 30  overweight  pets  \\\n",
       "Aman        37        22.985398     172   Biking     True       False   NaN   \n",
       "Lav         38        25.335002     181  Dancing     True       False   0.0   \n",
       "Praddyumn   30        32.724617     185      NaN    False        True   5.0   \n",
       "\n",
       "           weight  \n",
       "Aman           68  \n",
       "Lav            83  \n",
       "Praddyumn     112  "
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "people.sort_index(axis=1, inplace=True)\n",
    "people"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To sort the `DataFrame` by the values instead of the labels, we can use `sort_values` and specify the column to sort by:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [],
   "source": [
    "people.sort_values(by=\"age\", inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>age</th>\n",
       "      <th>body_mass_index</th>\n",
       "      <th>height</th>\n",
       "      <th>hobby</th>\n",
       "      <th>over 30</th>\n",
       "      <th>overweight</th>\n",
       "      <th>pets</th>\n",
       "      <th>weight</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Praddyumn</th>\n",
       "      <td>30</td>\n",
       "      <td>32.724617</td>\n",
       "      <td>185</td>\n",
       "      <td>NaN</td>\n",
       "      <td>False</td>\n",
       "      <td>True</td>\n",
       "      <td>5.0</td>\n",
       "      <td>112</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Aman</th>\n",
       "      <td>37</td>\n",
       "      <td>22.985398</td>\n",
       "      <td>172</td>\n",
       "      <td>Biking</td>\n",
       "      <td>True</td>\n",
       "      <td>False</td>\n",
       "      <td>NaN</td>\n",
       "      <td>68</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Lav</th>\n",
       "      <td>38</td>\n",
       "      <td>25.335002</td>\n",
       "      <td>181</td>\n",
       "      <td>Dancing</td>\n",
       "      <td>True</td>\n",
       "      <td>False</td>\n",
       "      <td>0.0</td>\n",
       "      <td>83</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           age  body_mass_index  height    hobby  over 30  overweight  pets  \\\n",
       "Praddyumn   30        32.724617     185      NaN    False        True   5.0   \n",
       "Aman        37        22.985398     172   Biking     True       False   NaN   \n",
       "Lav         38        25.335002     181  Dancing     True       False   0.0   \n",
       "\n",
       "           weight  \n",
       "Praddyumn     112  \n",
       "Aman           68  \n",
       "Lav            83  "
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "people"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plotting a `DataFrame`\n",
    "Just like for `Series`, pandas makes it easy to draw nice graphs based on a `DataFrame`.\n",
    "\n",
    "For example, it is trivial to create a line plot from a `DataFrame`'s data by calling its `plot` method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "people.plot(kind=\"line\", x=\"body_mass_index\", y=[\"height\", \"weight\"])\n",
    "plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can pass extra arguments supported by matplotlib's functions. For example, we can create scatterplot and pass it a list of sizes using the `s` argument of matplotlib's `scatter()` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "people.plot(kind = \"scatter\", x = \"height\", y = \"weight\", s=[40, 120, 200])\n",
    "plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Again, there are way too many options to list here: the best option is to scroll through the [Visualization](http://pandas.pydata.org/pandas-docs/stable/visualization.html) page in pandas' documentation, find the plot you are interested in and look at the example code."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Operations on `DataFrame`s\n",
    "So, now we Have Learned About `DataFrame`s a Lot But now Let's Learn about Operations That Can be Applied on a `DataFrame`. All Though Pandas `DataFrame`s don't Try to Mimic `ndarray`s or Numpy `Array`s but still some Functions are Same Between `ndarray`s and Pandas `DataFrame`s."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>sep</th>\n",
       "      <th>oct</th>\n",
       "      <th>nov</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Aman</th>\n",
       "      <td>8</td>\n",
       "      <td>8</td>\n",
       "      <td>9</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Lav</th>\n",
       "      <td>10</td>\n",
       "      <td>9</td>\n",
       "      <td>9</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Praddyumn</th>\n",
       "      <td>4</td>\n",
       "      <td>8</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Nityendra</th>\n",
       "      <td>9</td>\n",
       "      <td>10</td>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           sep  oct  nov\n",
       "Aman         8    8    9\n",
       "Lav         10    9    9\n",
       "Praddyumn    4    8    2\n",
       "Nityendra    9   10   10"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grades_array = np.array([[8,8,9],[10,9,9],[4, 8, 2], [9, 10, 10]])\n",
    "grades = pd.DataFrame(grades_array, columns=[\"sep\", \"oct\", \"nov\"], index=[\"Aman\",\"Lav\",\"Praddyumn\",\"Nityendra\"])\n",
    "grades"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can apply NumPy mathematical functions on a `DataFrame`: the function is applied to all values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>sep</th>\n",
       "      <th>oct</th>\n",
       "      <th>nov</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Aman</th>\n",
       "      <td>2.828427</td>\n",
       "      <td>2.828427</td>\n",
       "      <td>3.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Lav</th>\n",
       "      <td>3.162278</td>\n",
       "      <td>3.000000</td>\n",
       "      <td>3.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Praddyumn</th>\n",
       "      <td>2.000000</td>\n",
       "      <td>2.828427</td>\n",
       "      <td>1.414214</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Nityendra</th>\n",
       "      <td>3.000000</td>\n",
       "      <td>3.162278</td>\n",
       "      <td>3.162278</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                sep       oct       nov\n",
       "Aman       2.828427  2.828427  3.000000\n",
       "Lav        3.162278  3.000000  3.000000\n",
       "Praddyumn  2.000000  2.828427  1.414214\n",
       "Nityendra  3.000000  3.162278  3.162278"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sqrt(grades)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similarly, adding a single value to a `DataFrame` will add that value to all elements in the `DataFrame`. This is called *broadcasting*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>sep</th>\n",
       "      <th>oct</th>\n",
       "      <th>nov</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Aman</th>\n",
       "      <td>9</td>\n",
       "      <td>9</td>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Lav</th>\n",
       "      <td>11</td>\n",
       "      <td>10</td>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Praddyumn</th>\n",
       "      <td>5</td>\n",
       "      <td>9</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Nityendra</th>\n",
       "      <td>10</td>\n",
       "      <td>11</td>\n",
       "      <td>11</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           sep  oct  nov\n",
       "Aman         9    9   10\n",
       "Lav         11   10   10\n",
       "Praddyumn    5    9    3\n",
       "Nityendra   10   11   11"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grades + 1"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Of course, the same is true for all other binary operations, including arithmetic (`*`,`/`,`**`...) and conditional (`>`, `==`...) operations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>sep</th>\n",
       "      <th>oct</th>\n",
       "      <th>nov</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Aman</th>\n",
       "      <td>True</td>\n",
       "      <td>True</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Lav</th>\n",
       "      <td>True</td>\n",
       "      <td>True</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Praddyumn</th>\n",
       "      <td>False</td>\n",
       "      <td>True</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Nityendra</th>\n",
       "      <td>True</td>\n",
       "      <td>True</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             sep   oct    nov\n",
       "Aman        True  True   True\n",
       "Lav         True  True   True\n",
       "Praddyumn  False  True  False\n",
       "Nityendra   True  True   True"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grades >= 5"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aggregation operations, such as computing the `max`, the `sum` or the `mean` of a `DataFrame`, apply to each column, and you get back a `Series` object:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "sep    7.75\n",
       "oct    8.75\n",
       "nov    7.50\n",
       "dtype: float64"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grades.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "sep    10\n",
       "oct    10\n",
       "nov    10\n",
       "dtype: int64"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grades.max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "sep    31\n",
       "oct    35\n",
       "nov    30\n",
       "dtype: int64"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grades.sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "sep    4\n",
       "oct    8\n",
       "nov    2\n",
       "dtype: int64"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grades.min()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `all` method is also an aggregation operation: it checks whether all values are `True` or not. Let's see during which months all students got a grade greater than `5`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "sep    False\n",
       "oct     True\n",
       "nov    False\n",
       "dtype: bool"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(grades > 5).all()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Most of these functions take an optional `axis` parameter which lets you specify along which axis of the `DataFrame` you want the operation executed. The default is `axis=0`, meaning that the operation is executed vertically (on each column). You can set `axis=1` to execute the operation horizontally (on each row). For example, let's find out which students had all grades greater than `5`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Aman          True\n",
       "Lav           True\n",
       "Praddyumn    False\n",
       "Nityendra     True\n",
       "dtype: bool"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(grades > 5).all(axis=1)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `any` method returns `True` if any value is True. Let's see who got at least one grade 10:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Aman         False\n",
       "Lav           True\n",
       "Praddyumn    False\n",
       "Nityendra     True\n",
       "dtype: bool"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(grades == 10).any(axis = 1)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you add a `Series` object to a `DataFrame` (or execute any other binary operation), pandas attempts to broadcast the operation to all *rows* in the `DataFrame`. This only works if the `Series` has the same size as the `DataFrame`s rows. For example, let's subtract the `mean` of the `DataFrame` (a `Series` object) from the `DataFrame`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>sep</th>\n",
       "      <th>oct</th>\n",
       "      <th>nov</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Aman</th>\n",
       "      <td>0.25</td>\n",
       "      <td>-0.75</td>\n",
       "      <td>1.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Lav</th>\n",
       "      <td>2.25</td>\n",
       "      <td>0.25</td>\n",
       "      <td>1.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Praddyumn</th>\n",
       "      <td>-3.75</td>\n",
       "      <td>-0.75</td>\n",
       "      <td>-5.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Nityendra</th>\n",
       "      <td>1.25</td>\n",
       "      <td>1.25</td>\n",
       "      <td>2.5</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            sep   oct  nov\n",
       "Aman       0.25 -0.75  1.5\n",
       "Lav        2.25  0.25  1.5\n",
       "Praddyumn -3.75 -0.75 -5.5\n",
       "Nityendra  1.25  1.25  2.5"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grades - grades.mean()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We subtracted `7.75` from all September grades, `8.75` from October grades and `7.50` from November grades. It is equivalent to subtracting this `DataFrame`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>sep</th>\n",
       "      <th>oct</th>\n",
       "      <th>nov</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Aman</th>\n",
       "      <td>7.75</td>\n",
       "      <td>8.75</td>\n",
       "      <td>7.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Lav</th>\n",
       "      <td>7.75</td>\n",
       "      <td>8.75</td>\n",
       "      <td>7.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Praddyumn</th>\n",
       "      <td>7.75</td>\n",
       "      <td>8.75</td>\n",
       "      <td>7.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Nityendra</th>\n",
       "      <td>7.75</td>\n",
       "      <td>8.75</td>\n",
       "      <td>7.5</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            sep   oct  nov\n",
       "Aman       7.75  8.75  7.5\n",
       "Lav        7.75  8.75  7.5\n",
       "Praddyumn  7.75  8.75  7.5\n",
       "Nityendra  7.75  8.75  7.5"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.DataFrame([[7.75, 8.75, 7.50]]*4, index=grades.index, columns=grades.columns)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We subtracted `7.75` from all September grades, `8.75` from October grades and `7.50` from November grades. It is equivalent to subtracting this `DataFrame`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>sep</th>\n",
       "      <th>oct</th>\n",
       "      <th>nov</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Aman</th>\n",
       "      <td>7.75</td>\n",
       "      <td>8.75</td>\n",
       "      <td>7.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Lav</th>\n",
       "      <td>7.75</td>\n",
       "      <td>8.75</td>\n",
       "      <td>7.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Praddyumn</th>\n",
       "      <td>7.75</td>\n",
       "      <td>8.75</td>\n",
       "      <td>7.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Nityendra</th>\n",
       "      <td>7.75</td>\n",
       "      <td>8.75</td>\n",
       "      <td>7.5</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            sep   oct  nov\n",
       "Aman       7.75  8.75  7.5\n",
       "Lav        7.75  8.75  7.5\n",
       "Praddyumn  7.75  8.75  7.5\n",
       "Nityendra  7.75  8.75  7.5"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = pd.DataFrame([[7.75, 8.75, 7.50]]*4, index=grades.index, columns=grades.columns)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>sep</th>\n",
       "      <th>oct</th>\n",
       "      <th>nov</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Aman</th>\n",
       "      <td>0.25</td>\n",
       "      <td>-0.75</td>\n",
       "      <td>1.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Lav</th>\n",
       "      <td>2.25</td>\n",
       "      <td>0.25</td>\n",
       "      <td>1.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Praddyumn</th>\n",
       "      <td>-3.75</td>\n",
       "      <td>-0.75</td>\n",
       "      <td>-5.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Nityendra</th>\n",
       "      <td>1.25</td>\n",
       "      <td>1.25</td>\n",
       "      <td>2.5</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            sep   oct  nov\n",
       "Aman       0.25 -0.75  1.5\n",
       "Lav        2.25  0.25  1.5\n",
       "Praddyumn -3.75 -0.75 -5.5\n",
       "Nityendra  1.25  1.25  2.5"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grades - a"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want to subtract the global mean from every grade, here is one way to do it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>sep</th>\n",
       "      <th>oct</th>\n",
       "      <th>nov</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Aman</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Lav</th>\n",
       "      <td>2.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Praddyumn</th>\n",
       "      <td>-4.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>-6.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Nityendra</th>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           sep  oct  nov\n",
       "Aman       0.0  0.0  1.0\n",
       "Lav        2.0  1.0  1.0\n",
       "Praddyumn -4.0  0.0 -6.0\n",
       "Nityendra  1.0  2.0  2.0"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grades - grades.values.mean()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Automatic alignment\n",
    "Similar to `Series`, when operating on multiple `DataFrame`s, pandas automatically aligns them by row index label, but also by column names. Let's create a `DataFrame` with bonus points for each person from October to December:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>oct</th>\n",
       "      <th>nov</th>\n",
       "      <th>dec</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Lav</th>\n",
       "      <td>0.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Anurag</th>\n",
       "      <td>NaN</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Nityendra</th>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Praddyumn</th>\n",
       "      <td>3.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           oct  nov  dec\n",
       "Lav        0.0  NaN  2.0\n",
       "Anurag     NaN  1.0  0.0\n",
       "Nityendra  0.0  1.0  0.0\n",
       "Praddyumn  3.0  3.0  0.0"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bonus_array = np.array([[0, np.nan, 2], [np.nan, 1, 0], [0, 1, 0], [3, 3, 0]])\n",
    "bonus_points = pd.DataFrame(bonus_array, columns=[\"oct\", \"nov\", \"dec\"], index=[\"Lav\", \"Anurag\", \"Nityendra\", \"Praddyumn\"])\n",
    "bonus_points"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>sep</th>\n",
       "      <th>oct</th>\n",
       "      <th>nov</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Aman</th>\n",
       "      <td>8</td>\n",
       "      <td>8</td>\n",
       "      <td>9</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Lav</th>\n",
       "      <td>10</td>\n",
       "      <td>9</td>\n",
       "      <td>9</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Praddyumn</th>\n",
       "      <td>4</td>\n",
       "      <td>8</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Nityendra</th>\n",
       "      <td>9</td>\n",
       "      <td>10</td>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           sep  oct  nov\n",
       "Aman         8    8    9\n",
       "Lav         10    9    9\n",
       "Praddyumn    4    8    2\n",
       "Nityendra    9   10   10"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grades"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>dec</th>\n",
       "      <th>nov</th>\n",
       "      <th>oct</th>\n",
       "      <th>sep</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Aman</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Anurag</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Lav</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>9.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Nityendra</th>\n",
       "      <td>NaN</td>\n",
       "      <td>11.0</td>\n",
       "      <td>10.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Praddyumn</th>\n",
       "      <td>NaN</td>\n",
       "      <td>5.0</td>\n",
       "      <td>11.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           dec   nov   oct  sep\n",
       "Aman       NaN   NaN   NaN  NaN\n",
       "Anurag     NaN   NaN   NaN  NaN\n",
       "Lav        NaN   NaN   9.0  NaN\n",
       "Nityendra  NaN  11.0  10.0  NaN\n",
       "Praddyumn  NaN   5.0  11.0  NaN"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grades + bonus_points"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Looks like the addition worked in some cases but way too many elements are now empty. That's because when aligning the `DataFrame`s, some columns and rows were only present on one side, and thus they were considered missing on the other side (`NaN`). Then adding `NaN` to a number results in `NaN`, hence the result."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Handling missing data\n",
    "Dealing with missing data is a frequent task when working with real life data. Pandas offers a few tools to handle missing data.\n",
    " \n",
    "Let's try to fix the problem above. For example, we can decide that missing data should result in a zero, instead of `NaN`. We can replace all `NaN` values by a any value using the `fillna()` method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>dec</th>\n",
       "      <th>nov</th>\n",
       "      <th>oct</th>\n",
       "      <th>sep</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Aman</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Anurag</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Lav</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>9.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Nityendra</th>\n",
       "      <td>0.0</td>\n",
       "      <td>11.0</td>\n",
       "      <td>10.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Praddyumn</th>\n",
       "      <td>0.0</td>\n",
       "      <td>5.0</td>\n",
       "      <td>11.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           dec   nov   oct  sep\n",
       "Aman       0.0   0.0   0.0  0.0\n",
       "Anurag     0.0   0.0   0.0  0.0\n",
       "Lav        0.0   0.0   9.0  0.0\n",
       "Nityendra  0.0  11.0  10.0  0.0\n",
       "Praddyumn  0.0   5.0  11.0  0.0"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(grades + bonus_points).fillna(0)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's a bit unfair that we're setting grades to zero in September, though. Perhaps we should decide that missing grades are missing grades, but missing bonus points should be replaced by zeros:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>dec</th>\n",
       "      <th>nov</th>\n",
       "      <th>oct</th>\n",
       "      <th>sep</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Aman</th>\n",
       "      <td>NaN</td>\n",
       "      <td>9.0</td>\n",
       "      <td>8.0</td>\n",
       "      <td>8.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Anurag</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Lav</th>\n",
       "      <td>NaN</td>\n",
       "      <td>9.0</td>\n",
       "      <td>9.0</td>\n",
       "      <td>10.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Nityendra</th>\n",
       "      <td>NaN</td>\n",
       "      <td>11.0</td>\n",
       "      <td>10.0</td>\n",
       "      <td>9.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Praddyumn</th>\n",
       "      <td>NaN</td>\n",
       "      <td>5.0</td>\n",
       "      <td>11.0</td>\n",
       "      <td>4.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           dec   nov   oct   sep\n",
       "Aman       NaN   9.0   8.0   8.0\n",
       "Anurag     NaN   NaN   NaN   NaN\n",
       "Lav        NaN   9.0   9.0  10.0\n",
       "Nityendra  NaN  11.0  10.0   9.0\n",
       "Praddyumn  NaN   5.0  11.0   4.0"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fixed_bonus_points = bonus_points.fillna(0)\n",
    "fixed_bonus_points.insert(0, \"sep\", 0)\n",
    "fixed_bonus_points.loc[\"Aman\"] = 0\n",
    "grades + fixed_bonus_points"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That's much better: although we made up some data, we have not been too unfair.\n",
    "\n",
    "Another way to handle missing data is to interpolate. Let's look at the `bonus_points` `DataFrame` again:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>oct</th>\n",
       "      <th>nov</th>\n",
       "      <th>dec</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Lav</th>\n",
       "      <td>0.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Anurag</th>\n",
       "      <td>NaN</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Nityendra</th>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Praddyumn</th>\n",
       "      <td>3.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           oct  nov  dec\n",
       "Lav        0.0  NaN  2.0\n",
       "Anurag     NaN  1.0  0.0\n",
       "Nityendra  0.0  1.0  0.0\n",
       "Praddyumn  3.0  3.0  0.0"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bonus_points"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's call the `interpolate` method. By default, it interpolates vertically (`axis=0`), so let's tell it to interpolate horizontally (`axis=1`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>oct</th>\n",
       "      <th>nov</th>\n",
       "      <th>dec</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Lav</th>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Anurag</th>\n",
       "      <td>NaN</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Nityendra</th>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Praddyumn</th>\n",
       "      <td>3.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           oct  nov  dec\n",
       "Lav        0.0  1.0  2.0\n",
       "Anurag     NaN  1.0  0.0\n",
       "Nityendra  0.0  1.0  0.0\n",
       "Praddyumn  3.0  3.0  0.0"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bonus_points.interpolate(axis=1)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lav had 0 bonus points in October, and 2 in December. When we interpolate for November, we get the mean: 1 bonus point. Anurag had 1 bonus point in November, but we do not know how many bonus points he had in September, so we cannot interpolate, this is why there is still a missing value in October after interpolation. To fix this, we can set the September bonus points to 0 before interpolation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>sep</th>\n",
       "      <th>oct</th>\n",
       "      <th>nov</th>\n",
       "      <th>dec</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Lav</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Anurag</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Nityendra</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Praddyumn</th>\n",
       "      <td>0.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Aman</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           sep  oct  nov  dec\n",
       "Lav        0.0  0.0  1.0  2.0\n",
       "Anurag     0.0  0.5  1.0  0.0\n",
       "Nityendra  0.0  0.0  1.0  0.0\n",
       "Praddyumn  0.0  3.0  3.0  0.0\n",
       "Aman       0.0  0.0  0.0  0.0"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "better_bonus_points = bonus_points.copy()\n",
    "better_bonus_points.insert(0, \"sep\", 0)\n",
    "better_bonus_points.loc[\"Aman\"] = 0\n",
    "better_bonus_points = better_bonus_points.interpolate(axis=1)\n",
    "better_bonus_points"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Great, now we have reasonable bonus points everywhere. Let's find out the final grades:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>dec</th>\n",
       "      <th>nov</th>\n",
       "      <th>oct</th>\n",
       "      <th>sep</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Aman</th>\n",
       "      <td>NaN</td>\n",
       "      <td>9.0</td>\n",
       "      <td>8.0</td>\n",
       "      <td>8.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Anurag</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Lav</th>\n",
       "      <td>NaN</td>\n",
       "      <td>10.0</td>\n",
       "      <td>9.0</td>\n",
       "      <td>10.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Nityendra</th>\n",
       "      <td>NaN</td>\n",
       "      <td>11.0</td>\n",
       "      <td>10.0</td>\n",
       "      <td>9.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Praddyumn</th>\n",
       "      <td>NaN</td>\n",
       "      <td>5.0</td>\n",
       "      <td>11.0</td>\n",
       "      <td>4.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           dec   nov   oct   sep\n",
       "Aman       NaN   9.0   8.0   8.0\n",
       "Anurag     NaN   NaN   NaN   NaN\n",
       "Lav        NaN  10.0   9.0  10.0\n",
       "Nityendra  NaN  11.0  10.0   9.0\n",
       "Praddyumn  NaN   5.0  11.0   4.0"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grades + better_bonus_points"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is slightly annoying that the September column ends up on the right. This is because the `DataFrame`s we are adding do not have the exact same columns (the `grades` `DataFrame` is missing the `\"dec\"` column), so to make things predictable, pandas orders the final columns alphabetically. To fix this, we can simply add the missing column before adding:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>sep</th>\n",
       "      <th>oct</th>\n",
       "      <th>nov</th>\n",
       "      <th>dec</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Aman</th>\n",
       "      <td>8.0</td>\n",
       "      <td>8.0</td>\n",
       "      <td>9.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Anurag</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Lav</th>\n",
       "      <td>10.0</td>\n",
       "      <td>9.0</td>\n",
       "      <td>10.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Nityendra</th>\n",
       "      <td>9.0</td>\n",
       "      <td>10.0</td>\n",
       "      <td>11.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Praddyumn</th>\n",
       "      <td>4.0</td>\n",
       "      <td>11.0</td>\n",
       "      <td>5.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            sep   oct   nov  dec\n",
       "Aman        8.0   8.0   9.0  NaN\n",
       "Anurag      NaN   NaN   NaN  NaN\n",
       "Lav        10.0   9.0  10.0  NaN\n",
       "Nityendra   9.0  10.0  11.0  NaN\n",
       "Praddyumn   4.0  11.0   5.0  NaN"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grades[\"dec\"] = np.nan\n",
    "final_grades = grades + better_bonus_points\n",
    "final_grades"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There's not much we can do about December and Colin: it's bad enough that we are making up bonus points, but we can't reasonably make up grades (well I guess some teachers probably do). So let's call the `dropna()` method to get rid of rows that are full of `NaN`s:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>sep</th>\n",
       "      <th>oct</th>\n",
       "      <th>nov</th>\n",
       "      <th>dec</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Aman</th>\n",
       "      <td>8.0</td>\n",
       "      <td>8.0</td>\n",
       "      <td>9.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Lav</th>\n",
       "      <td>10.0</td>\n",
       "      <td>9.0</td>\n",
       "      <td>10.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Nityendra</th>\n",
       "      <td>9.0</td>\n",
       "      <td>10.0</td>\n",
       "      <td>11.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Praddyumn</th>\n",
       "      <td>4.0</td>\n",
       "      <td>11.0</td>\n",
       "      <td>5.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            sep   oct   nov  dec\n",
       "Aman        8.0   8.0   9.0  NaN\n",
       "Lav        10.0   9.0  10.0  NaN\n",
       "Nityendra   9.0  10.0  11.0  NaN\n",
       "Praddyumn   4.0  11.0   5.0  NaN"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "final_grades_clean = final_grades.dropna(how=\"all\")\n",
    "final_grades_clean"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's remove columns that are full of `NaN`s by setting the `axis` argument to `1`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>sep</th>\n",
       "      <th>oct</th>\n",
       "      <th>nov</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Aman</th>\n",
       "      <td>8.0</td>\n",
       "      <td>8.0</td>\n",
       "      <td>9.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Lav</th>\n",
       "      <td>10.0</td>\n",
       "      <td>9.0</td>\n",
       "      <td>10.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Nityendra</th>\n",
       "      <td>9.0</td>\n",
       "      <td>10.0</td>\n",
       "      <td>11.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Praddyumn</th>\n",
       "      <td>4.0</td>\n",
       "      <td>11.0</td>\n",
       "      <td>5.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            sep   oct   nov\n",
       "Aman        8.0   8.0   9.0\n",
       "Lav        10.0   9.0  10.0\n",
       "Nityendra   9.0  10.0  11.0\n",
       "Praddyumn   4.0  11.0   5.0"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "final_grades_clean = final_grades_clean.dropna(axis=1, how=\"all\")\n",
    "final_grades_clean"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Aggregating with `groupby`\n",
    "Similar to the SQL language, pandas allows grouping your data into groups to run calculations over each group.\n",
    "\n",
    "First, let's add some extra data about each person so we can group them, and let's go back to the `final_grades` `DataFrame` so we can see how `NaN` values are handled:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>sep</th>\n",
       "      <th>oct</th>\n",
       "      <th>nov</th>\n",
       "      <th>dec</th>\n",
       "      <th>hobby</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Aman</th>\n",
       "      <td>8.0</td>\n",
       "      <td>8.0</td>\n",
       "      <td>9.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>Biking</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Anurag</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>Dancing</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Lav</th>\n",
       "      <td>10.0</td>\n",
       "      <td>9.0</td>\n",
       "      <td>10.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Nityendra</th>\n",
       "      <td>9.0</td>\n",
       "      <td>10.0</td>\n",
       "      <td>11.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>Dancing</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Praddyumn</th>\n",
       "      <td>4.0</td>\n",
       "      <td>11.0</td>\n",
       "      <td>5.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>Biking</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            sep   oct   nov  dec    hobby\n",
       "Aman        8.0   8.0   9.0  NaN   Biking\n",
       "Anurag      NaN   NaN   NaN  NaN  Dancing\n",
       "Lav        10.0   9.0  10.0  NaN      NaN\n",
       "Nityendra   9.0  10.0  11.0  NaN  Dancing\n",
       "Praddyumn   4.0  11.0   5.0  NaN   Biking"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "final_grades[\"hobby\"] = [\"Biking\", \"Dancing\", np.nan, \"Dancing\", \"Biking\"]\n",
    "final_grades"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now Let's Group the Data in `DataFrame` by `hobby`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<pandas.core.groupby.generic.DataFrameGroupBy object at 0x7f39451ddd50>"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grouped_grades = final_grades.groupby(\"hobby\")\n",
    "grouped_grades"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We are Ready to Compute the Average of Grade per hobby:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>sep</th>\n",
       "      <th>oct</th>\n",
       "      <th>nov</th>\n",
       "      <th>dec</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>hobby</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Biking</th>\n",
       "      <td>6.0</td>\n",
       "      <td>9.5</td>\n",
       "      <td>7.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Dancing</th>\n",
       "      <td>9.0</td>\n",
       "      <td>10.0</td>\n",
       "      <td>11.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         sep   oct   nov  dec\n",
       "hobby                        \n",
       "Biking   6.0   9.5   7.0  NaN\n",
       "Dancing  9.0  10.0  11.0  NaN"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grouped_grades.mean()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That was easy! Note that the `NaN` values have simply been skipped when computing the means."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pivot tables\n",
    "Pandas supports spreadsheet-like [pivot tables](https://en.wikipedia.org/wiki/Pivot_table) that allow quick data summarization. To illustrate this, let's create a simple `DataFrame`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>oct</th>\n",
       "      <th>nov</th>\n",
       "      <th>dec</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Lav</th>\n",
       "      <td>0.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Anurag</th>\n",
       "      <td>NaN</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Nityendra</th>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Praddyumn</th>\n",
       "      <td>3.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           oct  nov  dec\n",
       "Lav        0.0  NaN  2.0\n",
       "Anurag     NaN  1.0  0.0\n",
       "Nityendra  0.0  1.0  0.0\n",
       "Praddyumn  3.0  3.0  0.0"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bonus_points"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>name</th>\n",
       "      <th>month</th>\n",
       "      <th>grade</th>\n",
       "      <th>bonus</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Aman</td>\n",
       "      <td>sep</td>\n",
       "      <td>8.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Aman</td>\n",
       "      <td>oct</td>\n",
       "      <td>8.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Aman</td>\n",
       "      <td>nov</td>\n",
       "      <td>9.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Lav</td>\n",
       "      <td>sep</td>\n",
       "      <td>10.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Lav</td>\n",
       "      <td>oct</td>\n",
       "      <td>9.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Lav</td>\n",
       "      <td>nov</td>\n",
       "      <td>10.0</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>Nityendra</td>\n",
       "      <td>sep</td>\n",
       "      <td>9.0</td>\n",
       "      <td>3.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>Nityendra</td>\n",
       "      <td>oct</td>\n",
       "      <td>10.0</td>\n",
       "      <td>3.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>Nityendra</td>\n",
       "      <td>nov</td>\n",
       "      <td>11.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>Praddyumn</td>\n",
       "      <td>sep</td>\n",
       "      <td>4.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>Praddyumn</td>\n",
       "      <td>oct</td>\n",
       "      <td>11.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>Praddyumn</td>\n",
       "      <td>nov</td>\n",
       "      <td>5.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         name month  grade  bonus\n",
       "0        Aman   sep    8.0    NaN\n",
       "1        Aman   oct    8.0    NaN\n",
       "2        Aman   nov    9.0    NaN\n",
       "3         Lav   sep   10.0    0.0\n",
       "4         Lav   oct    9.0    NaN\n",
       "5         Lav   nov   10.0    2.0\n",
       "6   Nityendra   sep    9.0    3.0\n",
       "7   Nityendra   oct   10.0    3.0\n",
       "8   Nityendra   nov   11.0    0.0\n",
       "9   Praddyumn   sep    4.0    0.0\n",
       "10  Praddyumn   oct   11.0    1.0\n",
       "11  Praddyumn   nov    5.0    0.0"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "more_grades = final_grades_clean.stack().reset_index()\n",
    "more_grades.columns = [\"name\", \"month\", \"grade\"]\n",
    "more_grades[\"bonus\"] = [np.nan, np.nan, np.nan, 0, np.nan, 2, 3, 3, 0, 0, 1, 0]\n",
    "more_grades"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can call the `pd.pivot_table()` function for this `DataFrame`, asking to group by the `name` column. By default, `pivot_table()` computes the mean of each numeric column:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_24589/584684106.py:1: FutureWarning: pivot_table dropped a column because it failed to aggregate. This behavior is deprecated and will raise in a future version of pandas. Select only the columns that can be aggregated.\n",
      "  pd.pivot_table(more_grades, index=\"name\")\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>bonus</th>\n",
       "      <th>grade</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>name</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Aman</th>\n",
       "      <td>NaN</td>\n",
       "      <td>8.333333</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Lav</th>\n",
       "      <td>1.000000</td>\n",
       "      <td>9.666667</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Nityendra</th>\n",
       "      <td>2.000000</td>\n",
       "      <td>10.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Praddyumn</th>\n",
       "      <td>0.333333</td>\n",
       "      <td>6.666667</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "              bonus      grade\n",
       "name                          \n",
       "Aman            NaN   8.333333\n",
       "Lav        1.000000   9.666667\n",
       "Nityendra  2.000000  10.000000\n",
       "Praddyumn  0.333333   6.666667"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.pivot_table(more_grades, index=\"name\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can change the aggregation function by setting the `aggfunc` argument, and we can also specify the list of columns whose values will be aggregated:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>bonus</th>\n",
       "      <th>grade</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>name</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Aman</th>\n",
       "      <td>NaN</td>\n",
       "      <td>9.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Lav</th>\n",
       "      <td>2.0</td>\n",
       "      <td>10.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Nityendra</th>\n",
       "      <td>3.0</td>\n",
       "      <td>11.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Praddyumn</th>\n",
       "      <td>1.0</td>\n",
       "      <td>11.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           bonus  grade\n",
       "name                   \n",
       "Aman         NaN    9.0\n",
       "Lav          2.0   10.0\n",
       "Nityendra    3.0   11.0\n",
       "Praddyumn    1.0   11.0"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.pivot_table(more_grades, index=\"name\", values=[\"grade\", \"bonus\"], aggfunc=np.max)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also specify the `columns` to aggregate over horizontally, and request the grand totals for each row and column by setting `margins=True`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th>month</th>\n",
       "      <th>nov</th>\n",
       "      <th>oct</th>\n",
       "      <th>sep</th>\n",
       "      <th>All</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>name</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Aman</th>\n",
       "      <td>9.00</td>\n",
       "      <td>8.0</td>\n",
       "      <td>8.00</td>\n",
       "      <td>8.333333</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Lav</th>\n",
       "      <td>10.00</td>\n",
       "      <td>9.0</td>\n",
       "      <td>10.00</td>\n",
       "      <td>9.666667</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Nityendra</th>\n",
       "      <td>11.00</td>\n",
       "      <td>10.0</td>\n",
       "      <td>9.00</td>\n",
       "      <td>10.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Praddyumn</th>\n",
       "      <td>5.00</td>\n",
       "      <td>11.0</td>\n",
       "      <td>4.00</td>\n",
       "      <td>6.666667</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>All</th>\n",
       "      <td>8.75</td>\n",
       "      <td>9.5</td>\n",
       "      <td>7.75</td>\n",
       "      <td>8.666667</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "month        nov   oct    sep        All\n",
       "name                                    \n",
       "Aman        9.00   8.0   8.00   8.333333\n",
       "Lav        10.00   9.0  10.00   9.666667\n",
       "Nityendra  11.00  10.0   9.00  10.000000\n",
       "Praddyumn   5.00  11.0   4.00   6.666667\n",
       "All         8.75   9.5   7.75   8.666667"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.pivot_table(more_grades, index=\"name\", values=\"grade\", columns=\"month\", margins=True)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we can specify multiple index or column names, and pandas will create multi-level indices:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th>bonus</th>\n",
       "      <th>grade</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>name</th>\n",
       "      <th>month</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th rowspan=\"3\" valign=\"top\">Aman</th>\n",
       "      <th>nov</th>\n",
       "      <td>NaN</td>\n",
       "      <td>9.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>oct</th>\n",
       "      <td>NaN</td>\n",
       "      <td>8.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>sep</th>\n",
       "      <td>NaN</td>\n",
       "      <td>8.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th rowspan=\"3\" valign=\"top\">Lav</th>\n",
       "      <th>nov</th>\n",
       "      <td>2.000</td>\n",
       "      <td>10.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>oct</th>\n",
       "      <td>NaN</td>\n",
       "      <td>9.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>sep</th>\n",
       "      <td>0.000</td>\n",
       "      <td>10.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th rowspan=\"3\" valign=\"top\">Nityendra</th>\n",
       "      <th>nov</th>\n",
       "      <td>0.000</td>\n",
       "      <td>11.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>oct</th>\n",
       "      <td>3.000</td>\n",
       "      <td>10.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>sep</th>\n",
       "      <td>3.000</td>\n",
       "      <td>9.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th rowspan=\"3\" valign=\"top\">Praddyumn</th>\n",
       "      <th>nov</th>\n",
       "      <td>0.000</td>\n",
       "      <td>5.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>oct</th>\n",
       "      <td>1.000</td>\n",
       "      <td>11.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>sep</th>\n",
       "      <td>0.000</td>\n",
       "      <td>4.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>All</th>\n",
       "      <th></th>\n",
       "      <td>1.125</td>\n",
       "      <td>8.75</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                 bonus  grade\n",
       "name      month              \n",
       "Aman      nov      NaN   9.00\n",
       "          oct      NaN   8.00\n",
       "          sep      NaN   8.00\n",
       "Lav       nov    2.000  10.00\n",
       "          oct      NaN   9.00\n",
       "          sep    0.000  10.00\n",
       "Nityendra nov    0.000  11.00\n",
       "          oct    3.000  10.00\n",
       "          sep    3.000   9.00\n",
       "Praddyumn nov    0.000   5.00\n",
       "          oct    1.000  11.00\n",
       "          sep    0.000   4.00\n",
       "All              1.125   8.75"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.pivot_table(more_grades, index=(\"name\", \"month\"), margins=True)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Overview functions\n",
    "When dealing with large `DataFrames`, it is useful to get a quick overview of its content. Pandas offers a few functions for this. First, let's create a large `DataFrame` with a mix of numeric values, missing values and text values. Notice how Jupyter displays only the corners of the `DataFrame`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "      <th>C</th>\n",
       "      <th>some_text</th>\n",
       "      <th>D</th>\n",
       "      <th>E</th>\n",
       "      <th>F</th>\n",
       "      <th>G</th>\n",
       "      <th>H</th>\n",
       "      <th>I</th>\n",
       "      <th>...</th>\n",
       "      <th>Q</th>\n",
       "      <th>R</th>\n",
       "      <th>S</th>\n",
       "      <th>T</th>\n",
       "      <th>U</th>\n",
       "      <th>V</th>\n",
       "      <th>W</th>\n",
       "      <th>X</th>\n",
       "      <th>Y</th>\n",
       "      <th>Z</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>NaN</td>\n",
       "      <td>11.0</td>\n",
       "      <td>44.0</td>\n",
       "      <td>Blabla</td>\n",
       "      <td>99.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>88.0</td>\n",
       "      <td>22.0</td>\n",
       "      <td>165.0</td>\n",
       "      <td>143.0</td>\n",
       "      <td>...</td>\n",
       "      <td>11.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>11.0</td>\n",
       "      <td>44.0</td>\n",
       "      <td>99.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>88.0</td>\n",
       "      <td>22.0</td>\n",
       "      <td>165.0</td>\n",
       "      <td>143.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>11.0</td>\n",
       "      <td>22.0</td>\n",
       "      <td>55.0</td>\n",
       "      <td>Blabla</td>\n",
       "      <td>110.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>99.0</td>\n",
       "      <td>33.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>154.0</td>\n",
       "      <td>...</td>\n",
       "      <td>22.0</td>\n",
       "      <td>11.0</td>\n",
       "      <td>22.0</td>\n",
       "      <td>55.0</td>\n",
       "      <td>110.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>99.0</td>\n",
       "      <td>33.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>154.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>22.0</td>\n",
       "      <td>33.0</td>\n",
       "      <td>66.0</td>\n",
       "      <td>Blabla</td>\n",
       "      <td>121.0</td>\n",
       "      <td>11.0</td>\n",
       "      <td>110.0</td>\n",
       "      <td>44.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>165.0</td>\n",
       "      <td>...</td>\n",
       "      <td>33.0</td>\n",
       "      <td>22.0</td>\n",
       "      <td>33.0</td>\n",
       "      <td>66.0</td>\n",
       "      <td>121.0</td>\n",
       "      <td>11.0</td>\n",
       "      <td>110.0</td>\n",
       "      <td>44.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>165.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>33.0</td>\n",
       "      <td>44.0</td>\n",
       "      <td>77.0</td>\n",
       "      <td>Blabla</td>\n",
       "      <td>132.0</td>\n",
       "      <td>22.0</td>\n",
       "      <td>121.0</td>\n",
       "      <td>55.0</td>\n",
       "      <td>11.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>...</td>\n",
       "      <td>44.0</td>\n",
       "      <td>33.0</td>\n",
       "      <td>44.0</td>\n",
       "      <td>77.0</td>\n",
       "      <td>132.0</td>\n",
       "      <td>22.0</td>\n",
       "      <td>121.0</td>\n",
       "      <td>55.0</td>\n",
       "      <td>11.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>44.0</td>\n",
       "      <td>55.0</td>\n",
       "      <td>88.0</td>\n",
       "      <td>Blabla</td>\n",
       "      <td>143.0</td>\n",
       "      <td>33.0</td>\n",
       "      <td>132.0</td>\n",
       "      <td>66.0</td>\n",
       "      <td>22.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>...</td>\n",
       "      <td>55.0</td>\n",
       "      <td>44.0</td>\n",
       "      <td>55.0</td>\n",
       "      <td>88.0</td>\n",
       "      <td>143.0</td>\n",
       "      <td>33.0</td>\n",
       "      <td>132.0</td>\n",
       "      <td>66.0</td>\n",
       "      <td>22.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9995</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>33.0</td>\n",
       "      <td>Blabla</td>\n",
       "      <td>88.0</td>\n",
       "      <td>165.0</td>\n",
       "      <td>77.0</td>\n",
       "      <td>11.0</td>\n",
       "      <td>154.0</td>\n",
       "      <td>132.0</td>\n",
       "      <td>...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>33.0</td>\n",
       "      <td>88.0</td>\n",
       "      <td>165.0</td>\n",
       "      <td>77.0</td>\n",
       "      <td>11.0</td>\n",
       "      <td>154.0</td>\n",
       "      <td>132.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9996</th>\n",
       "      <td>NaN</td>\n",
       "      <td>11.0</td>\n",
       "      <td>44.0</td>\n",
       "      <td>Blabla</td>\n",
       "      <td>99.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>88.0</td>\n",
       "      <td>22.0</td>\n",
       "      <td>165.0</td>\n",
       "      <td>143.0</td>\n",
       "      <td>...</td>\n",
       "      <td>11.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>11.0</td>\n",
       "      <td>44.0</td>\n",
       "      <td>99.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>88.0</td>\n",
       "      <td>22.0</td>\n",
       "      <td>165.0</td>\n",
       "      <td>143.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9997</th>\n",
       "      <td>11.0</td>\n",
       "      <td>22.0</td>\n",
       "      <td>55.0</td>\n",
       "      <td>Blabla</td>\n",
       "      <td>110.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>99.0</td>\n",
       "      <td>33.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>154.0</td>\n",
       "      <td>...</td>\n",
       "      <td>22.0</td>\n",
       "      <td>11.0</td>\n",
       "      <td>22.0</td>\n",
       "      <td>55.0</td>\n",
       "      <td>110.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>99.0</td>\n",
       "      <td>33.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>154.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9998</th>\n",
       "      <td>22.0</td>\n",
       "      <td>33.0</td>\n",
       "      <td>66.0</td>\n",
       "      <td>Blabla</td>\n",
       "      <td>121.0</td>\n",
       "      <td>11.0</td>\n",
       "      <td>110.0</td>\n",
       "      <td>44.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>165.0</td>\n",
       "      <td>...</td>\n",
       "      <td>33.0</td>\n",
       "      <td>22.0</td>\n",
       "      <td>33.0</td>\n",
       "      <td>66.0</td>\n",
       "      <td>121.0</td>\n",
       "      <td>11.0</td>\n",
       "      <td>110.0</td>\n",
       "      <td>44.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>165.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9999</th>\n",
       "      <td>33.0</td>\n",
       "      <td>44.0</td>\n",
       "      <td>77.0</td>\n",
       "      <td>Blabla</td>\n",
       "      <td>132.0</td>\n",
       "      <td>22.0</td>\n",
       "      <td>121.0</td>\n",
       "      <td>55.0</td>\n",
       "      <td>11.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>...</td>\n",
       "      <td>44.0</td>\n",
       "      <td>33.0</td>\n",
       "      <td>44.0</td>\n",
       "      <td>77.0</td>\n",
       "      <td>132.0</td>\n",
       "      <td>22.0</td>\n",
       "      <td>121.0</td>\n",
       "      <td>55.0</td>\n",
       "      <td>11.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>10000 rows × 27 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "         A     B     C some_text      D      E      F     G      H      I  \\\n",
       "0      NaN  11.0  44.0    Blabla   99.0    NaN   88.0  22.0  165.0  143.0   \n",
       "1     11.0  22.0  55.0    Blabla  110.0    NaN   99.0  33.0    NaN  154.0   \n",
       "2     22.0  33.0  66.0    Blabla  121.0   11.0  110.0  44.0    NaN  165.0   \n",
       "3     33.0  44.0  77.0    Blabla  132.0   22.0  121.0  55.0   11.0    NaN   \n",
       "4     44.0  55.0  88.0    Blabla  143.0   33.0  132.0  66.0   22.0    NaN   \n",
       "...    ...   ...   ...       ...    ...    ...    ...   ...    ...    ...   \n",
       "9995   NaN   NaN  33.0    Blabla   88.0  165.0   77.0  11.0  154.0  132.0   \n",
       "9996   NaN  11.0  44.0    Blabla   99.0    NaN   88.0  22.0  165.0  143.0   \n",
       "9997  11.0  22.0  55.0    Blabla  110.0    NaN   99.0  33.0    NaN  154.0   \n",
       "9998  22.0  33.0  66.0    Blabla  121.0   11.0  110.0  44.0    NaN  165.0   \n",
       "9999  33.0  44.0  77.0    Blabla  132.0   22.0  121.0  55.0   11.0    NaN   \n",
       "\n",
       "      ...     Q     R     S     T      U      V      W     X      Y      Z  \n",
       "0     ...  11.0   NaN  11.0  44.0   99.0    NaN   88.0  22.0  165.0  143.0  \n",
       "1     ...  22.0  11.0  22.0  55.0  110.0    NaN   99.0  33.0    NaN  154.0  \n",
       "2     ...  33.0  22.0  33.0  66.0  121.0   11.0  110.0  44.0    NaN  165.0  \n",
       "3     ...  44.0  33.0  44.0  77.0  132.0   22.0  121.0  55.0   11.0    NaN  \n",
       "4     ...  55.0  44.0  55.0  88.0  143.0   33.0  132.0  66.0   22.0    NaN  \n",
       "...   ...   ...   ...   ...   ...    ...    ...    ...   ...    ...    ...  \n",
       "9995  ...   NaN   NaN   NaN  33.0   88.0  165.0   77.0  11.0  154.0  132.0  \n",
       "9996  ...  11.0   NaN  11.0  44.0   99.0    NaN   88.0  22.0  165.0  143.0  \n",
       "9997  ...  22.0  11.0  22.0  55.0  110.0    NaN   99.0  33.0    NaN  154.0  \n",
       "9998  ...  33.0  22.0  33.0  66.0  121.0   11.0  110.0  44.0    NaN  165.0  \n",
       "9999  ...  44.0  33.0  44.0  77.0  132.0   22.0  121.0  55.0   11.0    NaN  \n",
       "\n",
       "[10000 rows x 27 columns]"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "much_data = np.fromfunction(lambda x,y: (x+y*y)%17*11, (10000, 26))\n",
    "large_df = pd.DataFrame(much_data, columns=list(\"ABCDEFGHIJKLMNOPQRSTUVWXYZ\"))\n",
    "large_df[large_df % 16 == 0] = np.nan\n",
    "large_df.insert(3, \"some_text\", \"Blabla\")\n",
    "large_df"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `head()` method returns the top 5 rows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "      <th>C</th>\n",
       "      <th>some_text</th>\n",
       "      <th>D</th>\n",
       "      <th>E</th>\n",
       "      <th>F</th>\n",
       "      <th>G</th>\n",
       "      <th>H</th>\n",
       "      <th>I</th>\n",
       "      <th>...</th>\n",
       "      <th>Q</th>\n",
       "      <th>R</th>\n",
       "      <th>S</th>\n",
       "      <th>T</th>\n",
       "      <th>U</th>\n",
       "      <th>V</th>\n",
       "      <th>W</th>\n",
       "      <th>X</th>\n",
       "      <th>Y</th>\n",
       "      <th>Z</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>NaN</td>\n",
       "      <td>11.0</td>\n",
       "      <td>44.0</td>\n",
       "      <td>Blabla</td>\n",
       "      <td>99.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>88.0</td>\n",
       "      <td>22.0</td>\n",
       "      <td>165.0</td>\n",
       "      <td>143.0</td>\n",
       "      <td>...</td>\n",
       "      <td>11.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>11.0</td>\n",
       "      <td>44.0</td>\n",
       "      <td>99.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>88.0</td>\n",
       "      <td>22.0</td>\n",
       "      <td>165.0</td>\n",
       "      <td>143.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>11.0</td>\n",
       "      <td>22.0</td>\n",
       "      <td>55.0</td>\n",
       "      <td>Blabla</td>\n",
       "      <td>110.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>99.0</td>\n",
       "      <td>33.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>154.0</td>\n",
       "      <td>...</td>\n",
       "      <td>22.0</td>\n",
       "      <td>11.0</td>\n",
       "      <td>22.0</td>\n",
       "      <td>55.0</td>\n",
       "      <td>110.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>99.0</td>\n",
       "      <td>33.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>154.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>22.0</td>\n",
       "      <td>33.0</td>\n",
       "      <td>66.0</td>\n",
       "      <td>Blabla</td>\n",
       "      <td>121.0</td>\n",
       "      <td>11.0</td>\n",
       "      <td>110.0</td>\n",
       "      <td>44.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>165.0</td>\n",
       "      <td>...</td>\n",
       "      <td>33.0</td>\n",
       "      <td>22.0</td>\n",
       "      <td>33.0</td>\n",
       "      <td>66.0</td>\n",
       "      <td>121.0</td>\n",
       "      <td>11.0</td>\n",
       "      <td>110.0</td>\n",
       "      <td>44.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>165.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>33.0</td>\n",
       "      <td>44.0</td>\n",
       "      <td>77.0</td>\n",
       "      <td>Blabla</td>\n",
       "      <td>132.0</td>\n",
       "      <td>22.0</td>\n",
       "      <td>121.0</td>\n",
       "      <td>55.0</td>\n",
       "      <td>11.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>...</td>\n",
       "      <td>44.0</td>\n",
       "      <td>33.0</td>\n",
       "      <td>44.0</td>\n",
       "      <td>77.0</td>\n",
       "      <td>132.0</td>\n",
       "      <td>22.0</td>\n",
       "      <td>121.0</td>\n",
       "      <td>55.0</td>\n",
       "      <td>11.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>44.0</td>\n",
       "      <td>55.0</td>\n",
       "      <td>88.0</td>\n",
       "      <td>Blabla</td>\n",
       "      <td>143.0</td>\n",
       "      <td>33.0</td>\n",
       "      <td>132.0</td>\n",
       "      <td>66.0</td>\n",
       "      <td>22.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>...</td>\n",
       "      <td>55.0</td>\n",
       "      <td>44.0</td>\n",
       "      <td>55.0</td>\n",
       "      <td>88.0</td>\n",
       "      <td>143.0</td>\n",
       "      <td>33.0</td>\n",
       "      <td>132.0</td>\n",
       "      <td>66.0</td>\n",
       "      <td>22.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>5 rows × 27 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "      A     B     C some_text      D     E      F     G      H      I  ...  \\\n",
       "0   NaN  11.0  44.0    Blabla   99.0   NaN   88.0  22.0  165.0  143.0  ...   \n",
       "1  11.0  22.0  55.0    Blabla  110.0   NaN   99.0  33.0    NaN  154.0  ...   \n",
       "2  22.0  33.0  66.0    Blabla  121.0  11.0  110.0  44.0    NaN  165.0  ...   \n",
       "3  33.0  44.0  77.0    Blabla  132.0  22.0  121.0  55.0   11.0    NaN  ...   \n",
       "4  44.0  55.0  88.0    Blabla  143.0  33.0  132.0  66.0   22.0    NaN  ...   \n",
       "\n",
       "      Q     R     S     T      U     V      W     X      Y      Z  \n",
       "0  11.0   NaN  11.0  44.0   99.0   NaN   88.0  22.0  165.0  143.0  \n",
       "1  22.0  11.0  22.0  55.0  110.0   NaN   99.0  33.0    NaN  154.0  \n",
       "2  33.0  22.0  33.0  66.0  121.0  11.0  110.0  44.0    NaN  165.0  \n",
       "3  44.0  33.0  44.0  77.0  132.0  22.0  121.0  55.0   11.0    NaN  \n",
       "4  55.0  44.0  55.0  88.0  143.0  33.0  132.0  66.0   22.0    NaN  \n",
       "\n",
       "[5 rows x 27 columns]"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "large_df.head()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Of course there's also a `tail()` function to view the bottom 5 rows. You can pass the number of rows you want:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "      <th>C</th>\n",
       "      <th>some_text</th>\n",
       "      <th>D</th>\n",
       "      <th>E</th>\n",
       "      <th>F</th>\n",
       "      <th>G</th>\n",
       "      <th>H</th>\n",
       "      <th>I</th>\n",
       "      <th>...</th>\n",
       "      <th>Q</th>\n",
       "      <th>R</th>\n",
       "      <th>S</th>\n",
       "      <th>T</th>\n",
       "      <th>U</th>\n",
       "      <th>V</th>\n",
       "      <th>W</th>\n",
       "      <th>X</th>\n",
       "      <th>Y</th>\n",
       "      <th>Z</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>9998</th>\n",
       "      <td>22.0</td>\n",
       "      <td>33.0</td>\n",
       "      <td>66.0</td>\n",
       "      <td>Blabla</td>\n",
       "      <td>121.0</td>\n",
       "      <td>11.0</td>\n",
       "      <td>110.0</td>\n",
       "      <td>44.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>165.0</td>\n",
       "      <td>...</td>\n",
       "      <td>33.0</td>\n",
       "      <td>22.0</td>\n",
       "      <td>33.0</td>\n",
       "      <td>66.0</td>\n",
       "      <td>121.0</td>\n",
       "      <td>11.0</td>\n",
       "      <td>110.0</td>\n",
       "      <td>44.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>165.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9999</th>\n",
       "      <td>33.0</td>\n",
       "      <td>44.0</td>\n",
       "      <td>77.0</td>\n",
       "      <td>Blabla</td>\n",
       "      <td>132.0</td>\n",
       "      <td>22.0</td>\n",
       "      <td>121.0</td>\n",
       "      <td>55.0</td>\n",
       "      <td>11.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>...</td>\n",
       "      <td>44.0</td>\n",
       "      <td>33.0</td>\n",
       "      <td>44.0</td>\n",
       "      <td>77.0</td>\n",
       "      <td>132.0</td>\n",
       "      <td>22.0</td>\n",
       "      <td>121.0</td>\n",
       "      <td>55.0</td>\n",
       "      <td>11.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>2 rows × 27 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "         A     B     C some_text      D     E      F     G     H      I  ...  \\\n",
       "9998  22.0  33.0  66.0    Blabla  121.0  11.0  110.0  44.0   NaN  165.0  ...   \n",
       "9999  33.0  44.0  77.0    Blabla  132.0  22.0  121.0  55.0  11.0    NaN  ...   \n",
       "\n",
       "         Q     R     S     T      U     V      W     X     Y      Z  \n",
       "9998  33.0  22.0  33.0  66.0  121.0  11.0  110.0  44.0   NaN  165.0  \n",
       "9999  44.0  33.0  44.0  77.0  132.0  22.0  121.0  55.0  11.0    NaN  \n",
       "\n",
       "[2 rows x 27 columns]"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "large_df.tail(n=2)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `info()` method prints out a summary of each columns contents:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 10000 entries, 0 to 9999\n",
      "Data columns (total 27 columns):\n",
      " #   Column     Non-Null Count  Dtype  \n",
      "---  ------     --------------  -----  \n",
      " 0   A          8823 non-null   float64\n",
      " 1   B          8824 non-null   float64\n",
      " 2   C          8824 non-null   float64\n",
      " 3   some_text  10000 non-null  object \n",
      " 4   D          8824 non-null   float64\n",
      " 5   E          8822 non-null   float64\n",
      " 6   F          8824 non-null   float64\n",
      " 7   G          8824 non-null   float64\n",
      " 8   H          8822 non-null   float64\n",
      " 9   I          8823 non-null   float64\n",
      " 10  J          8823 non-null   float64\n",
      " 11  K          8822 non-null   float64\n",
      " 12  L          8824 non-null   float64\n",
      " 13  M          8824 non-null   float64\n",
      " 14  N          8822 non-null   float64\n",
      " 15  O          8824 non-null   float64\n",
      " 16  P          8824 non-null   float64\n",
      " 17  Q          8824 non-null   float64\n",
      " 18  R          8823 non-null   float64\n",
      " 19  S          8824 non-null   float64\n",
      " 20  T          8824 non-null   float64\n",
      " 21  U          8824 non-null   float64\n",
      " 22  V          8822 non-null   float64\n",
      " 23  W          8824 non-null   float64\n",
      " 24  X          8824 non-null   float64\n",
      " 25  Y          8822 non-null   float64\n",
      " 26  Z          8823 non-null   float64\n",
      "dtypes: float64(26), object(1)\n",
      "memory usage: 2.1+ MB\n"
     ]
    }
   ],
   "source": [
    "large_df.info()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, the `describe()` method gives a nice overview of the main aggregated values over each column:\n",
    "* `count`: number of non-null (not NaN) values\n",
    "* `mean`: mean of non-null values\n",
    "* `std`: [standard deviation](https://en.wikipedia.org/wiki/Standard_deviation) of non-null values\n",
    "* `min`: minimum of non-null values\n",
    "* `25%`, `50%`, `75%`: 25th, 50th and 75th [percentile](https://en.wikipedia.org/wiki/Percentile) of non-null values\n",
    "* `max`: maximum of non-null values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "      <th>C</th>\n",
       "      <th>D</th>\n",
       "      <th>E</th>\n",
       "      <th>F</th>\n",
       "      <th>G</th>\n",
       "      <th>H</th>\n",
       "      <th>I</th>\n",
       "      <th>J</th>\n",
       "      <th>...</th>\n",
       "      <th>Q</th>\n",
       "      <th>R</th>\n",
       "      <th>S</th>\n",
       "      <th>T</th>\n",
       "      <th>U</th>\n",
       "      <th>V</th>\n",
       "      <th>W</th>\n",
       "      <th>X</th>\n",
       "      <th>Y</th>\n",
       "      <th>Z</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>count</th>\n",
       "      <td>8823.000000</td>\n",
       "      <td>8824.000000</td>\n",
       "      <td>8824.000000</td>\n",
       "      <td>8824.000000</td>\n",
       "      <td>8822.000000</td>\n",
       "      <td>8824.000000</td>\n",
       "      <td>8824.000000</td>\n",
       "      <td>8822.000000</td>\n",
       "      <td>8823.000000</td>\n",
       "      <td>8823.000000</td>\n",
       "      <td>...</td>\n",
       "      <td>8824.000000</td>\n",
       "      <td>8823.000000</td>\n",
       "      <td>8824.000000</td>\n",
       "      <td>8824.000000</td>\n",
       "      <td>8824.000000</td>\n",
       "      <td>8822.000000</td>\n",
       "      <td>8824.000000</td>\n",
       "      <td>8824.000000</td>\n",
       "      <td>8822.000000</td>\n",
       "      <td>8823.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mean</th>\n",
       "      <td>87.977559</td>\n",
       "      <td>87.972575</td>\n",
       "      <td>87.987534</td>\n",
       "      <td>88.012466</td>\n",
       "      <td>87.983791</td>\n",
       "      <td>88.007480</td>\n",
       "      <td>87.977561</td>\n",
       "      <td>88.000000</td>\n",
       "      <td>88.022441</td>\n",
       "      <td>88.022441</td>\n",
       "      <td>...</td>\n",
       "      <td>87.972575</td>\n",
       "      <td>87.977559</td>\n",
       "      <td>87.972575</td>\n",
       "      <td>87.987534</td>\n",
       "      <td>88.012466</td>\n",
       "      <td>87.983791</td>\n",
       "      <td>88.007480</td>\n",
       "      <td>87.977561</td>\n",
       "      <td>88.000000</td>\n",
       "      <td>88.022441</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>std</th>\n",
       "      <td>47.535911</td>\n",
       "      <td>47.535523</td>\n",
       "      <td>47.521679</td>\n",
       "      <td>47.521679</td>\n",
       "      <td>47.535001</td>\n",
       "      <td>47.519371</td>\n",
       "      <td>47.529755</td>\n",
       "      <td>47.536879</td>\n",
       "      <td>47.535911</td>\n",
       "      <td>47.535911</td>\n",
       "      <td>...</td>\n",
       "      <td>47.535523</td>\n",
       "      <td>47.535911</td>\n",
       "      <td>47.535523</td>\n",
       "      <td>47.521679</td>\n",
       "      <td>47.521679</td>\n",
       "      <td>47.535001</td>\n",
       "      <td>47.519371</td>\n",
       "      <td>47.529755</td>\n",
       "      <td>47.536879</td>\n",
       "      <td>47.535911</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>min</th>\n",
       "      <td>11.000000</td>\n",
       "      <td>11.000000</td>\n",
       "      <td>11.000000</td>\n",
       "      <td>11.000000</td>\n",
       "      <td>11.000000</td>\n",
       "      <td>11.000000</td>\n",
       "      <td>11.000000</td>\n",
       "      <td>11.000000</td>\n",
       "      <td>11.000000</td>\n",
       "      <td>11.000000</td>\n",
       "      <td>...</td>\n",
       "      <td>11.000000</td>\n",
       "      <td>11.000000</td>\n",
       "      <td>11.000000</td>\n",
       "      <td>11.000000</td>\n",
       "      <td>11.000000</td>\n",
       "      <td>11.000000</td>\n",
       "      <td>11.000000</td>\n",
       "      <td>11.000000</td>\n",
       "      <td>11.000000</td>\n",
       "      <td>11.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25%</th>\n",
       "      <td>44.000000</td>\n",
       "      <td>44.000000</td>\n",
       "      <td>44.000000</td>\n",
       "      <td>44.000000</td>\n",
       "      <td>44.000000</td>\n",
       "      <td>44.000000</td>\n",
       "      <td>44.000000</td>\n",
       "      <td>44.000000</td>\n",
       "      <td>44.000000</td>\n",
       "      <td>44.000000</td>\n",
       "      <td>...</td>\n",
       "      <td>44.000000</td>\n",
       "      <td>44.000000</td>\n",
       "      <td>44.000000</td>\n",
       "      <td>44.000000</td>\n",
       "      <td>44.000000</td>\n",
       "      <td>44.000000</td>\n",
       "      <td>44.000000</td>\n",
       "      <td>44.000000</td>\n",
       "      <td>44.000000</td>\n",
       "      <td>44.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50%</th>\n",
       "      <td>88.000000</td>\n",
       "      <td>88.000000</td>\n",
       "      <td>88.000000</td>\n",
       "      <td>88.000000</td>\n",
       "      <td>88.000000</td>\n",
       "      <td>88.000000</td>\n",
       "      <td>88.000000</td>\n",
       "      <td>88.000000</td>\n",
       "      <td>88.000000</td>\n",
       "      <td>88.000000</td>\n",
       "      <td>...</td>\n",
       "      <td>88.000000</td>\n",
       "      <td>88.000000</td>\n",
       "      <td>88.000000</td>\n",
       "      <td>88.000000</td>\n",
       "      <td>88.000000</td>\n",
       "      <td>88.000000</td>\n",
       "      <td>88.000000</td>\n",
       "      <td>88.000000</td>\n",
       "      <td>88.000000</td>\n",
       "      <td>88.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75%</th>\n",
       "      <td>132.000000</td>\n",
       "      <td>132.000000</td>\n",
       "      <td>132.000000</td>\n",
       "      <td>132.000000</td>\n",
       "      <td>132.000000</td>\n",
       "      <td>132.000000</td>\n",
       "      <td>132.000000</td>\n",
       "      <td>132.000000</td>\n",
       "      <td>132.000000</td>\n",
       "      <td>132.000000</td>\n",
       "      <td>...</td>\n",
       "      <td>132.000000</td>\n",
       "      <td>132.000000</td>\n",
       "      <td>132.000000</td>\n",
       "      <td>132.000000</td>\n",
       "      <td>132.000000</td>\n",
       "      <td>132.000000</td>\n",
       "      <td>132.000000</td>\n",
       "      <td>132.000000</td>\n",
       "      <td>132.000000</td>\n",
       "      <td>132.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>max</th>\n",
       "      <td>165.000000</td>\n",
       "      <td>165.000000</td>\n",
       "      <td>165.000000</td>\n",
       "      <td>165.000000</td>\n",
       "      <td>165.000000</td>\n",
       "      <td>165.000000</td>\n",
       "      <td>165.000000</td>\n",
       "      <td>165.000000</td>\n",
       "      <td>165.000000</td>\n",
       "      <td>165.000000</td>\n",
       "      <td>...</td>\n",
       "      <td>165.000000</td>\n",
       "      <td>165.000000</td>\n",
       "      <td>165.000000</td>\n",
       "      <td>165.000000</td>\n",
       "      <td>165.000000</td>\n",
       "      <td>165.000000</td>\n",
       "      <td>165.000000</td>\n",
       "      <td>165.000000</td>\n",
       "      <td>165.000000</td>\n",
       "      <td>165.000000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>8 rows × 26 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "                 A            B            C            D            E  \\\n",
       "count  8823.000000  8824.000000  8824.000000  8824.000000  8822.000000   \n",
       "mean     87.977559    87.972575    87.987534    88.012466    87.983791   \n",
       "std      47.535911    47.535523    47.521679    47.521679    47.535001   \n",
       "min      11.000000    11.000000    11.000000    11.000000    11.000000   \n",
       "25%      44.000000    44.000000    44.000000    44.000000    44.000000   \n",
       "50%      88.000000    88.000000    88.000000    88.000000    88.000000   \n",
       "75%     132.000000   132.000000   132.000000   132.000000   132.000000   \n",
       "max     165.000000   165.000000   165.000000   165.000000   165.000000   \n",
       "\n",
       "                 F            G            H            I            J  ...  \\\n",
       "count  8824.000000  8824.000000  8822.000000  8823.000000  8823.000000  ...   \n",
       "mean     88.007480    87.977561    88.000000    88.022441    88.022441  ...   \n",
       "std      47.519371    47.529755    47.536879    47.535911    47.535911  ...   \n",
       "min      11.000000    11.000000    11.000000    11.000000    11.000000  ...   \n",
       "25%      44.000000    44.000000    44.000000    44.000000    44.000000  ...   \n",
       "50%      88.000000    88.000000    88.000000    88.000000    88.000000  ...   \n",
       "75%     132.000000   132.000000   132.000000   132.000000   132.000000  ...   \n",
       "max     165.000000   165.000000   165.000000   165.000000   165.000000  ...   \n",
       "\n",
       "                 Q            R            S            T            U  \\\n",
       "count  8824.000000  8823.000000  8824.000000  8824.000000  8824.000000   \n",
       "mean     87.972575    87.977559    87.972575    87.987534    88.012466   \n",
       "std      47.535523    47.535911    47.535523    47.521679    47.521679   \n",
       "min      11.000000    11.000000    11.000000    11.000000    11.000000   \n",
       "25%      44.000000    44.000000    44.000000    44.000000    44.000000   \n",
       "50%      88.000000    88.000000    88.000000    88.000000    88.000000   \n",
       "75%     132.000000   132.000000   132.000000   132.000000   132.000000   \n",
       "max     165.000000   165.000000   165.000000   165.000000   165.000000   \n",
       "\n",
       "                 V            W            X            Y            Z  \n",
       "count  8822.000000  8824.000000  8824.000000  8822.000000  8823.000000  \n",
       "mean     87.983791    88.007480    87.977561    88.000000    88.022441  \n",
       "std      47.535001    47.519371    47.529755    47.536879    47.535911  \n",
       "min      11.000000    11.000000    11.000000    11.000000    11.000000  \n",
       "25%      44.000000    44.000000    44.000000    44.000000    44.000000  \n",
       "50%      88.000000    88.000000    88.000000    88.000000    88.000000  \n",
       "75%     132.000000   132.000000   132.000000   132.000000   132.000000  \n",
       "max     165.000000   165.000000   165.000000   165.000000   165.000000  \n",
       "\n",
       "[8 rows x 26 columns]"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "large_df.describe()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Saving & loading\n",
    "Pandas can save `DataFrame`s to various backends, including file formats such as CSV, Excel, JSON, HTML and HDF5, or to a SQL database. Let's create a `DataFrame` to demonstrate this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>hobby</th>\n",
       "      <th>weight</th>\n",
       "      <th>birthyear</th>\n",
       "      <th>children</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Aman</th>\n",
       "      <td>Biking</td>\n",
       "      <td>68.5</td>\n",
       "      <td>1985</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Lav</th>\n",
       "      <td>Dancing</td>\n",
       "      <td>83.1</td>\n",
       "      <td>1984</td>\n",
       "      <td>3.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        hobby  weight  birthyear  children\n",
       "Aman   Biking    68.5       1985       NaN\n",
       "Lav   Dancing    83.1       1984       3.0"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_df = pd.DataFrame(\n",
    "    [[\"Biking\", 68.5, 1985, np.nan], [\"Dancing\", 83.1, 1984, 3]],\n",
    "    columns=[\"hobby\", \"weight\", \"birthyear\", \"children\"],\n",
    "    index=[\"Aman\", \"Lav\"]\n",
    ")\n",
    "my_df"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Saving\n",
    "Let's save it to CSV, HTML and JSON:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_df.to_csv(\"my_df.csv\")\n",
    "my_df.to_html(\"my_df.html\")\n",
    "my_df.to_json(\"my_df.json\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Done Lets Look at What is Saved."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# my_df.csv\n",
      ",hobby,weight,birthyear,children\n",
      "Aman,Biking,68.5,1985,\n",
      "Lav,Dancing,83.1,1984,3.0\n",
      "\n",
      "\n",
      "# my_df.html\n",
      "<table border=\"1\" class=\"dataframe\">\n",
      "  <thead>\n",
      "    <tr style=\"text-align: right;\">\n",
      "      <th></th>\n",
      "      <th>hobby</th>\n",
      "      <th>weight</th>\n",
      "      <th>birthyear</th>\n",
      "      <th>children</th>\n",
      "    </tr>\n",
      "  </thead>\n",
      "  <tbody>\n",
      "    <tr>\n",
      "      <th>Aman</th>\n",
      "      <td>Biking</td>\n",
      "      <td>68.5</td>\n",
      "      <td>1985</td>\n",
      "      <td>NaN</td>\n",
      "    </tr>\n",
      "    <tr>\n",
      "      <th>Lav</th>\n",
      "      <td>Dancing</td>\n",
      "      <td>83.1</td>\n",
      "      <td>1984</td>\n",
      "      <td>3.0</td>\n",
      "    </tr>\n",
      "  </tbody>\n",
      "</table>\n",
      "\n",
      "# my_df.json\n",
      "{\"hobby\":{\"Aman\":\"Biking\",\"Lav\":\"Dancing\"},\"weight\":{\"Aman\":68.5,\"Lav\":83.1},\"birthyear\":{\"Aman\":1985,\"Lav\":1984},\"children\":{\"Aman\":null,\"Lav\":3.0}}\n",
      "\n"
     ]
    }
   ],
   "source": [
    "for filename in (\"my_df.csv\", \"my_df.html\", \"my_df.json\"):\n",
    "    print(\"#\", filename)\n",
    "    with open(filename, \"rt\") as f:\n",
    "        print(f.read())\n",
    "        print()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the index is saved as the first column (with no name) in a CSV file, as `<th>` tags in HTML and as keys in JSON.\n",
    "\n",
    "Saving to other formats works very similarly, but some formats require extra libraries to be installed. For example, saving to Excel requires the openpyxl library:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No module named 'openpyxl'\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    my_df.to_excel(\"my_df.xlsx\", sheet_name='People')\n",
    "except ImportError as e:\n",
    "    print(e)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loading\n",
    "Now let's load our CSV file back into a `DataFrame`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>hobby</th>\n",
       "      <th>weight</th>\n",
       "      <th>birthyear</th>\n",
       "      <th>children</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Aman</th>\n",
       "      <td>Biking</td>\n",
       "      <td>68.5</td>\n",
       "      <td>1985</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Lav</th>\n",
       "      <td>Dancing</td>\n",
       "      <td>83.1</td>\n",
       "      <td>1984</td>\n",
       "      <td>3.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        hobby  weight  birthyear  children\n",
       "Aman   Biking    68.5       1985       NaN\n",
       "Lav   Dancing    83.1       1984       3.0"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_df_loaded = pd.read_csv(\"my_df.csv\", index_col=0)\n",
    "my_df_loaded"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you might guess, there are similar `read_json`, `read_html`, `read_excel` functions as well.  We can also read data straight from the Internet. For example, let's load the top 1,000 U.S. cities from github:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>State</th>\n",
       "      <th>Population</th>\n",
       "      <th>lat</th>\n",
       "      <th>lon</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>City</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Marysville</th>\n",
       "      <td>Washington</td>\n",
       "      <td>63269</td>\n",
       "      <td>48.051764</td>\n",
       "      <td>-122.177082</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Perris</th>\n",
       "      <td>California</td>\n",
       "      <td>72326</td>\n",
       "      <td>33.782519</td>\n",
       "      <td>-117.228648</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Cleveland</th>\n",
       "      <td>Ohio</td>\n",
       "      <td>390113</td>\n",
       "      <td>41.499320</td>\n",
       "      <td>-81.694361</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Worcester</th>\n",
       "      <td>Massachusetts</td>\n",
       "      <td>182544</td>\n",
       "      <td>42.262593</td>\n",
       "      <td>-71.802293</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Columbia</th>\n",
       "      <td>South Carolina</td>\n",
       "      <td>133358</td>\n",
       "      <td>34.000710</td>\n",
       "      <td>-81.034814</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                     State  Population        lat         lon\n",
       "City                                                         \n",
       "Marysville      Washington       63269  48.051764 -122.177082\n",
       "Perris          California       72326  33.782519 -117.228648\n",
       "Cleveland             Ohio      390113  41.499320  -81.694361\n",
       "Worcester    Massachusetts      182544  42.262593  -71.802293\n",
       "Columbia    South Carolina      133358  34.000710  -81.034814"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "us_cities = None\n",
    "try:\n",
    "    csv_url = \"https://raw.githubusercontent.com/plotly/datasets/master/us-cities-top-1k.csv\"\n",
    "    us_cities = pd.read_csv(csv_url, index_col=0)\n",
    "    us_cities = us_cities.head()\n",
    "except IOError as e:\n",
    "    print(e)\n",
    "us_cities"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are more options available, in particular regarding datetime format. Check out the [documentation](http://pandas.pydata.org/pandas-docs/stable/io.html) for more details."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Combining `DataFrame`s\n",
    "\n",
    "## SQL-like joins\n",
    "One powerful feature of pandas is it's ability to perform SQL-like joins on `DataFrame`s. Various types of joins are supported: inner joins, left/right outer joins and full joins. To illustrate this, let's start by creating a couple simple `DataFrame`s:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>state</th>\n",
       "      <th>city</th>\n",
       "      <th>lat</th>\n",
       "      <th>lng</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>CA</td>\n",
       "      <td>San Francisco</td>\n",
       "      <td>37.781334</td>\n",
       "      <td>-122.416728</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>NY</td>\n",
       "      <td>New York</td>\n",
       "      <td>40.705649</td>\n",
       "      <td>-74.008344</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>FL</td>\n",
       "      <td>Miami</td>\n",
       "      <td>25.791100</td>\n",
       "      <td>-80.320733</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>OH</td>\n",
       "      <td>Cleveland</td>\n",
       "      <td>41.473508</td>\n",
       "      <td>-81.739791</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>UT</td>\n",
       "      <td>Salt Lake City</td>\n",
       "      <td>40.755851</td>\n",
       "      <td>-111.896657</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  state            city        lat         lng\n",
       "0    CA   San Francisco  37.781334 -122.416728\n",
       "1    NY        New York  40.705649  -74.008344\n",
       "2    FL           Miami  25.791100  -80.320733\n",
       "3    OH       Cleveland  41.473508  -81.739791\n",
       "4    UT  Salt Lake City  40.755851 -111.896657"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "city_loc = pd.DataFrame(\n",
    "    [\n",
    "        [\"CA\", \"San Francisco\", 37.781334, -122.416728],\n",
    "        [\"NY\", \"New York\", 40.705649, -74.008344],\n",
    "        [\"FL\", \"Miami\", 25.791100, -80.320733],\n",
    "        [\"OH\", \"Cleveland\", 41.473508, -81.739791],\n",
    "        [\"UT\", \"Salt Lake City\", 40.755851, -111.896657]\n",
    "    ], columns=[\"state\", \"city\", \"lat\", \"lng\"])\n",
    "city_loc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>population</th>\n",
       "      <th>city</th>\n",
       "      <th>state</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>808976</td>\n",
       "      <td>San Francisco</td>\n",
       "      <td>California</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>8363710</td>\n",
       "      <td>New York</td>\n",
       "      <td>New-York</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>413201</td>\n",
       "      <td>Miami</td>\n",
       "      <td>Florida</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>2242193</td>\n",
       "      <td>Houston</td>\n",
       "      <td>Texas</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   population           city       state\n",
       "3      808976  San Francisco  California\n",
       "4     8363710       New York    New-York\n",
       "5      413201          Miami     Florida\n",
       "6     2242193        Houston       Texas"
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "city_pop = pd.DataFrame(\n",
    "    [\n",
    "        [808976, \"San Francisco\", \"California\"],\n",
    "        [8363710, \"New York\", \"New-York\"],\n",
    "        [413201, \"Miami\", \"Florida\"],\n",
    "        [2242193, \"Houston\", \"Texas\"]\n",
    "    ], index=[3,4,5,6], columns=[\"population\", \"city\", \"state\"])\n",
    "city_pop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's join these `DataFrame`s using the `merge()` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>state_x</th>\n",
       "      <th>city</th>\n",
       "      <th>lat</th>\n",
       "      <th>lng</th>\n",
       "      <th>population</th>\n",
       "      <th>state_y</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>CA</td>\n",
       "      <td>San Francisco</td>\n",
       "      <td>37.781334</td>\n",
       "      <td>-122.416728</td>\n",
       "      <td>808976</td>\n",
       "      <td>California</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>NY</td>\n",
       "      <td>New York</td>\n",
       "      <td>40.705649</td>\n",
       "      <td>-74.008344</td>\n",
       "      <td>8363710</td>\n",
       "      <td>New-York</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>FL</td>\n",
       "      <td>Miami</td>\n",
       "      <td>25.791100</td>\n",
       "      <td>-80.320733</td>\n",
       "      <td>413201</td>\n",
       "      <td>Florida</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  state_x           city        lat         lng  population     state_y\n",
       "0      CA  San Francisco  37.781334 -122.416728      808976  California\n",
       "1      NY       New York  40.705649  -74.008344     8363710    New-York\n",
       "2      FL          Miami  25.791100  -80.320733      413201     Florida"
      ]
     },
     "execution_count": 145,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.merge(left=city_loc, right=city_pop, on=\"city\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that both `DataFrame`s have a column named `state`, so in the result they got renamed to `state_x` and `state_y`.\n",
    "\n",
    "Also, note that Cleveland, Salt Lake City and Houston were dropped because they don't exist in *both* `DataFrame`s. This is the equivalent of a SQL `INNER JOIN`. If you want a `FULL OUTER JOIN`, where no city gets dropped and `NaN` values are added, you must specify `how=\"outer\"`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>state_x</th>\n",
       "      <th>city</th>\n",
       "      <th>lat</th>\n",
       "      <th>lng</th>\n",
       "      <th>population</th>\n",
       "      <th>state_y</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>CA</td>\n",
       "      <td>San Francisco</td>\n",
       "      <td>37.781334</td>\n",
       "      <td>-122.416728</td>\n",
       "      <td>808976.0</td>\n",
       "      <td>California</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>NY</td>\n",
       "      <td>New York</td>\n",
       "      <td>40.705649</td>\n",
       "      <td>-74.008344</td>\n",
       "      <td>8363710.0</td>\n",
       "      <td>New-York</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>FL</td>\n",
       "      <td>Miami</td>\n",
       "      <td>25.791100</td>\n",
       "      <td>-80.320733</td>\n",
       "      <td>413201.0</td>\n",
       "      <td>Florida</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>OH</td>\n",
       "      <td>Cleveland</td>\n",
       "      <td>41.473508</td>\n",
       "      <td>-81.739791</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>UT</td>\n",
       "      <td>Salt Lake City</td>\n",
       "      <td>40.755851</td>\n",
       "      <td>-111.896657</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>NaN</td>\n",
       "      <td>Houston</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>2242193.0</td>\n",
       "      <td>Texas</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  state_x            city        lat         lng  population     state_y\n",
       "0      CA   San Francisco  37.781334 -122.416728    808976.0  California\n",
       "1      NY        New York  40.705649  -74.008344   8363710.0    New-York\n",
       "2      FL           Miami  25.791100  -80.320733    413201.0     Florida\n",
       "3      OH       Cleveland  41.473508  -81.739791         NaN         NaN\n",
       "4      UT  Salt Lake City  40.755851 -111.896657         NaN         NaN\n",
       "5     NaN         Houston        NaN         NaN   2242193.0       Texas"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "all_cities = pd.merge(left=city_loc, right=city_pop, on=\"city\", how=\"outer\")\n",
    "all_cities"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Of course `LEFT OUTER JOIN` is also available by setting `how=\"left\"`: only the cities present in the left `DataFrame` end up in the result. Similarly, with `how=\"right\"` only cities in the right `DataFrame` appear in the result. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>state_x</th>\n",
       "      <th>city</th>\n",
       "      <th>lat</th>\n",
       "      <th>lng</th>\n",
       "      <th>population</th>\n",
       "      <th>state_y</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>CA</td>\n",
       "      <td>San Francisco</td>\n",
       "      <td>37.781334</td>\n",
       "      <td>-122.416728</td>\n",
       "      <td>808976</td>\n",
       "      <td>California</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>NY</td>\n",
       "      <td>New York</td>\n",
       "      <td>40.705649</td>\n",
       "      <td>-74.008344</td>\n",
       "      <td>8363710</td>\n",
       "      <td>New-York</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>FL</td>\n",
       "      <td>Miami</td>\n",
       "      <td>25.791100</td>\n",
       "      <td>-80.320733</td>\n",
       "      <td>413201</td>\n",
       "      <td>Florida</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>NaN</td>\n",
       "      <td>Houston</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>2242193</td>\n",
       "      <td>Texas</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  state_x           city        lat         lng  population     state_y\n",
       "0      CA  San Francisco  37.781334 -122.416728      808976  California\n",
       "1      NY       New York  40.705649  -74.008344     8363710    New-York\n",
       "2      FL          Miami  25.791100  -80.320733      413201     Florida\n",
       "3     NaN        Houston        NaN         NaN     2242193       Texas"
      ]
     },
     "execution_count": 147,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.merge(left=city_loc, right=city_pop, on=\"city\", how=\"right\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If the key to join on is actually in one (or both) `DataFrame`'s index, you must use `left_index=True` and/or `right_index=True`. If the key column names differ, you must use `left_on` and `right_on`. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>state_x</th>\n",
       "      <th>city</th>\n",
       "      <th>lat</th>\n",
       "      <th>lng</th>\n",
       "      <th>population</th>\n",
       "      <th>name</th>\n",
       "      <th>state_y</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>CA</td>\n",
       "      <td>San Francisco</td>\n",
       "      <td>37.781334</td>\n",
       "      <td>-122.416728</td>\n",
       "      <td>808976</td>\n",
       "      <td>San Francisco</td>\n",
       "      <td>California</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>NY</td>\n",
       "      <td>New York</td>\n",
       "      <td>40.705649</td>\n",
       "      <td>-74.008344</td>\n",
       "      <td>8363710</td>\n",
       "      <td>New York</td>\n",
       "      <td>New-York</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>FL</td>\n",
       "      <td>Miami</td>\n",
       "      <td>25.791100</td>\n",
       "      <td>-80.320733</td>\n",
       "      <td>413201</td>\n",
       "      <td>Miami</td>\n",
       "      <td>Florida</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  state_x           city        lat         lng  population           name  \\\n",
       "0      CA  San Francisco  37.781334 -122.416728      808976  San Francisco   \n",
       "1      NY       New York  40.705649  -74.008344     8363710       New York   \n",
       "2      FL          Miami  25.791100  -80.320733      413201          Miami   \n",
       "\n",
       "      state_y  \n",
       "0  California  \n",
       "1    New-York  \n",
       "2     Florida  "
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "city_pop2 = city_pop.copy()\n",
    "city_pop2.columns = [\"population\", \"name\", \"state\"]\n",
    "pd.merge(left=city_loc, right=city_pop2, left_on=\"city\", right_on=\"name\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Concatenation\n",
    "Rather than joining `DataFrame`s, we may just want to concatenate them. That's what `concat()` is for:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>state</th>\n",
       "      <th>city</th>\n",
       "      <th>lat</th>\n",
       "      <th>lng</th>\n",
       "      <th>population</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>CA</td>\n",
       "      <td>San Francisco</td>\n",
       "      <td>37.781334</td>\n",
       "      <td>-122.416728</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>NY</td>\n",
       "      <td>New York</td>\n",
       "      <td>40.705649</td>\n",
       "      <td>-74.008344</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>FL</td>\n",
       "      <td>Miami</td>\n",
       "      <td>25.791100</td>\n",
       "      <td>-80.320733</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>OH</td>\n",
       "      <td>Cleveland</td>\n",
       "      <td>41.473508</td>\n",
       "      <td>-81.739791</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>UT</td>\n",
       "      <td>Salt Lake City</td>\n",
       "      <td>40.755851</td>\n",
       "      <td>-111.896657</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>California</td>\n",
       "      <td>San Francisco</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>808976.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>New-York</td>\n",
       "      <td>New York</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>8363710.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Florida</td>\n",
       "      <td>Miami</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>413201.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>Texas</td>\n",
       "      <td>Houston</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>2242193.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        state            city        lat         lng  population\n",
       "0          CA   San Francisco  37.781334 -122.416728         NaN\n",
       "1          NY        New York  40.705649  -74.008344         NaN\n",
       "2          FL           Miami  25.791100  -80.320733         NaN\n",
       "3          OH       Cleveland  41.473508  -81.739791         NaN\n",
       "4          UT  Salt Lake City  40.755851 -111.896657         NaN\n",
       "3  California   San Francisco        NaN         NaN    808976.0\n",
       "4    New-York        New York        NaN         NaN   8363710.0\n",
       "5     Florida           Miami        NaN         NaN    413201.0\n",
       "6       Texas         Houston        NaN         NaN   2242193.0"
      ]
     },
     "execution_count": 149,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result_concat = pd.concat([city_loc, city_pop])\n",
    "result_concat"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that this operation aligned the data horizontally (by columns) but not vertically (by rows). In this example, we end up with multiple rows having the same index (eg. 3). Pandas handles this rather gracefully:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>state</th>\n",
       "      <th>city</th>\n",
       "      <th>lat</th>\n",
       "      <th>lng</th>\n",
       "      <th>population</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>OH</td>\n",
       "      <td>Cleveland</td>\n",
       "      <td>41.473508</td>\n",
       "      <td>-81.739791</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>California</td>\n",
       "      <td>San Francisco</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>808976.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        state           city        lat        lng  population\n",
       "3          OH      Cleveland  41.473508 -81.739791         NaN\n",
       "3  California  San Francisco        NaN        NaN    808976.0"
      ]
     },
     "execution_count": 150,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result_concat.loc[3]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or you can tell pandas to just ignore the index:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>state</th>\n",
       "      <th>city</th>\n",
       "      <th>lat</th>\n",
       "      <th>lng</th>\n",
       "      <th>population</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>CA</td>\n",
       "      <td>San Francisco</td>\n",
       "      <td>37.781334</td>\n",
       "      <td>-122.416728</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>NY</td>\n",
       "      <td>New York</td>\n",
       "      <td>40.705649</td>\n",
       "      <td>-74.008344</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>FL</td>\n",
       "      <td>Miami</td>\n",
       "      <td>25.791100</td>\n",
       "      <td>-80.320733</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>OH</td>\n",
       "      <td>Cleveland</td>\n",
       "      <td>41.473508</td>\n",
       "      <td>-81.739791</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>UT</td>\n",
       "      <td>Salt Lake City</td>\n",
       "      <td>40.755851</td>\n",
       "      <td>-111.896657</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>California</td>\n",
       "      <td>San Francisco</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>808976.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>New-York</td>\n",
       "      <td>New York</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>8363710.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>Florida</td>\n",
       "      <td>Miami</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>413201.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>Texas</td>\n",
       "      <td>Houston</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>2242193.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        state            city        lat         lng  population\n",
       "0          CA   San Francisco  37.781334 -122.416728         NaN\n",
       "1          NY        New York  40.705649  -74.008344         NaN\n",
       "2          FL           Miami  25.791100  -80.320733         NaN\n",
       "3          OH       Cleveland  41.473508  -81.739791         NaN\n",
       "4          UT  Salt Lake City  40.755851 -111.896657         NaN\n",
       "5  California   San Francisco        NaN         NaN    808976.0\n",
       "6    New-York        New York        NaN         NaN   8363710.0\n",
       "7     Florida           Miami        NaN         NaN    413201.0\n",
       "8       Texas         Houston        NaN         NaN   2242193.0"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.concat([city_loc, city_pop], ignore_index=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that when a column does not exist in a `DataFrame`, it acts as if it was filled with `NaN` values. If we set `join=\"inner\"`, then only columns that exist in *both* `DataFrame`s are returned:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>state</th>\n",
       "      <th>city</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>CA</td>\n",
       "      <td>San Francisco</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>NY</td>\n",
       "      <td>New York</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>FL</td>\n",
       "      <td>Miami</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>OH</td>\n",
       "      <td>Cleveland</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>UT</td>\n",
       "      <td>Salt Lake City</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>California</td>\n",
       "      <td>San Francisco</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>New-York</td>\n",
       "      <td>New York</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Florida</td>\n",
       "      <td>Miami</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>Texas</td>\n",
       "      <td>Houston</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        state            city\n",
       "0          CA   San Francisco\n",
       "1          NY        New York\n",
       "2          FL           Miami\n",
       "3          OH       Cleveland\n",
       "4          UT  Salt Lake City\n",
       "3  California   San Francisco\n",
       "4    New-York        New York\n",
       "5     Florida           Miami\n",
       "6       Texas         Houston"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.concat([city_loc, city_pop], join=\"inner\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can concatenate `DataFrame`s horizontally instead of vertically by setting `axis=1`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>state</th>\n",
       "      <th>city</th>\n",
       "      <th>lat</th>\n",
       "      <th>lng</th>\n",
       "      <th>population</th>\n",
       "      <th>city</th>\n",
       "      <th>state</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>CA</td>\n",
       "      <td>San Francisco</td>\n",
       "      <td>37.781334</td>\n",
       "      <td>-122.416728</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>NY</td>\n",
       "      <td>New York</td>\n",
       "      <td>40.705649</td>\n",
       "      <td>-74.008344</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>FL</td>\n",
       "      <td>Miami</td>\n",
       "      <td>25.791100</td>\n",
       "      <td>-80.320733</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>OH</td>\n",
       "      <td>Cleveland</td>\n",
       "      <td>41.473508</td>\n",
       "      <td>-81.739791</td>\n",
       "      <td>808976.0</td>\n",
       "      <td>San Francisco</td>\n",
       "      <td>California</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>UT</td>\n",
       "      <td>Salt Lake City</td>\n",
       "      <td>40.755851</td>\n",
       "      <td>-111.896657</td>\n",
       "      <td>8363710.0</td>\n",
       "      <td>New York</td>\n",
       "      <td>New-York</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>413201.0</td>\n",
       "      <td>Miami</td>\n",
       "      <td>Florida</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>2242193.0</td>\n",
       "      <td>Houston</td>\n",
       "      <td>Texas</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  state            city        lat         lng  population           city  \\\n",
       "0    CA   San Francisco  37.781334 -122.416728         NaN            NaN   \n",
       "1    NY        New York  40.705649  -74.008344         NaN            NaN   \n",
       "2    FL           Miami  25.791100  -80.320733         NaN            NaN   \n",
       "3    OH       Cleveland  41.473508  -81.739791    808976.0  San Francisco   \n",
       "4    UT  Salt Lake City  40.755851 -111.896657   8363710.0       New York   \n",
       "5   NaN             NaN        NaN         NaN    413201.0          Miami   \n",
       "6   NaN             NaN        NaN         NaN   2242193.0        Houston   \n",
       "\n",
       "        state  \n",
       "0         NaN  \n",
       "1         NaN  \n",
       "2         NaN  \n",
       "3  California  \n",
       "4    New-York  \n",
       "5     Florida  \n",
       "6       Texas  "
      ]
     },
     "execution_count": 153,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.concat([city_loc, city_pop], axis=1)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this case it really does not make much sense because the indices do not align well (eg. Cleveland and San Francisco end up on the same row, because they shared the index label `3`). So let's reindex the `DataFrame`s by city name before concatenating:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>state</th>\n",
       "      <th>lat</th>\n",
       "      <th>lng</th>\n",
       "      <th>population</th>\n",
       "      <th>state</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>city</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>San Francisco</th>\n",
       "      <td>CA</td>\n",
       "      <td>37.781334</td>\n",
       "      <td>-122.416728</td>\n",
       "      <td>808976.0</td>\n",
       "      <td>California</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>New York</th>\n",
       "      <td>NY</td>\n",
       "      <td>40.705649</td>\n",
       "      <td>-74.008344</td>\n",
       "      <td>8363710.0</td>\n",
       "      <td>New-York</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Miami</th>\n",
       "      <td>FL</td>\n",
       "      <td>25.791100</td>\n",
       "      <td>-80.320733</td>\n",
       "      <td>413201.0</td>\n",
       "      <td>Florida</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Cleveland</th>\n",
       "      <td>OH</td>\n",
       "      <td>41.473508</td>\n",
       "      <td>-81.739791</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Salt Lake City</th>\n",
       "      <td>UT</td>\n",
       "      <td>40.755851</td>\n",
       "      <td>-111.896657</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Houston</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>2242193.0</td>\n",
       "      <td>Texas</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "               state        lat         lng  population       state\n",
       "city                                                               \n",
       "San Francisco     CA  37.781334 -122.416728    808976.0  California\n",
       "New York          NY  40.705649  -74.008344   8363710.0    New-York\n",
       "Miami             FL  25.791100  -80.320733    413201.0     Florida\n",
       "Cleveland         OH  41.473508  -81.739791         NaN         NaN\n",
       "Salt Lake City    UT  40.755851 -111.896657         NaN         NaN\n",
       "Houston          NaN        NaN         NaN   2242193.0       Texas"
      ]
     },
     "execution_count": 154,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.concat([city_loc.set_index(\"city\"), city_pop.set_index(\"city\")], axis=1)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This looks a lot like a `FULL OUTER JOIN`, except that the `state` columns were not renamed to `state_x` and `state_y`, and the `city` column is now the index."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `append()` method is a useful shorthand for concatenating `DataFrame`s vertically:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_24589/360768564.py:1: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
      "  city_loc.append(city_pop)\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>state</th>\n",
       "      <th>city</th>\n",
       "      <th>lat</th>\n",
       "      <th>lng</th>\n",
       "      <th>population</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>CA</td>\n",
       "      <td>San Francisco</td>\n",
       "      <td>37.781334</td>\n",
       "      <td>-122.416728</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>NY</td>\n",
       "      <td>New York</td>\n",
       "      <td>40.705649</td>\n",
       "      <td>-74.008344</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>FL</td>\n",
       "      <td>Miami</td>\n",
       "      <td>25.791100</td>\n",
       "      <td>-80.320733</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>OH</td>\n",
       "      <td>Cleveland</td>\n",
       "      <td>41.473508</td>\n",
       "      <td>-81.739791</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>UT</td>\n",
       "      <td>Salt Lake City</td>\n",
       "      <td>40.755851</td>\n",
       "      <td>-111.896657</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>California</td>\n",
       "      <td>San Francisco</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>808976.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>New-York</td>\n",
       "      <td>New York</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>8363710.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Florida</td>\n",
       "      <td>Miami</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>413201.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>Texas</td>\n",
       "      <td>Houston</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>2242193.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        state            city        lat         lng  population\n",
       "0          CA   San Francisco  37.781334 -122.416728         NaN\n",
       "1          NY        New York  40.705649  -74.008344         NaN\n",
       "2          FL           Miami  25.791100  -80.320733         NaN\n",
       "3          OH       Cleveland  41.473508  -81.739791         NaN\n",
       "4          UT  Salt Lake City  40.755851 -111.896657         NaN\n",
       "3  California   San Francisco        NaN         NaN    808976.0\n",
       "4    New-York        New York        NaN         NaN   8363710.0\n",
       "5     Florida           Miami        NaN         NaN    413201.0\n",
       "6       Texas         Houston        NaN         NaN   2242193.0"
      ]
     },
     "execution_count": 155,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "city_loc.append(city_pop)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As always in pandas, the `append()` method does *not* actually modify `city_loc`: it works on a copy and returns the modified copy."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Categories\n",
    "It is quite frequent to have values that represent categories, for example `1` for female and `2` for male, or `\"A\"` for Good, `\"B\"` for Average, `\"C\"` for Bad. These categorical values can be hard to read and cumbersome to handle, but fortunately pandas makes it easy. To illustrate this, let's take the `city_pop` `DataFrame` we created earlier, and add a column that represents a category:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>population</th>\n",
       "      <th>city</th>\n",
       "      <th>state</th>\n",
       "      <th>eco_code</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>808976</td>\n",
       "      <td>San Francisco</td>\n",
       "      <td>California</td>\n",
       "      <td>17</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>8363710</td>\n",
       "      <td>New York</td>\n",
       "      <td>New-York</td>\n",
       "      <td>17</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>413201</td>\n",
       "      <td>Miami</td>\n",
       "      <td>Florida</td>\n",
       "      <td>34</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>2242193</td>\n",
       "      <td>Houston</td>\n",
       "      <td>Texas</td>\n",
       "      <td>20</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   population           city       state  eco_code\n",
       "3      808976  San Francisco  California        17\n",
       "4     8363710       New York    New-York        17\n",
       "5      413201          Miami     Florida        34\n",
       "6     2242193        Houston       Texas        20"
      ]
     },
     "execution_count": 156,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "city_eco = city_pop.copy()\n",
    "city_eco[\"eco_code\"] = [17, 17, 34, 20]\n",
    "city_eco"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Right now the `eco_code` column is full of apparently meaningless codes. Let's fix that. First, we will create a new categorical column based on the `eco_code`s:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Int64Index([17, 20, 34], dtype='int64')"
      ]
     },
     "execution_count": 157,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "city_eco[\"economy\"] = city_eco[\"eco_code\"].astype('category')\n",
    "city_eco[\"economy\"].cat.categories"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can give each category a meaningful name:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_24589/2586490918.py:1: FutureWarning: Setting categories in-place is deprecated and will raise in a future version. Use rename_categories instead.\n",
      "  city_eco[\"economy\"].cat.categories = [\"Finance\", \"Energy\", \"Tourism\"]\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>population</th>\n",
       "      <th>city</th>\n",
       "      <th>state</th>\n",
       "      <th>eco_code</th>\n",
       "      <th>economy</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>808976</td>\n",
       "      <td>San Francisco</td>\n",
       "      <td>California</td>\n",
       "      <td>17</td>\n",
       "      <td>Finance</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>8363710</td>\n",
       "      <td>New York</td>\n",
       "      <td>New-York</td>\n",
       "      <td>17</td>\n",
       "      <td>Finance</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>413201</td>\n",
       "      <td>Miami</td>\n",
       "      <td>Florida</td>\n",
       "      <td>34</td>\n",
       "      <td>Tourism</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>2242193</td>\n",
       "      <td>Houston</td>\n",
       "      <td>Texas</td>\n",
       "      <td>20</td>\n",
       "      <td>Energy</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   population           city       state  eco_code  economy\n",
       "3      808976  San Francisco  California        17  Finance\n",
       "4     8363710       New York    New-York        17  Finance\n",
       "5      413201          Miami     Florida        34  Tourism\n",
       "6     2242193        Houston       Texas        20   Energy"
      ]
     },
     "execution_count": 158,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "city_eco[\"economy\"].cat.categories = [\"Finance\", \"Energy\", \"Tourism\"]\n",
    "city_eco"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that categorical values are sorted according to their categorical order, *not* their alphabetical order:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>population</th>\n",
       "      <th>city</th>\n",
       "      <th>state</th>\n",
       "      <th>eco_code</th>\n",
       "      <th>economy</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>413201</td>\n",
       "      <td>Miami</td>\n",
       "      <td>Florida</td>\n",
       "      <td>34</td>\n",
       "      <td>Tourism</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>2242193</td>\n",
       "      <td>Houston</td>\n",
       "      <td>Texas</td>\n",
       "      <td>20</td>\n",
       "      <td>Energy</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>808976</td>\n",
       "      <td>San Francisco</td>\n",
       "      <td>California</td>\n",
       "      <td>17</td>\n",
       "      <td>Finance</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>8363710</td>\n",
       "      <td>New York</td>\n",
       "      <td>New-York</td>\n",
       "      <td>17</td>\n",
       "      <td>Finance</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   population           city       state  eco_code  economy\n",
       "5      413201          Miami     Florida        34  Tourism\n",
       "6     2242193        Houston       Texas        20   Energy\n",
       "3      808976  San Francisco  California        17  Finance\n",
       "4     8363710       New York    New-York        17  Finance"
      ]
     },
     "execution_count": 159,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "city_eco.sort_values(by=\"economy\", ascending=False)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# What next?\n",
    "As you probably noticed by now, pandas is quite a large library with *many* features. Although we went through the most important features, there is still a lot to discover. Probably the best way to learn more is to get your hands dirty with some real-life data. It is also a good idea to go through pandas' excellent [documentation](http://pandas.pydata.org/pandas-docs/stable/index.html), in particular the [Cookbook](http://pandas.pydata.org/pandas-docs/stable/cookbook.html)."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "venv",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.6"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "8cab9bf14a15188bc462cdd05fc406dba01291ca9ffbd3249fbcef9e3b942c84"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}