Pandas101review.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pandas 101 review\n",
    "\n",
    "This is a severely cut-down version of the material covered in the Pandas 101 workshop just for a quick reference."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load DataFrame from CSV"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv('data/simple_dataframe.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Display/Select DataFrame elements\n",
    "\n",
    "For a more complete coverage of these topics look at [the DataFrameAccess notebook](DataFrameAccess.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Head/Tail"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "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>letters</th>\n",
       "      <th>hundreds</th>\n",
       "      <th>tens</th>\n",
       "      <th>boolean</th>\n",
       "      <th>spelled_out</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>A</td>\n",
       "      <td>100</td>\n",
       "      <td>10.0</td>\n",
       "      <td>True</td>\n",
       "      <td>One</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>B</td>\n",
       "      <td>200</td>\n",
       "      <td>20.0</td>\n",
       "      <td>False</td>\n",
       "      <td>Two</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>c</td>\n",
       "      <td>300</td>\n",
       "      <td>30.0</td>\n",
       "      <td>True</td>\n",
       "      <td>Three</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  letters  hundreds  tens  boolean spelled_out\n",
       "0       A       100  10.0     True         One\n",
       "1       B       200  20.0    False         Two\n",
       "2       c       300  30.0     True       Three"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.head(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "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>letters</th>\n",
       "      <th>hundreds</th>\n",
       "      <th>tens</th>\n",
       "      <th>boolean</th>\n",
       "      <th>spelled_out</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>D</td>\n",
       "      <td>400</td>\n",
       "      <td>40.0</td>\n",
       "      <td>True</td>\n",
       "      <td>Four</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>eee</td>\n",
       "      <td>500</td>\n",
       "      <td>50.0</td>\n",
       "      <td>False</td>\n",
       "      <td>Five</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  letters  hundreds  tens  boolean spelled_out\n",
       "3       D       400  40.0     True        Four\n",
       "4     eee       500  50.0    False        Five"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.tail(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Index (row names)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "RangeIndex(start=0, stop=5, step=1)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.index"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Column names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['letters', 'hundreds', 'tens', 'boolean', 'spelled_out'], dtype='object')"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.columns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "## Selecting/displaying rows, columns, and single values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "### `df[]` with a name\n",
    "\n",
    "A single column or row is not a DataFrame, it's a Series (the Pandas 1D data structure)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    100\n",
       "1    200\n",
       "2    300\n",
       "3    400\n",
       "4    500\n",
       "Name: hundreds, dtype: int64"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df['hundreds']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### List of column names for multiple columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "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>tens</th>\n",
       "      <th>hundreds</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>10.0</td>\n",
       "      <td>100</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>20.0</td>\n",
       "      <td>200</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>30.0</td>\n",
       "      <td>300</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>40.0</td>\n",
       "      <td>400</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>50.0</td>\n",
       "      <td>500</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   tens  hundreds\n",
       "0  10.0       100\n",
       "1  20.0       200\n",
       "2  30.0       300\n",
       "3  40.0       400\n",
       "4  50.0       500"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df[['tens','hundreds']]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Boolean Series\n",
    "\n",
    "**It's very common to want all the rows from your DataFrame which pass a certain test**, or set of criteria. You can write the test itself in a very straightforward way, returning a `Series` of True/False boolean values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0     True\n",
       "1     True\n",
       "2     True\n",
       "3    False\n",
       "4    False\n",
       "Name: tens, dtype: bool"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df['tens'] < 35"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "### `df[]` with boolean Series returns multiple rows, all columns\n",
    "\n",
    "- Rows are returned where boolean Series == True\n",
    "- *This may be confusing!* If we use a single bracket with a boolean Series inside, we get back rows instead of columns!\n",
    "- Note that you can easily use the `df.loc[,:]` notation below to do the same thing, which is somewhat more clear and readable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "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>letters</th>\n",
       "      <th>hundreds</th>\n",
       "      <th>tens</th>\n",
       "      <th>boolean</th>\n",
       "      <th>spelled_out</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>A</td>\n",
       "      <td>100</td>\n",
       "      <td>10.0</td>\n",
       "      <td>True</td>\n",
       "      <td>One</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>B</td>\n",
       "      <td>200</td>\n",
       "      <td>20.0</td>\n",
       "      <td>False</td>\n",
       "      <td>Two</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>c</td>\n",
       "      <td>300</td>\n",
       "      <td>30.0</td>\n",
       "      <td>True</td>\n",
       "      <td>Three</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  letters  hundreds  tens  boolean spelled_out\n",
       "0       A       100  10.0     True         One\n",
       "1       B       200  20.0    False         Two\n",
       "2       c       300  30.0     True       Three"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df[df['tens'] < 35]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Row Index doesn't have to be integers!\n",
    "\n",
    "The Index values aren't \"row numbers\" – they are instead the names of the rows, so you can use things like strings or dates for the Index."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "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>letters</th>\n",
       "      <th>hundreds</th>\n",
       "      <th>tens</th>\n",
       "      <th>boolean</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>spelled_out</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>One</th>\n",
       "      <td>A</td>\n",
       "      <td>100</td>\n",
       "      <td>10.0</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Two</th>\n",
       "      <td>B</td>\n",
       "      <td>200</td>\n",
       "      <td>20.0</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Three</th>\n",
       "      <td>c</td>\n",
       "      <td>300</td>\n",
       "      <td>30.0</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Four</th>\n",
       "      <td>D</td>\n",
       "      <td>400</td>\n",
       "      <td>40.0</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Five</th>\n",
       "      <td>eee</td>\n",
       "      <td>500</td>\n",
       "      <td>50.0</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            letters  hundreds  tens  boolean\n",
       "spelled_out                                 \n",
       "One               A       100  10.0     True\n",
       "Two               B       200  20.0    False\n",
       "Three             c       300  30.0     True\n",
       "Four              D       400  40.0     True\n",
       "Five            eee       500  50.0    False"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df2 = df.set_index('spelled_out')\n",
    "df2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Both the DataFrame and any column Series have the same Index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "spelled_out\n",
       "One      100\n",
       "Two      200\n",
       "Three    300\n",
       "Four     400\n",
       "Five     500\n",
       "Name: hundreds, dtype: int64"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df2['hundreds']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `df.loc[row,col]` for label-based, multi-axis indexing\n",
    "\n",
    "**This is the best access/selection method!** It lets you select first along rows, and then along columns, in both directions simultaneoulsy using row and column \"labels\", which are the row index and column names."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "300"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df2.loc['Three','hundreds']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Colon `:` for selecting whole or slices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "spelled_out\n",
       "One      100\n",
       "Two      200\n",
       "Three    300\n",
       "Four     400\n",
       "Five     500\n",
       "Name: hundreds, dtype: int64"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df2.loc[:,'hundreds']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Slice end-points are included in Pandas selections\n",
    "\n",
    "Unlike Python lists, in Pandas the slice includes both end points!\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "letters        c\n",
       "hundreds     300\n",
       "tens        30.0\n",
       "Name: Three, dtype: object"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df2.loc['Three','letters':'tens']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "### `df.query()` for selecting rows like in SQL \"where\" statement\n",
    "\n",
    "The idea is to return rows where column content meets certain criteria, like when you use a boolean series inside of a `df[]` statement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "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>letters</th>\n",
       "      <th>hundreds</th>\n",
       "      <th>tens</th>\n",
       "      <th>boolean</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>spelled_out</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>One</th>\n",
       "      <td>A</td>\n",
       "      <td>100</td>\n",
       "      <td>10.0</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Two</th>\n",
       "      <td>B</td>\n",
       "      <td>200</td>\n",
       "      <td>20.0</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Three</th>\n",
       "      <td>c</td>\n",
       "      <td>300</td>\n",
       "      <td>30.0</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            letters  hundreds  tens  boolean\n",
       "spelled_out                                 \n",
       "One               A       100  10.0     True\n",
       "Two               B       200  20.0    False\n",
       "Three             c       300  30.0     True"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df2.query('tens < 35')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create an explicit `.copy()` to avoid the SettingWithCopyWarning\n",
    "\n",
    "If you are assigning a subset of a DataFrame to a new variable with the intention of creating a copy that you'll work on independently of the original, create an explicit copy by chaining the `.copy()` method to the end! *(Try deleting the `.copy()` part of the first command to see what happens without it.)*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "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>hundreds</th>\n",
       "      <th>tens</th>\n",
       "      <th>sums</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>spelled_out</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>One</th>\n",
       "      <td>100</td>\n",
       "      <td>10.0</td>\n",
       "      <td>110.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Two</th>\n",
       "      <td>200</td>\n",
       "      <td>20.0</td>\n",
       "      <td>220.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Three</th>\n",
       "      <td>300</td>\n",
       "      <td>30.0</td>\n",
       "      <td>330.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Four</th>\n",
       "      <td>400</td>\n",
       "      <td>40.0</td>\n",
       "      <td>440.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Five</th>\n",
       "      <td>500</td>\n",
       "      <td>50.0</td>\n",
       "      <td>550.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             hundreds  tens   sums\n",
       "spelled_out                       \n",
       "One               100  10.0  110.0\n",
       "Two               200  20.0  220.0\n",
       "Three             300  30.0  330.0\n",
       "Four              400  40.0  440.0\n",
       "Five              500  50.0  550.0"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_nums = df2[['hundreds','tens']].copy()\n",
    "df_nums['sums'] = df_nums['hundreds'] + df_nums['tens']\n",
    "df_nums"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sorting a DataFrame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "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>hundreds</th>\n",
       "      <th>tens</th>\n",
       "      <th>sums</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>spelled_out</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Five</th>\n",
       "      <td>500</td>\n",
       "      <td>50.0</td>\n",
       "      <td>550.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Four</th>\n",
       "      <td>400</td>\n",
       "      <td>40.0</td>\n",
       "      <td>440.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Three</th>\n",
       "      <td>300</td>\n",
       "      <td>30.0</td>\n",
       "      <td>330.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Two</th>\n",
       "      <td>200</td>\n",
       "      <td>20.0</td>\n",
       "      <td>220.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>One</th>\n",
       "      <td>100</td>\n",
       "      <td>10.0</td>\n",
       "      <td>110.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             hundreds  tens   sums\n",
       "spelled_out                       \n",
       "Five              500  50.0  550.0\n",
       "Four              400  40.0  440.0\n",
       "Three             300  30.0  330.0\n",
       "Two               200  20.0  220.0\n",
       "One               100  10.0  110.0"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_nums.sort_values(by='tens', ascending=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "## Pandas Plotting\n",
    "\n",
    "- Pandas wants data in a \"wide\" format, like Excel, not a \"tidy\" format like Seaborn or Altair\n",
    "- For a more complete coverage look at [the BasicPandasPlotting notebook](BasicPandasPlotting.ipynb)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Plotting from a DataFrame\n",
    "\n",
    "By default the plot will use the Index as the x-axis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:xlabel='spelled_out'>"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "df_nums.plot.bar()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Lots of options\n",
    "\n",
    "- You can explicitly set which columns are used for the x and y values\n",
    "- There are lots of extra options for controlling the size and layout"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[<AxesSubplot:xlabel='hundreds'>, <AxesSubplot:xlabel='hundreds'>]],\n",
       "      dtype=object)"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAecAAADQCAYAAAA9Ban1AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAkLElEQVR4nO3de3hU1b3/8fc3IZAgN7moQMDQilZuoiBeaC0W5WJFtD1SarHU0tLfKRZtBSFtf2r1YFFbbxVtsfXU1lakCgKiggZRa1EEpNwpIAgBBEQTLiaQyzp/7B2YwCSZXCZ7z+Tzep48M7Nmz853Miw+s9es2cucc4iIiEh4pARdgIiIiJSncBYREQkZhbOIiEjIKJxFRERCRuEsIiISMgpnERGRkGkUdAEAbdu2dVlZWUGXIRJ6y5cv/8Q51y7oOiqj/iwSm8r6cyjCOSsri2XLlgVdhkjomdlHQddQFfVnkdhU1p81rC0iIhIyCmcREZGQUTiLiIjUlVUz4aEecFcr73LVzBrtJhSfOYtUV1FREbm5uRQWFgZdSlykp6eTmZlJWlpa0KXUiWR/vaJJttdQYrBqJswbD0UF3u38Hd5tgF4jqrUrhbMkpNzcXJo3b05WVhZmFnQ5dco5x/79+8nNzaVLly5Bl1Mnkvn1iiYZX0OJQc7dx4O5TFGB117NcNawtiSkwsJC2rRpk5T/0ZsZbdq0SaqjzGR+vaJJxtdQqlBS7B0pR5OfW+3dKZwlYSXzf/TJ+NyS8TlVpqE93wZtzzr405UV398ys9q7VDiL1EBeXh6PP/540GWISJCKj8Li++APl0Hedug3FtIyym+TlgED76j2rhXO0iC8+MFO+k9dRJfJ8+k/dREvfrCzVvtTOMdZHc14FYmbXR/Ak5fD4nuh+7Uwbilc9QAMexRadgLMuxz2aLU/bwaFszQAL36wk+xZq9mZV4ADduYVkD1rda0CevLkyWzZsoXevXszceJEHnjgAS688EJ69erFnXfeCcC2bds499xz+eEPf0j37t0ZNGgQBQXeZJFHH32Ubt260atXL0aOHFkXTzN5lM14zd8BuOMzXmsR0IcPH+brX/865513Hj169OC5554jKyuLTz75BIBly5YxYMAAAO666y5Gjx7NoEGDyMrKYtasWdx+++307NmTIUOGUFRUBHj/BspewwkTJtT2WUuiKCqE1++CJwfC4U9g5LPwzT/CKW28+3uNgJ+ugbvyvMsaBDNotrYkgV/NW8u6XQcqvP+D7XkcLSkt11ZQVMLtz6/i2aXboz6mW4cW3Dmse4X7nDp1KmvWrGHlypUsXLiQ559/nqVLl+Kc45prruGtt96ic+fObNq0iWeffZYnn3ySESNG8MILLzBq1CimTp3K1q1badKkCXl5eTV63gnrlcnw8eqK7899H0qOlG8rKoA5N8Pyp6M/5oyeMHRqhbt89dVX6dChA/PnzwcgPz+fSZMmVbj9li1beOONN1i3bh2XXHIJL7zwAvfffz/XXXcd8+fP57LLLmP27Nls2LABM2t4r2FDtf09mDMO9m+C82+EQf8DGa3i8qt05CxJ78Rgrqq9uhYuXMjChQs5//zzueCCC9iwYQObNm0CoEuXLvTu3RuAPn36sG3bNgB69erFd77zHZ555hkaNdJ75HJODOaq2mPQs2dPXn/9dSZNmsTbb79Ny5YtK91+6NChpKWl0bNnT0pKShgyZMix/Wzbto0WLVqQnp7OD37wA2bNmkXTpk1rXJskgKOHvTeVTw2G4iNw42wY/ljcghl05CxJoLIjXID+UxexM6/gpPaOrTJ47keX1Pr3O+fIzs7mRz/6Ubn2bdu20aRJk2O3U1NTjw1rz58/n7feeou5c+dyzz33sHbt2oYT0pUc4QLeZ8zRvpLSshPcNL9Gv/Lss89m+fLlvPzyy2RnZzNo0CAaNWpEaan3Bu3ErzyVvW4pKSmkpaUdm3mdkpJCcXExjRo1YunSpeTk5DBjxgwee+wxFi1aVKPaJOQ+fBPm/gTyPvImfA28E5o0i/uv1ZGzJL2Jg88hIy21XFtGWioTB59T4302b96cgwcPAjB48GCeeuopDh06BMDOnTvZu3dvhY8tLS1lx44dXH755dx///3k5eUde6zgzWytoxmvZXbt2kXTpk0ZNWoUEyZMYMWKFWRlZbF8+XIAXnjhhWrt79ChQ+Tn53PVVVfx8MMPs3LlyhrXJiFVmA/zboG/XAMpqXDTK96Er3oIZtCRszQA157fEYAHFmxkV14BHVplMHHwOcfaa6JNmzb079+fHj16MHToUG644QYuucQ7Cm/WrBnPPPMMqampUR9bUlLCqFGjyM/PxznHT3/6U1q1alXjWpJO2QSanLu9kze0zPSCuYYTawBWr17NxIkTjx0JP/HEExQUFDBmzBjuvfdeLrroomrt7+DBgwwfPpzCwkKcczz00EM1rk1C6D8L4aVb4eBuuHQ8XP7zk98wxpk556reyGwbcBAoAYqdc33NrDXwHJAFbANGOOc+87fPBsb42493zi2obP99+/Z1Wv9VqmP9+vWce+65QZcRV9Geo5ktd871DaikmETrzw3h9YqmoT7vhPX5p/BqNqyaAe3OheHTILNP3H5dZf25OsPalzvnekfsaDKQ45zrCuT4tzGzbsBIoDswBHjczKIfQoiIiITBujkw7SJY8zx8dRL86M24BnNVajOsPRwY4F9/GlgMTPLbZzjnjgBbzWwz0A9YUovfJSIiUvcO7YWXJ3jh3P48uHGW99W8gMUazg5YaGYO+INzbjpwunNuN4BzbreZneZv2xF4N+KxuX6biIhIODjnndjm1Ulw9HNvFval4yE1HFOxYq2iv3Nulx/Ar5nZhkq2jXa295M+2DazscBYgM6dO8dYhshxzrmkXVwglrkgYRJLf07m1yuaRHsNG5T8nfDST2HTAsjs53223O7soKsqJ6bPnJ1zu/zLvcBsvGHqPWbWHsC/LPvuSC7QKeLhmcCuKPuc7pzr65zr265du5o/A2mQ0tPT2b9/f1L+B1i2FnB6enrQpcSsqv6czK9XNIn4GjYIzsHyP8PjF8O2t2HIVPj+q6ELZojhyNnMTgFSnHMH/euDgLuBucBoYKp/Ocd/yFzg72b2INAB6AosjUPt0oBlZmaSm5vLvn37gi4lLtLT08nMrP4yc2GV7K9XNMn2Gia8z7bB3PGw9U3I+gpc8zto3SXoqioUy7D26cBsfziqEfB359yrZvY+MNPMxgDbgesBnHNrzWwmsA4oBsY550riUr00WGlpaXTpEt6OJeXp9ZLAlJbC0umQ8yuwVLj6YejzPQj5RyxVhrNz7kPgvCjt+4GBFTxmCjCl1tWJiIjU1CebvAVTdrwLZ10Jwx72TmqTAMIxLU1ERKSulBTDkt/BG7/2zux13R+g17dCf7QcSeEsIiLJY89aePHHsHslnDsMrvotND896KqqTeEsIiKJr/govP1b7yejFVz/NHS/NuiqakzhLCIiiW3nCu+z5b1rveHrIVOhaeugq6oVhbOIiCSmogJY/Gv41++g2Rnw7efgnCFBV1UnFM4iIpJ4PloCc2+G/ZvhgtEw6B5Ibxl0VXVG4SwiIonjyCFvre+l06FVJ7jxRfji5UFXVecUziIikhg+XAxzfwJ5O6DfWBh4BzRpFnRVcaFwFhGRcFk10zs6zs/1Thpy2QTYuRxW/AXanAU3vQJnXhJ0lXGlcBYRkfBYNRPmjfcmewHk74B5twIO+t8CA7K9E4skOYWziIiER87dx4P5GAfNToMr7w6kpCDEtGSkiIhIvcjPjd5+qOGsaAYKZxERCYuDe6BRBWtgJ8iCFXVF4SwiIsFyDlY+C9P6QclRSEkrf39ahjczuwFROIuISHDyc+Fv18OL/w/afQnGvQfXPg4tOwHmXQ57FHqNCLrSeqUJYSIiUv9KS2HFn2HhHeBKYOj9cOEPISUF2nZtcGF8IoWziIjUr08/hLnjYdvb0OUyuOZ3cGpW0FWFisJZRETqR2kJvPcH7+tSqWkw7BHvvNhmQVcWOgpnERGJv30bvWUdc5dC18Fw9UPQsmPQVYVWzBPCzCzVzD4ws5f8263N7DUz2+RfnhqxbbaZbTazjWY2OB6Fi4hIAigphrd/C7//MuzfBN94Em54TsFcherM1r4FWB9xezKQ45zrCuT4tzGzbsBIoDswBHjczFLrplwREUkYH6+GP37NG8Y+ZyiMW+pN9NIwdpViCmczywS+Dvwxonk48LR//Wng2oj2Gc65I865rcBmoF+dVCsiIuFXfAQWTYHpA+DAbhjxF++n2WlBV5YwYv3M+WHgdqB5RNvpzrndAM653WZW9lfvCLwbsV2u31aOmY0FxgJ07ty5elWLSKioP8sxucthzjjYtx7O+zYMvheatg66qoRT5ZGzmV0N7HXOLY9xn9HGK9xJDc5Nd871dc71bdeuXYy7FpEwUn8Wigpg4S/hT1fAkQNwwz/gut8rmGsoliPn/sA1ZnYVkA60MLNngD1m1t4/am4P7PW3zwU6RTw+E9hVl0WLiEiIfPQvbyb2p1ugz03e6lHpLYKuKqFVeeTsnMt2zmU657LwJnotcs6NAuYCo/3NRgNz/OtzgZFm1sTMugBdgaV1XrmIiATryEGYPwH+d6h3lq/R82DYwwrmOlCb7zlPBWaa2RhgO3A9gHNurZnNBNYBxcA451xJrSsVEZHw2LII5t4C+Tvg4h/D134JjU8JuqqkUa1wds4tBhb71/cDAyvYbgowpZa1iYhI2BTkwcJfwAfPQNuz4fsLoPNFQVeVdHSGMBERic2Gl+Gln8LhffDln8FXJ0FaBesvS60onEVEpHKHP4FXJsGa5+H0Ht4Zvjr0DrqqpKZwFhGR6JyDtbPg5YlQeAAu/wX0vxUaNQ66sqSncBYRkZMd/Bhe+hlsnA8dLoDh0+D0bkFX1WAonEVE5DjnYOXfYUG2dxrOK+/xZmOnKi7qk/7aIiLiydsO826FLTnQ+VK45nfQ9qygq2qQFM4iIg1daSksfwpeu9M7cr7qN9B3DKRUZ+FCqUsKZxGRhmz/Fpg7Hj76J3zhchj2CJx6ZtBVNXgKZxGRhqi0BN59Ahb9D6Q2hmseg/NHaa3lkFA4i4g0NHs3eMs67lwGZw+Fqx+CFu2DrkoiKJxFRBqKkiJ452F4835o3Ay++Sfo8U0dLYeQwllEJFmtmgk5d0N+LjQ7DVLS4EAudP8GDL0fmmnt7bBSOIuIJKNVM2HeeCgq8G4f2uNdXvxjGPLr4OqSmGievIhIMsq5+3gwR1o/r/5rkWpTOIuIJJujn3vrLEeTn1u/tUiNKJxFRJLJ1rfhiUsrvr9lZv3VIjWmcBYRSQaFB7y1lp++2rv9lQmQllF+m7QMGHhH/dcm1aYJYSIiiW7T6zDvFji4Cy652VvasXFTaHfO8dnaLTO9YO41IuhqJQZVhrOZpQNvAU387Z93zt1pZq2B54AsYBswwjn3mf+YbGAMUAKMd84tiEv1IiIN2eefwoJfwL//Dm3Pge8vhE4XHr+/1wiFcYKK5cj5CPA159whM0sD/mlmrwDfAHKcc1PNbDIwGZhkZt2AkUB3oAPwupmd7ZwridNzEBFpeNbPg/m3weFPvCHsr94OjZoEXZXUkSrD2TnngEP+zTT/xwHDgQF++9PAYmCS3z7DOXcE2Gpmm4F+wJK6LFxEpEE6tA9emQhrZ8MZPeE7/4D25wVdldSxmD5zNrNUYDlwFjDNOfeemZ3unNsN4JzbbWan+Zt3BN6NeHiu3yYiIjXlHKx+Hl65HY4egq/9EvrfCqlpQVcmcRBTOPtD0r3NrBUw28x6VLJ5tJO0upM2MhsLjAXo3LlzLGWISEipP8fZgV3w0s/gP69Ax74wfBqc9qWgq5I4qtZXqZxzeXjD10OAPWbWHsC/3Otvlgt0inhYJrAryr6mO+f6Ouf6tmun87uKJDL15zhxDlb8FaZdDB8uhkFTYMxCBXMDUGU4m1k7/4gZM8sArgA2AHOB0f5mo4E5/vW5wEgza2JmXYCuwNI6rltEJLl99hH89TqYe7P32fJ/vwOX3gwpqUFXJvUglmHt9sDT/ufOKcBM59xLZrYEmGlmY4DtwPUAzrm1ZjYTWAcUA+M0U1tEJEalpbDsT/Dand5Sjl9/EPrcBCk6Z1RDEsts7VXA+VHa9wMDK3jMFGBKrasTEWlIPtkMc38C2/8FXxwIwx6BVp2qfpwkHZ0hTEQkaCXF8O40eONe77vK1z4B533bO3KWBknhLCISpD3rYM442LUCzvk6XP0gND8j6KokYApnEZEgFB+Ffz4Ebz0A6S3gv56C7t/Q0bIACmcRkfq36wOYczPsWQM9/guG3gentA26KgkRhbOISH0pKoQ3p8I7j8Ip7WDks/Clq4KuSkJI4SwiUh+2v+d9trx/E5w/yjuhSEaroKuSkFI4i4jE09HDkHMPvPd7aNkJRs2Cs6J+C1XkGIWziEi8fPim973lvI/gwh/CFXdCk+ZBVyUJQOEsIlLXCvPhtTtg+Z+h9Rfgey9DVv+gq5IEonAWEalL/1kA826FQx/DpePh8p9DWkbQVUmCUTiLiNSFzz+FV7Nh1Qxody586xnI7BN0VZKgFM4iIrW1bg7Mvw0KPoOvToKv3OadhlOkhhTOIiI1dWgvvDzBC+czesGNs73lHUVqSeEsIlJdzsGqmfDqJO+rUgPv8D5fTk0LujJJEgpnEZGqrJoJOXdDfq63KEXTtrBnNWT2g+GPQbtzgq5QkozCWUSkMqtmwrzxUFTg3T642/vpOQKu+z2kpAZbnySllKALEBEJtZy7jwdzpO1LFMwSNwpnEZGKlJZC/o7o9+Xn1m8t0qAonEVEovlkE/zv0Irvb5lZf7VIg1NlOJtZJzN7w8zWm9laM7vFb29tZq+Z2Sb/8tSIx2Sb2WYz22hmg+P5BERE6lRJMfzzIXiiP+zbAH2/f/IZvtIyvBnaInESy5FzMXCbc+5c4GJgnJl1AyYDOc65rkCOfxv/vpFAd2AI8LiZ6YMZEQm/j9fAHwfC63fB2YNg3FK4+iEY9qi3ohTmXQ57FHqNCLpaSWJVztZ2zu0GdvvXD5rZeqAjMBwY4G/2NLAYmOS3z3DOHQG2mtlmoB+wpK6LFxGpE8VH4e3fwtu/gfRWcP3T0P3a4/f3GqEwlnpVra9SmVkWcD7wHnC6H9w453ab2Wn+Zh2BdyMeluu3nbivscBYgM6dO1e7cBEJj4TuzzuXw5ybYe867+tRQ6bCKW2CrkoauJgnhJlZM+AF4Fbn3IHKNo3S5k5qcG66c66vc65vu3btYi1DREIoIftzUQEs/P/wxyu8c2J/+zn45pMKZgmFmI6czSwNL5j/5pyb5TfvMbP2/lFze2Cv354LdIp4eCawq64KFhGptY+WwJxx8OkWuOC7cOU9kNEq6KpEjolltrYBfwLWO+cejLhrLjDavz4amBPRPtLMmphZF6ArsLTuShYRqaEjh+Dlid5XpEqL4MYX4ZrfKZgldGI5cu4P3AisNrOVftvPganATDMbA2wHrgdwzq01s5nAOryZ3uOccyV1XbiISLVsecM7DWfeDug31vsqVJNmQVclElUss7X/SfTPkQEGVvCYKcCUWtQlIlI3CvNh4S9hxV+gzVlw0ytw5iVBVyVSKS18ISLJa+Or8NKtcGgP9L8FBmSffEIRkRBSOItI8jm8H16dDKtnwmndYOTfoGOfoKsSiZnCWUSSh3Ow7kWYPwEK8+Crk+Ert0GjxkFXJlItCmcRSQ4H98D8n8GGl6B9b/juHDijR9BVidSIwllEEptz8O8Z3jB2UQFccRdc8hNI1X9vkrj0r1dEElfeDm/C1+bXodNFMHwatO0adFUitaZwFpHEU1oKK/4MC+8AVwJD7oN+P4QULYAnyUHhLCKJ5dMPYe542PY2dLnMW76xdZegqxKpUwpnEUkMpSXw3u8h5x5ITYNhj8AFo8EqOkeSSOJSOItI+O3b6C1Ukfs+dB0EVz8MLU9aiVYkaSicRSS8SorgnUfgzfug8Slw3XToNUJHy5L0FM4iEk67V3lHyx+vgm7D4arfQLPTgq5KpF4onEUkXIqPwFu/gX8+CBmnwoi/eOEs0oAonEUkPHKXeUfL+zZAr5Ew5NfQtHXQVYnUO4WziATv6Oew+F5YMg2at4cb/gFnDwq6KpHAKJxFJFjb3oG5N3vfX+7zPbjybkhvGXRVIoFSOItI/Vk1E3LuhvxcaNEB2nSFrYuh1Znw3bnwha8GXaFIKCicRaR+rJoJ88Z7i1MAHNjp/XxxIHzrr95XpUQEgJSqNjCzp8xsr5mtiWhrbWavmdkm//LUiPuyzWyzmW00s8HxKlxEEkzO3ceDOdIn/1Ewi5ygynAG/gwMOaFtMpDjnOsK5Pi3MbNuwEigu/+Yx81MZ6IXEW8ouzrtIg1YleHsnHsL+PSE5uHA0/71p4FrI9pnOOeOOOe2ApuBfnVTqogktJaZ1WsXacBiOXKO5nTn3G4A/7LstD0dgR0R2+X6bSLS0A28A9IyyrelZXjtIlJOTcO5ItFOeOuibmg21syWmdmyffv21XEZIlKfYurPvUZ4yzu27ASYdznsUa9dRMqp6WztPWbW3jm328zaA3v99lygU8R2mcCuaDtwzk0HpgP07ds3aoCLSGKIuT/3GqEwFolBTY+c5wKj/eujgTkR7SPNrImZdQG6AktrV6KIiEjDUuWRs5k9CwwA2ppZLnAnMBWYaWZjgO3A9QDOubVmNhNYBxQD45xzJXGqXUREJClVGc7OuW9XcNfACrafAkypTVEiIiINWV1PCBMREZFaUjiLiIiEjMJZREQkZBTOIiIiIaNwFhERCRktGSkSsBc/2MkDCzayK6+ADq0ymDj4HK49X2e9FWnIFM4iAXrxg51kz1pNQZF3OoCdeQVkz1oNoIAWacA0rC1Sz4pKSvn08FG2fXKYKS+vPxbMZQqKSnhgwcaAqhORMNCRsySN+hgeLil1HCos5kBhEQcKizhYWMzBwmIOFBRxsOz2kbLbxce2Ob5tEYVFpVX+nl15BXVat4gkFoWzJIVYhodLSx2HjxZzwA/JsrA8UOBflgVtxH0nbnP4aNVno01PS6F5ehot0hvRPD2N5umN6NgqgxYZ/u0mjWie3ogWGWn8z/z1fHr46En76NAqI8qeRaShUDhLQnDOUVBUckKQHr+875UNUYeHJ/zj3zywYCMHCos4dKQYV8X6Z41TU44FZ/N0L0TbNWt2PFj9wG1xwmXZY5o1aUTjRrF/WpRiVu5NBUBGWioTB59Trb+PiCQXhbOcJB7Dw4VFJVGPSsuGf8uC9qT7I4aOS0qrv7Jocanj4i+08cKzLFBPCFrvPu8yPS21Vs+zusr+rpqtLSKRFM5STrTh4cmzVnHoSDFfPqttpUF6bPj3yImfxRZztKTyz1nNoFmT4yHZIj2NM1qk0/W0ZhFHseWDtOzItUVGGtdOe4fd+YUn7bdjqwx+O+K8uPyt6sq153dUGItIOQrnJFfRBCYvSI9PYCoL1tfX7+FIcfkgLSwq5Zcvrqn095zSOLXcUWnrUxpzZptTyg/7lhsuLh+0pzRuREqK1fh5ThryJQ0Pi0jSUDjHUW2Hh8smMB0sN1GpbLi3/JBwRUPG1ZnA1Dy90UnBHOm3159X7rPYFulptEhPo1l6I1JrEax1QcPDIpJMFM5xMntFLtmzVx/72szOvAJuf34VK7Z/xpfOaFEuaCOHhMsFbDUmMEVOYmrXrNkJk5rSIsK08glM/acuYmeUr/F0bJXBN/tk1unfqK5peFhEkkVChHMQpzcsm8AUOSP4xKPSA5HBekLQfvZ50Un7PFpSyl+WfHTsdmqKHQvW5k28IeFOrZtGDdKTJzJ529T1BKaJg8/R8LCISMBCH841Ob1hUUlpBd9hrSBooxzB1nwCkxegf333o+iPA5ZkD6R5eiOaNk7FLNjh4BNpeFhEJHihD+cHFmyM+v3Vn89ezWvr90T93DWWMzCVTWAqG94tm8AUOUnpxCHgyCHiZlVMYFq0YW/U4eEOrTI4o2V69f8Q9UjDwyIiwYpbOJvZEOARIBX4o3Nuak32U9FpDD8/WsL63QeOBWnHVhnHQ9Q/A9OJwVq2bbMmjWiUGt/Timt4WEREaiou4WxmqcA04EogF3jfzOY659ZVd18dWmVUOEFp0W0Daltq3Gh4WEREaipeR879gM3OuQ8BzGwGMByodjgn8hGohodFRKQm4jW22xHYEXE71287xszGmtkyM1u2b9++Cnd07fkd+fU3etKxVQaGd8T862/0VOiJhEis/VlEYhOvI+doM6XKfWPXOTcdmA7Qt2/fSr/NqyNQkXCrTn8WkarF68g5F+gUcTsT2BWn3yUiIpJU4hXO7wNdzayLmTUGRgJz4/S7REREkkpchrWdc8VmdjOwAO+rVE8559bG43eJiIgkG3NVnby5Poow2wdEP6VWeW2BT+JcTjyo7vqVzHWf6ZxrVx/F1FSM/TmZX6MwUt31r1b9ORThHCszW+ac6xt0HdWluuuX6g6/RH2uqrt+JWrdUPva43uaLBEREak2hbOIiEjIJFo4Tw+6gBpS3fVLdYdfoj5X1V2/ErVuqGXtCfWZs4iISEOQaEfOIiIiSS804WxmT5nZXjNbE9HW2sxeM7NN/uWpEfdlm9lmM9toZoODqRrMrJOZvWFm681srZndkgi1m1m6mS01s3/7df8qEeqOqCXVzD4ws5f826Gv28y2mdlqM1tpZssSpe6aSMT+rL4cjETsy34t8e3PzrlQ/ACXARcAayLa7gcm+9cnA/f517sB/waaAF2ALUBqQHW3By7wrzcH/uPXF+ra8c5/3sy/nga8B1wc9roj6v8Z8HfgpQT6t7INaHtCW+jrruFzTbj+rL4c2L+VhOvLfj1x7c+BPKlKnmzWCZ15I9Dev94e2OhfzwayI7ZbAFwSdP1+LXPw1rFOmNqBpsAK4KJEqBvvXO05wNciOnQi1B2tM4e+7lo834Tuz+rL9VJvQvZl//fHtT+HZli7Aqc753YD+Jen+e1VLkkZBDPLAs7He+ca+tr94aSVwF7gNedcQtQNPAzcDpRGtCVC3Q5YaGbLzWys35YIddeVhHmu6sv15mESsy9DnPtzvJaMjLcql6Ssb2bWDHgBuNU5d8AsWoneplHaAqndOVcC9DazVsBsM+tRyeahqNvMrgb2OueWm9mAWB4SpS2ofyv9nXO7zOw04DUz21DJtmGqO95C9VzVl+tHgvdliHN/DvuR8x4zaw/gX+7120O1JKWZpeF15r8552b5zQlRO4BzLg9YDAwh/HX3B64xs23ADOBrZvYM4a8b59wu/3IvMBvoRwLUXYdC/1zVl+tVwvZliH9/Dns4zwVG+9dH430GVNY+0syamFkXoCuwNID6MO9t9Z+A9c65ByPuCnXtZtbOf5eNmWUAVwAbCHndzrls51ymcy4LbynSRc65UYS8bjM7xcyal10HBgFrCHnddSzUz1V9uX4lal+GeurPQX2YHuXD9WeB3UAR3ruMMUAbvMkCm/zL1hHb/wJvxttGYGiAdX8Zb3hiFbDS/7kq7LUDvYAP/LrXAHf47aGu+4TnMIDjk0hCXTfwBbzZmv8G1gK/SIS6a/F8E64/qy8H+u8lYfqyX0fc+7POECYiIhIyYR/WFhERaXAUziIiIiGjcBYREQkZhbOIiEjIKJxFRERCRuGc4MwsyyJW/qnD/X7PzB6r5T4O1VU9Ig2B+rOUUThLtZhZop7yVUROoP4cXgrn5JBqZk+at5brQjPLMLPFZtYXwMza+qfIK3sHPcvMXvXXHL2/bCdmdpOZ/cfM3sQ7tV5Z+5/N7EEzewO4z8y+6D9+uZm9bWZf8rfrYmZLzOx9M7sn4vHtzewt89Y9XWNmX6mnv4tIIlJ/FoVzkugKTHPOdQfygG9WsX1v4FtAT+Bb5i0y3x74FV4nvhJv/dFIZwNXOOduA6YDP3HO9QEmAI/72zwCPOGcuxD4OOKxNwALnHO9gfPwzrwkItGpP0vCrkol5W11zq30ry/HW0e3MjnOuXwAM1sHnAm0BRY75/b57c/hdeAy/3DOlZi3Ys+lwD/s+Go9TfzL/hz/j+SvwH3+9feBp8xbVODFiFpF5GTqz6Ij5yRxJOJ6Cd6brmKOv77pMWwPlS9hdti/TAHynHO9I37OjdjupH04594CLgN2An81s+9W9mREGjj1Z1E4J7FtQB//+n/FsP17wAAza+O/I74+2kbOuQPAVjO7HryVfMzsPP/ud/BWlwH4TtljzOxMvHVbn8Rb9eeCaj4XkYZuG+rPDYrCOXn9BvhvM/sX3hBXpZxzu4G7gCXA68CKSjb/DjDGzMpWZBnut98CjDOz94GWEdsPAFaa2Qd4w2SPVOuZiIj6cwOjValERERCRkfOIiIiIaNwFhERCRmFs4iISMgonEVEREJG4SwiIhIyCmcREZGQUTiLiIiEjMJZREQkZP4PHtmeyMpu8pIAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 576x216 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "df_nums.plot.line(x='hundreds', \n",
    "                  y=['tens','sums'], \n",
    "                  subplots=True, \n",
    "                  layout=(1,-1), \n",
    "                  figsize=(8,3), \n",
    "                  sharey=True,\n",
    "                  marker='o')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### You can also plot a Series"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:ylabel='spelled_out'>"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "df_nums['sums'].sort_values(ascending=False).plot.barh()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.12"
  },
  "toc-autonumbering": false,
  "toc-showmarkdowntxt": false
 },
 "nbformat": 4,
 "nbformat_minor": 4
}