homework5-part1-Valeeva.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Homework 5, Part 1: Building a pandas cheat sheet\n",
    "\n",
    "**Use `animals.csv` to answer the following questions.** The data is small and the questions are pretty simple, so hopefully you can use this for pandas reference in the future."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 0) Setup\n",
    "\n",
    "Import pandas **with the correct name**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1) Reading in a csv file\n",
    "\n",
    "Use pandas to read in the animals CSV file, saving it as a variable with the normal name for a dataframe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "02-Billionaires.ipynb          homework5-part1-Valeeva.ipynb\r\n",
      "animals.csv                    richpeople.xlsx\r\n"
     ]
    }
   ],
   "source": [
    "ls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv(\"animals.csv\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2) Checking your data\n",
    "\n",
    "Display the number of rows and columns in your data. Also display the names and data types of each column."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(df.columns)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 7 entries, 0 to 6\n",
      "Data columns (total 3 columns):\n",
      " #   Column  Non-Null Count  Dtype \n",
      "---  ------  --------------  ----- \n",
      " 0   animal  7 non-null      object\n",
      " 1   name    7 non-null      object\n",
      " 2   length  7 non-null      int64 \n",
      "dtypes: int64(1), object(2)\n",
      "memory usage: 296.0+ bytes\n"
     ]
    }
   ],
   "source": [
    "df.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "animal    object\n",
       "name      object\n",
       "length     int64\n",
       "dtype: object"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.dtypes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3) Display the first 3 animals\n",
    "\n",
    "Hmmm, we know how to take the first 5, but maybe the first 3. Maybe there is an option to change how many you get? Use `?` to check the documentation on the command."
   ]
  },
  {
   "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>animal</th>\n",
       "      <th>name</th>\n",
       "      <th>length</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>cat</td>\n",
       "      <td>Anne</td>\n",
       "      <td>35</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>cat</td>\n",
       "      <td>Bob</td>\n",
       "      <td>45</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>dog</td>\n",
       "      <td>Egglesburg</td>\n",
       "      <td>65</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  animal        name  length\n",
       "0    cat        Anne      35\n",
       "1    cat         Bob      45\n",
       "2    dog  Egglesburg      65"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.head(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4) Sort the animals to show me the 3 longest animals\n",
    "\n",
    "> **TIP:** You can use `.head()` after you sort things!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "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>animal</th>\n",
       "      <th>name</th>\n",
       "      <th>length</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>dog</td>\n",
       "      <td>Egglesburg</td>\n",
       "      <td>65</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>dog</td>\n",
       "      <td>Devon</td>\n",
       "      <td>50</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>cat</td>\n",
       "      <td>Bob</td>\n",
       "      <td>45</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  animal        name  length\n",
       "2    dog  Egglesburg      65\n",
       "3    dog       Devon      50\n",
       "1    cat         Bob      45"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.sort_values(by='length', ascending=False).head(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5) Get the mean and standard deviation of animal lengths\n",
    "\n",
    "You can do this with separate commands or with a single command."
   ]
  },
  {
   "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>length</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>count</th>\n",
       "      <td>7.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mean</th>\n",
       "      <td>38.857143</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>std</th>\n",
       "      <td>17.101935</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>min</th>\n",
       "      <td>10.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25%</th>\n",
       "      <td>33.500000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50%</th>\n",
       "      <td>35.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75%</th>\n",
       "      <td>47.500000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>max</th>\n",
       "      <td>65.000000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          length\n",
       "count   7.000000\n",
       "mean   38.857143\n",
       "std    17.101935\n",
       "min    10.000000\n",
       "25%    33.500000\n",
       "50%    35.000000\n",
       "75%    47.500000\n",
       "max    65.000000"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.describe()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6) How many cats do we have and how many dogs?\n",
    "\n",
    "You only need one command to do this"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "cat    4\n",
       "dog    3\n",
       "Name: animal, dtype: int64"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.animal.value_counts()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7) Only display the dogs\n",
    "\n",
    "> **TIP:** It's probably easiest to make it display the list of `True`/`False` first, then wrap the `df[]` around it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "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>animal</th>\n",
       "      <th>name</th>\n",
       "      <th>length</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>dog</td>\n",
       "      <td>Egglesburg</td>\n",
       "      <td>65</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>dog</td>\n",
       "      <td>Devon</td>\n",
       "      <td>50</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>dog</td>\n",
       "      <td>Fontaine</td>\n",
       "      <td>35</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  animal        name  length\n",
       "2    dog  Egglesburg      65\n",
       "3    dog       Devon      50\n",
       "5    dog    Fontaine      35"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df[df.animal == 'dog']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8) Only display the animals that are longer than 40cm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "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>animal</th>\n",
       "      <th>name</th>\n",
       "      <th>length</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>cat</td>\n",
       "      <td>Bob</td>\n",
       "      <td>45</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>dog</td>\n",
       "      <td>Egglesburg</td>\n",
       "      <td>65</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>dog</td>\n",
       "      <td>Devon</td>\n",
       "      <td>50</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  animal        name  length\n",
       "1    cat         Bob      45\n",
       "2    dog  Egglesburg      65\n",
       "3    dog       Devon      50"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df[df.length >= 40]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9) `length` is the animal's length in centimeters. Create a new column called `inches` that is the length in inches."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "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>animal</th>\n",
       "      <th>name</th>\n",
       "      <th>length</th>\n",
       "      <th>inches</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>cat</td>\n",
       "      <td>Anne</td>\n",
       "      <td>35</td>\n",
       "      <td>13.779528</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>cat</td>\n",
       "      <td>Bob</td>\n",
       "      <td>45</td>\n",
       "      <td>17.716535</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>dog</td>\n",
       "      <td>Egglesburg</td>\n",
       "      <td>65</td>\n",
       "      <td>25.590551</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>dog</td>\n",
       "      <td>Devon</td>\n",
       "      <td>50</td>\n",
       "      <td>19.685039</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>cat</td>\n",
       "      <td>Charlie</td>\n",
       "      <td>32</td>\n",
       "      <td>12.598425</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  animal        name  length     inches\n",
       "0    cat        Anne      35  13.779528\n",
       "1    cat         Bob      45  17.716535\n",
       "2    dog  Egglesburg      65  25.590551\n",
       "3    dog       Devon      50  19.685039\n",
       "4    cat     Charlie      32  12.598425"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df['inches']= df['length']/2.54\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 10) Save the cats to a separate variable called `cats`. Save the dogs to a separate variable called `dogs`.\n",
    "\n",
    "This is the same as listing them, but you just save the result to a variable instead of looking at it. Be sure to use `.head()` to make sure your data looks right.\n",
    "\n",
    "Once you do this, every time you use `cats` you'll only be talking about the cats, and same for the dogs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "cats = df[df.animal == 'cat']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "dogs = df[df.animal == 'dog']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  animal     name  length     inches\n",
      "0    cat     Anne      35  13.779528\n",
      "1    cat      Bob      45  17.716535\n",
      "4    cat  Charlie      32  12.598425\n",
      "6    cat   Xypher      10   3.937008\n"
     ]
    }
   ],
   "source": [
    "print (cats.head())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 11) Display all of the animals that are cats and above 12 inches long.\n",
    "\n",
    "First do it using the `cats` variable, then also do it using your `df` dataframe.\n",
    "\n",
    "> **TIP:** For multiple conditions, you use `df[(one condition) & (another condition)]`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "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>animal</th>\n",
       "      <th>name</th>\n",
       "      <th>length</th>\n",
       "      <th>inches</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>cat</td>\n",
       "      <td>Anne</td>\n",
       "      <td>35</td>\n",
       "      <td>13.779528</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>cat</td>\n",
       "      <td>Bob</td>\n",
       "      <td>45</td>\n",
       "      <td>17.716535</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>cat</td>\n",
       "      <td>Charlie</td>\n",
       "      <td>32</td>\n",
       "      <td>12.598425</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  animal     name  length     inches\n",
       "0    cat     Anne      35  13.779528\n",
       "1    cat      Bob      45  17.716535\n",
       "4    cat  Charlie      32  12.598425"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cats[cats['length']>12]"
   ]
  },
  {
   "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>animal</th>\n",
       "      <th>name</th>\n",
       "      <th>length</th>\n",
       "      <th>inches</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>cat</td>\n",
       "      <td>Anne</td>\n",
       "      <td>35</td>\n",
       "      <td>13.779528</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>cat</td>\n",
       "      <td>Bob</td>\n",
       "      <td>45</td>\n",
       "      <td>17.716535</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>cat</td>\n",
       "      <td>Charlie</td>\n",
       "      <td>32</td>\n",
       "      <td>12.598425</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  animal     name  length     inches\n",
       "0    cat     Anne      35  13.779528\n",
       "1    cat      Bob      45  17.716535\n",
       "4    cat  Charlie      32  12.598425"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df[(df.animal == 'cat')&(df.length>12)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 12) What's the mean length of a cat? What's the mean length of a dog?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30.5"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cats.length.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "50.0"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dogs.length.mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 13) If you didn't already, use `groupby` to do #12 all at once"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "animal\n",
       "cat    30.5\n",
       "dog    50.0\n",
       "Name: length, dtype: float64"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.groupby(by=\"animal\").length.mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 14) Make a histogram of the length of dogs.\n",
    "\n",
    "We didn't talk about how to make a histogram in class! It **does not** use `plot()`. Imagine you're a programmer who doesn't want to type out `histogram` - what do you think you'd type instead?\n",
    "\n",
    "> **TIP:** The method is four letters long\n",
    ">\n",
    "> **TIP:** First you'll say \"I want the length column,\" then you'll say \"make a histogram\"\n",
    ">\n",
    "> **TIP:** This is the worst histogram ever"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x11dd9afd0>"
      ]
     },
     "execution_count": 33,
     "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": [
    "dogs.length.hist()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 15) Make a horizontal bar graph of the length of the animals, with the animal's name as the label\n",
    "\n",
    "> **TIP:** It isn't `df['length'].plot()`, because it needs *both* columns. Think about how we did the scatterplot in class.\n",
    ">\n",
    "> **TIP:** Which is the `x` axis and which is the `y` axis? You'll notice pandas is kind of weird and wrong.\n",
    ">\n",
    "> **TIP:** Make sure you specify the `kind` of graph or else it will be a weird line thing\n",
    ">\n",
    "> **TIP:** If you want, you can set a custom size for your plot by sending it something like `figsize=(15,2)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x11b2ac520>"
      ]
     },
     "execution_count": 52,
     "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.plot(x='name', y='length', kind='barh')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 16) Make a sorted horizontal bar graph of the cats, with the larger cats on top\n",
    "\n",
    "> **TIP:** Think in steps, even though it's all on one line - first make sure you can sort it, then try to graph it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x11d286610>"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "cats.sort_values('length', ascending=True).plot(x='name', y='length', kind='barh', legend=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 17) As a reward for getting down here: run the following code, then plot the number of dogs vs. the number of cats\n",
    "\n",
    "> **TIP:** Counting the number of dogs and number of cats does NOT use `.groupby`! That's only for calculations.\n",
    ">\n",
    "> **TIP:** You can set a title with `title=\"Number of animals\"`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "plt.style.use('fivethirtyeight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x11cd693a0>"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "df.animal.value_counts().plot(kind='barh', title='Number of animals')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}