week_5.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to Python for Biology\n",
    "# Week 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "-W6mNl-jz2Ry"
   },
   "source": [
    "## Pandas Library"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "N8K03D3yz2Rz"
   },
   "source": [
    "* A data analysis library — **Pan**el **Da**ta **S**ystem.\n",
    "* Created by Wes McKinney in 2009.\n",
    "* Implemented in highly optimized Python/Cython.\n",
    "* Like Excel or R for Python!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "x6dJyD6dz2R0"
   },
   "source": [
    "### Pandas is used for"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "sb9P4Etfz2R2"
   },
   "source": [
    "* Cleaning data/munging.\n",
    "* Exploratory analysis.\n",
    "* Structuring data for plots or tabular display.\n",
    "* Joining disparate sources.\n",
    "* Modeling.\n",
    "* Filtering, extracting, or transforming."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "yALvlVl3z2R4"
   },
   "source": [
    "### Importing Pandas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "UdPcxmbLz2R6"
   },
   "source": [
    "Import Pandas at the top of your notebook. Give it the nickname **pd** so you don't have to keep typing \"pandas.\" (But you can nickname it anything or leave out the nickname)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "fBMvHZAKz2R8"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "JadK8RNzz2SA"
   },
   "source": [
    "### Loading a CSV as a DataFrame"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "OfgT64a5z2SC"
   },
   "source": [
    "Pandas can load many types of files, but one of the most common types is .csv (comma separated values)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "g2GLFOlbz2SD"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "iI2yzKSZz2SJ"
   },
   "source": [
    "This creates a Pandas object called a **DataFrame.**  \n",
    "\n",
    "DataFrames are powerful containers that have lots of built-in functions for exploring and manipulating your data. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ZWCxy8Y-z2SL"
   },
   "source": [
    "### Exploring the data using DataFrames"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "v48riBypz2SM"
   },
   "source": [
    "#### Use .head() to examine the top of the DataFrame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "XOKtVmYez2SO",
    "outputId": "c529f6cd-3315-4468-c5af-0498ee8af209"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "NQyGfvCez2Sa",
    "outputId": "8418cb7c-a0ce-407a-ff69-f21766f20df1"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "gJuD0gsPz2Sf"
   },
   "source": [
    "### Use .tail() to examine the bottom"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "hvYv_b1gz2Sg",
    "outputId": "725a0c77-8664-4d49-db4c-b67096b813bb"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "s6KMDKYbz2Sm"
   },
   "source": [
    "#### The .shape property will tell you how many rows and columns you have"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "JQ-MoCb9z2Sn",
    "outputId": "c1999754-fc2f-4cc8-d846-681af29e6e82"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "sHqREcvBz2St"
   },
   "source": [
    "#### You can look up the names of your columns using the .columns property."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "DNOYz7dbz2Su",
    "outputId": "a6cb9489-4a55-43b6-f2dd-c158bef45961"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "nClLXDf7z2Sy"
   },
   "source": [
    "#### You can access a specific column with bracket syntax (like with dictionaries) using the column's string name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "YNmWEYNPz2S1",
    "outputId": "c83d94dc-98e5-4179-b462-74ef1f63a808"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "7FDHVpoKz2S_"
   },
   "source": [
    "#### You can also access it using dot notation. (When might this not work?)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "uWcKKGZPz2TA",
    "outputId": "7c15ac89-bcab-45a5-eeeb-51f3facfff1b"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Be7M_PYaz2TI",
    "outputId": "c80ee58f-bbd9-45bc-f746-49088bb88902"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "_xvkH0z8z2TN"
   },
   "source": [
    "Notice that this looks a little different than our DataFrame above. That is because it is a Series object. It's a little different than a Dataframe. \n",
    "\n",
    "**What's the difference between Pandas' Series and DataFrame objects?**  \n",
    "Essentially, a Series object contains the data for a single column, and a DataFrame object is a matrix-like container for those Series objects that comprise your data. They mostly act like one another, but occasionaly you'll run into methods that only work for one."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "yWqInwYgz2TO"
   },
   "source": [
    "#### Examining Your Data With .info()  \n",
    "Provides information about:\n",
    "\n",
    "* The name of the column/variable attribute.\n",
    "* The type of index (RangeIndex is default).\n",
    "* The count of non-null values by column/attribute.\n",
    "* The type of data contained in the column/attribute.\n",
    "* The unqiue counts of dtypes (pandas data types).\n",
    "* The memory usage of our data set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "I7j9zdP7z2TR",
    "outputId": "c97cc37b-7e27-4b3f-8dc4-cc570d9c2557"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 891 entries, 0 to 890\n",
      "Data columns (total 12 columns):\n",
      "PassengerId    891 non-null int64\n",
      "Survived       891 non-null int64\n",
      "Pclass         891 non-null int64\n",
      "Name           891 non-null object\n",
      "Sex            891 non-null object\n",
      "Age            714 non-null float64\n",
      "SibSp          891 non-null int64\n",
      "Parch          891 non-null int64\n",
      "Ticket         891 non-null object\n",
      "Fare           891 non-null float64\n",
      "Cabin          204 non-null object\n",
      "Embarked       889 non-null object\n",
      "dtypes: float64(2), int64(5), object(5)\n",
      "memory usage: 83.6+ KB\n"
     ]
    }
   ],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "5LQnDf2Pz2TX"
   },
   "source": [
    "Types affect the way data is represented in machine learning models, whether we can apply math operators to them, etc.   \n",
    "\n",
    "Some common problems with working with a new dataset:  \n",
    "* Missing values.\n",
    "* Unexpected types (string/object instead of int/float).\n",
    "* Dirty data (commas, dollar signs, unexpected characters, etc.).\n",
    "* Blank values that are actually \"non-null\" or single white-space characters."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "srAawUuhz2Te"
   },
   "source": [
    "#### Summarize the data with .describe()\n",
    "It gives us the following statistics:\n",
    "\n",
    "* Count, which is equivalent to the number of cells (rows).\n",
    "* Mean, or, the average of the values in the column.\n",
    "* Std, which is the standard deviation.\n",
    "* Min, a.k.a., the minimum value.\n",
    "* 25%, or, the 25th percentile of the values.\n",
    "* 50%, or, the 50th percentile of the values ( which is the equivalent to the median).\n",
    "* 75%, or, the 75th percentile of the values.\n",
    "* Max, which is the maximum value.  \n",
    "\n",
    "Let's try this on a single column as well as the entire dataframe."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "P9oEeIGsz2Th",
    "outputId": "4b85135c-d979-4957-b1bb-a3d7f9084ca1"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ZgfyKAnlz2To",
    "outputId": "950cba8b-c7ff-4337-c049-ddb31d108cf7"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "wvwEOZ9hz2T2"
   },
   "source": [
    "There are also built-in math functions that will work on all columns of a DataFrame at once, as well as subsets of the data.\n",
    "\n",
    "#### For example, I can use the .mean() function on the titanic DataFrame to get the mean for Age"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "YX782relz2T5",
    "outputId": "125f9311-5d5a-4f20-d477-f8fc5abae6dc"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Filtering and Sorting DataFrames"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load in the drinks dataset (drinks.csv)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Filter drinks to include only European countries."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First we create a series of Booleans"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then we can use this series to filter our dataframe. (This is why we see the `drinks` twice.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Filter drinks to include only European countries with wine_servings > 300."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Filter drinks to include only countries with wine_servings > 300 or beer_servings > 300."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Calculate the mean beer_servings for all of Europe."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Determine which 10 countries have the highest total_litres_of_pure_alcohol."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Which 10 countries have the lowest total_litres_of_pure_alcohol?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Side note: This does not change the underlying data. How can we change the underlying data?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Let's sort by multiple columns. First sort by `beer_servings` then by `wine_servings`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Visualization in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Data visualization is used to explore your data and to communicate your data (early and late in the workflow). My goal for you isn't to make you a data viz wizard, but to give you enough of an understanding to be able to explore your data and jumpstart your own learning.  \n",
    "\n",
    "The **matplotlib** library is great for making simple plots. If you want to make elaborate interactive visualizations, it's probably not for you. But it's good for quick and dirty data viz that is relatively customizable. \n",
    "\n",
    "The **seaborn** library is built on matplotlib and has a lot more \"out-of-the-box\" functionality for quick plots."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Choosing the correct plot\n",
    "We'll match plot type with model \n",
    "<img src=\"assets/chartpicker.jpg\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic MatplotLib `plt.plot(xxx)` Plotting Formula"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* `plt.plot(x, y)` will create your plot. `.plot()` may be replaced with a different type of plot, like `.bar()`\n",
    "* `plt.title(“My Title”)` will add a title “My Title” to your plot\n",
    "\n",
    "* `plt.xlabel(“Year”)` will add a label “Year” to your x-axis\n",
    "\n",
    "* `plt.ylabel(“Population”)` will add a label “Population” to your y-axis\n",
    "\n",
    "* `plt.xticks([1, 2, 3, 4, 5])` set the numbers on the x-axis to be 1, 2, 3, 4, 5. \n",
    "\n",
    "We can also pass and labels as a second argument. For, example, if we use this code `plt.xticks([1, 2, 3, 4, 5], [\"1M\", \"2M\", \"3M\", \"4M\", \"5M\"])`, it will set the labels 1M, 2M, 3M, 4M, 5M on the x-axis.\n",
    "plt.yticks() - works the same as `plt.xticks()`, but for the y-axis."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Line Plot\n",
    "* displays information as a series of data points called “markers” connected by straight lines \n",
    "* need the measurement points to be ordered (typically by their x-axis values) \n",
    "* often used to visualize a trend in data over intervals of time (time series)\n",
    "\n",
    "\n",
    "To make a line plot with Matplotlib, we call `plt.plot()`. \n",
    "\n",
    "The first argument is used for the data on the horizontal axis, and the second is used for the data on the vertical axis. \n",
    "\n",
    "This function generates your plot, but it doesn’t display it. To display the plot, we need to call the `plt.show()` function. This is nice because we might want to add some additional customizations to our plot before we display it. For example, we might want to add labels to the axis and title for the plot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "years = [1974, 1975, 1976, 1977, 1978]\n",
    "total_populations = [8939007, 8954518, 8960387, 8956741, 8943721]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Scatter Plot\n",
    "* shows all individual data points but doesn't connect them with lines\n",
    "* used to display trends or correlations and how 2 variables compare\n",
    "\n",
    "To make a scatter plot with Matplotlib, we can use the `plt.scatter()` function. Again, the first argument is used for the data on the horizontal axis, and the second - for the vertical axis."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Load in the iris dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can save the figure with `.savefig()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Histogram\n",
    "* represents the distribution of numeric data\n",
    "* divide range of values into a series of intervals (AKA bins) and count how many values fall in each interval\n",
    "\n",
    "To make a histogram with Matplotlib, we can use the `plt.hist()` function. The first argument is the numeric data, the second argument is the number of bins. The default value for the bins argument is 10."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers = [0.1, 0.5, 1, 1.5, 2, 4, 5.5, 6, 8, 9]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Box Plot\n",
    "* (AKA box-and-whisker plot) way to show the distribution of values based on the five-number summary: minimum, first quartile, median, third quartile, and maximum\n",
    "* minimum and the maximum are just the min and max values from our data.\n",
    "* median is the value that separates the higher half of a data from the lower half\n",
    "* first quartile is the median of the data values to the left of the median in our ordered values.\n",
    "* third quartile is the median of the data values to the right of the median in our ordered values. (third quartile minus first quartile is refered to as interquartile range)\n",
    "* outlier is a data value that lies outside the overall pattern. There are many ways to identify what is an outlier. A commonly used rule says that a value is an outlier if it’s less than the first quartile - 1.5 * IQR or high than the third quartile + 1.5 * IQR. \n",
    "\n",
    "<img src=\"assets/boxplot.png\"/>\n",
    "\n",
    "To create this plot with Matplotlib we use `plt.boxplot()`. The first argument is the data points."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "values = [1, 2, 5, 6, 6, 7, 7, 8, 8, 8, 9, 10, 21]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Bar chart:\n",
    "* represents categorical data with rectangular bars \n",
    "* each bar has a height corresponds to the value it represents\n",
    "* used when we want to compare a given numeric value on different categories.\n",
    "\n",
    "\n",
    "To make a bar chart with Maplotlib, we’ll need the `plt.bar()` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "languages =['Python', 'SQL', 'Java', 'C++', 'JavaScript']\n",
    "# generating the y positions\n",
    "pos = np.arange(len(languages))\n",
    "popularity = [56, 39, 34, 34, 29]\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pandas Plotting\n",
    "You can also plot directly from a dataframe because Pandas is tightly integrated with MatPlotLib. This is great for when you just need a quick and easy plot of your data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Customizing: Change color and size "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Creating a Scatter Matrix with Pandas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Seaborn\n",
    "Provides a high-level interface for graphics. I find it super useful for Exploratory Data Analysis because it makes it easy to get to know your data quickly.\n",
    "\n",
    "#### Seaborn VS matplotlib\n",
    "* seaborn extends matplotlib, so they can do the same things\n",
    "* matplotlib makes easy things easy and hard things possible\n",
    "* seaborn tries to takes some of those hard things and make them easier to do\n",
    "* seaborn has better defaults (e.g. colors, tick marks, etc.)\n",
    "* seaborn also makes little easier to work with dataframes\n",
    "\n",
    "#### Seaborn's well-defined set of hard things it make easy\n",
    "* using default themes that are aesthetically pleasing.\n",
    "* setting custom color palettes.\n",
    "* making attractive statistical plots.\n",
    "* easily and flexibly displaying distributions.\n",
    "* visualizing information from matrices and DataFrames."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Scatterplots\n",
    "* make a scatter plot is just one line of code using `lmplot()` \n",
    "* pass your DataFrame to the `data=` argument, passing column names to the axes arguments `x=` and `y=`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Scatterplot parameters\n",
    "Seaborn doesn't have a dedicated scatter plot function, which is why you see a diagonal line. We actually used Seaborn's function for fitting and plotting a regression line.\n",
    "\n",
    "**Useful plotting options to set**\n",
    "* Set `fit_reg=False` to remove the regression line, since we only want a scatter plot.\n",
    "* set `hue='species'` to color our points by the species. This hue argument is very useful because it allows you to express a third dimension of information using color."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we want to continue customizing this plot (like tweaking axes), then we can use matplotlib to do these customizations. \n",
    "\n",
    "Let's take a tour of some useful quick seaborn plots."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Pairplot \n",
    "Shows relationships between all variables. I find this one super useful!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Heatmap"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Independent Practice"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load the `drinks.csv` data.  \n",
    "\n",
    "Perform the following:  \n",
    "\n",
    "1. Print the head and tail.\n",
    "2. Look at the index, columns, dtypes, and shape.\n",
    "3. Assign the beer_servings column/Series to a variable.\n",
    "4. Calculate summary statistics for beer_servings.\n",
    "5. Calculate the mean of beer_servings.\n",
    "6. Count the values of unique categories in continent. (.value_counts)\n",
    "7. Print the dimensions of the drinks DataFrame.\n",
    "8. Find the first three items of the value counts of the continent column."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Bonus Problem: Pandas Practice: Filtering "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Using the UFO data (\"ufo.csv\")\n",
    "\n",
    "1. Read in the data.\n",
    "2. Check the shape and describe the columns.\n",
    "3. Find the four most frequently reported colors.\n",
    "4. Find the most frequent city for reports in state VA.\n",
    "5. Find only UFO reports from Arlington, VA.\n",
    "\n",
    "**Extra Bonus Items (check bonus materials for hints)**\n",
    "6. Find the number of missing values in each column.\n",
    "7. Show only UFO reports where city is missing.\n",
    "8. Count the number of rows with no null values.\n",
    "9. Amend column names with spaces to have underscores.\n",
    "10. Make a new column that is a combination of city and state.\n",
    "11. Drop rows where City or Shape Reported is missing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data Viz: Exploring the Titanic Data\n",
    "Explore the data in the `titanic.csv` file using your new knowledge of Seaborn and matplotlib. Be prepared to tell one interesting finding about this dataset (think about what you might want to explore further with modeling and statistics).\n",
    "\n",
    "Stumped? Try looking at survival rates for gender and boarding class. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Bonus Problem: Exploring the Wine Data\n",
    "Explore the data in the `wine.csv` file using your new knowledge of Seaborn and matplotlib. Be prepared to tell one interesting finding about this dataset (think about what you might want to explore further with modeling and statistics).\n",
    "\n",
    "Stumped? Try asking how different variables relate to wine quality."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}