Intro_to_Data_Analysis_final.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Intro to Data Analysis.ipynb",
      "version": "0.3.2",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "metadata": {
        "id": "OhS5qxqQ1e9X",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "# Introduction to Data Analysis with pandas\n",
        "\n",
        "\n",
        "![alt text] [logo1]\n",
        "\n",
        "[logo1]: https://i.pinimg.com/236x/ca/f8/e8/caf8e8b084c55999ca3e5baf7b29c11b--panda-party-baby-shawer.jpg?b=t\n",
        "\n",
        "## jkjk\n",
        "\n",
        "![alt text][logo]\n",
        "\n",
        "[logo]: https://pandas.pydata.org/_static/pandas_logo.png\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "metadata": {
        "id": "qCgSpWIhBNj5",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        ""
      ]
    },
    {
      "metadata": {
        "id": "cXHnuO0K1e9Z",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "## IEEELearn Coding Workshops\n",
        "\n",
        "\n",
        "\n",
        "Welcome to the IEEELearn Python workshops, hope you liked all the workshops from morning! \n",
        "We will now move to the last workshop in this bootcamp, Data Analysis with pandas\n",
        "\n",
        "The scope of this workshop will be limited to Data Wrangling and the syntax of python, as learning analysis would require you to learn algorithms like Regression, for which we don't have enough time. Maybe in the next workshop series :)\n",
        "\n"
      ]
    },
    {
      "metadata": {
        "id": "ZZwqxGPZ1e9a",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "To start off we will import pandas from the library\n"
      ]
    },
    {
      "metadata": {
        "id": "vrBOGdV61e9b",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "import pandas as pd                    #notice the usage of import and the as keyword"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "ba7nmNRy1e9e",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "### Reading data\n",
        "\n",
        "The first step for any data analysis project, is to actually have the data. Data can be stored in many file formats like CSV, XLSX, SQL and so on. So the fundamental operation is to read the data. \n",
        "\n",
        "Before reading data, you need to know how data is stored when we use pandas. There are two important terms to keep in mind \n",
        "\n",
        "1. __Series__ - Series is a sequence of data values. It is analogous to a list which you learnt previously.\n",
        "2. __DataFrame__ - Dataframe is a an array of individual entries. Each entry has a unique row number and cilumn number. This implies that it is analogous to a table in excel, or a 2-D array in general.\n",
        "\n",
        "Dataframe is essentially a collection of series' (which in turn are just columns)\n",
        "\n",
        "We will now create a Dataframe, Series and read data from a CSV file."
      ]
    },
    {
      "metadata": {
        "id": "NMCHxdU71e9f",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "pd.Series([1, 2, 3, 4, 5]) #this creates a column containing the values 1,2,3,4,5"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "aYNZPkwe1e9j",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "pd.Series([50, 60, 70], index=['2017 Sales', '2018 Sales', '2019 Sales'], name='Product A sales report')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "h8CTwO-B1e9m",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Now that we are comfortable with Series, we will move on to DataFrames"
      ]
    },
    {
      "metadata": {
        "id": "oWpymm_B1e9n",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "pd.DataFrame({'Yes': [50, 20], 'No': [30, 90]})"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "RbSTIBvG1e9q",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "pd.DataFrame({'Bob': ['Meh', 'Duh!'], 'Sue': ['Pffftt..', 'Damnn']})"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "gUaEmdjS1e9u",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "pd.DataFrame({'Bob': ['Meh', 'Duh!'], 'Sue': ['Pffftt..', 'Damnn']}, index=['Line 1', 'Line 2'])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "dqyOvjoa1e9x",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "#### Reading CSV files\n",
        "\n",
        "Being able to create a DataFrame and Series by hand is handy. But, most of the time, we won't actually be creating our own data by hand, we'll be working with data that already exists.\n",
        "\n",
        "Data can be stored in any of a number of different forms and formats. \n",
        "\n",
        "By far the most basic of these is the humble CSV file. When you open a CSV file you get something that looks like this\n",
        "\n",
        "CSV stands for Comma Separated Value\n",
        "The following syntax is used to read the csv file stored in a local machine (offline)"
      ]
    },
    {
      "metadata": {
        "id": "okvU5eKv1e9y",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "wine_reviews = pd.read_csv(\"content/winemag-data_first150k.csv\")     #since the csv file is in my local path, I can refer it directly, but for files in some other directory, it is better to use the full path\n",
        "\n",
        "wine_reviews"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "rTsh3Ll71e93",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Incase you want to use a csv file which is online, it can be done in the following way"
      ]
    },
    {
      "metadata": {
        "id": "fyrBIbI91e94",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "url = \"https://raw.githubusercontent.com/stoltzmaniac/wine-reviews-kaggle/master/winemag-data_first150k.csv\"\n",
        "\n",
        "wine_reviews = pd.read_csv(url,index_col = 0)\n",
        "\n",
        "wine_reviews"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "Dp1mmixM1e-A",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "We will now go through some of the common functionalities that can be done on a dataframe after it is loaded\n",
        "\n",
        "Please refer to this cheatsheet for a quick reference at all times. \n",
        "[Pandas Cheatsheet](https://s3.amazonaws.com/assets.datacamp.com/blog_assets/PandasPythonForDataScience.pdf)\n"
      ]
    },
    {
      "metadata": {
        "id": "Uz_k2mEz1e-B",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "wine_reviews.shape     # shape returns the size of the dataframe (rows, colums)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "9xr1Pt6W1e-E",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "wine_reviews.head     # returns the top few results from the dataset\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "rJyAtgPaHHeK",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "## Indexing and Selection of Data \n",
        "\n",
        "If you have a look at the `series` of pandas, it just looks like a fancy `dict`, which was covered in the advanced workshop. \n",
        "\n",
        "We will therefore exploit this feature to perform various operations. \n",
        "\n"
      ]
    },
    {
      "metadata": {
        "id": "hlXP8Bp01e-I",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "wine_reviews.country # both the statements are equivalent, so we can use it as a dict\n",
        "\n",
        "wine_reviews['country']"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "r07xA6enIOxI",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "wine_reviews['country'][1]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "Aq5VEAxSIb2e",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Yes, this is very useful, but pandas provides us with two more powerful operators which help us with indexing and slicing.\n",
        "\n",
        "1.  `loc` - label based selection\n",
        "2. `iloc` - index based selection \n",
        "\n",
        "Let us have a look at `iloc` first. So as mentioned, `iloc` is index based selection. What this essentially implies is that we can access the data by using numerical position.\n"
      ]
    },
    {
      "metadata": {
        "id": "Q6BKbwX6JFLc",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "wine_reviews.iloc[10]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "0TD3B3qDJPGA",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Both `iloc` and `loc` are __row first, column second__"
      ]
    },
    {
      "metadata": {
        "id": "CikCkb_OJdRW",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "wine_reviews.iloc[:,8]  #this will give me the variety of all the wines in the dataset"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "Xhns_Ix-KIN6",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "req_list = [1,5,7,9]\n",
        "\n",
        "wine_reviews.iloc[req_list]\n",
        "\n",
        "#wine_reviews.iloc[req_list,1]\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "dnyC4WgTKneo",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "We will now have a look at the `loc` function.\n",
        "`loc` is a label based selection operator. This uses the data index value and not its numerical position. "
      ]
    },
    {
      "metadata": {
        "id": "OOv8IlDpL4OO",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "wine_reviews.loc[5,'country']"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "XH1NSMiNMKiL",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "wine_reviews.loc[:, ['country','province','variety']]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "LMnNGUzKMZfl",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "wine_reviews.set_index(\"country\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "d-WMjyRONE0N",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "### Conditional selection\n",
        "\n",
        "We use True/False booleans to perform selection"
      ]
    },
    {
      "metadata": {
        "id": "ILCvhz8FNQO6",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "wine_reviews.loc[wine_reviews.country == \"Portugal\"]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "PTDQS6EWNbRm",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "wine_reviews.loc[(wine_reviews.country == \"Portugal\") & (wine_reviews.points >=80)]\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "71-Ea3cv_Pi2",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "## Summarization functions\n",
        "\n",
        "We will now look at a few of the important summarization functions. It can be done by `describe` function\n",
        "\n",
        "We will now obtain the summary of the column `points`"
      ]
    },
    {
      "metadata": {
        "id": "M8ZDWIIk1e-L",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "wine_reviews.points.describe()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "IAYH4awaADit",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "As you can see the `describe` function works for numerical data. What about for string data ? "
      ]
    },
    {
      "metadata": {
        "id": "N42ZtD3I_kgq",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "wine_reviews.country.describe()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "vzGAl-xqBGV4",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "To get the average points, we use the `mean` function. \n",
        "\n",
        "To view the unique values in the dataset, we use the `unique` function\n",
        "\n",
        "To view the frequency of the unique values, we use the `value_counts` function"
      ]
    },
    {
      "metadata": {
        "id": "8IS00Nl5AYsP",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "wine_reviews.points.mean()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "tZVFgQ41BlZP",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "wine_reviews.country.unique()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "KaHeta7aBo-Y",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "wine_reviews.country.value_counts()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "6W0WkVwiC_xw",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Grouping can be used for many purposes. You've already used the `value_counts` function. We can replicate what `value_counts` does using groupby by doing the following:\n",
        "\n"
      ]
    },
    {
      "metadata": {
        "id": "GNJ3cT-ZBvdJ",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "wine_reviews.groupby('country').country.count()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "NS5PBjiPDvW9",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "There are a few __aggregation__ functions we can use with `groupby` to perform operations. \n",
        "A few of them are :\n",
        "+ `max`\n",
        "+ `min`\n"
      ]
    },
    {
      "metadata": {
        "id": "sbN7RnbcDpWx",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "max_points = wine_reviews.groupby('points').price.max()\n",
        "min_points = wine_reviews.groupby('points').price.min()\n",
        "\n",
        "max_points\n",
        "min_points"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "b0f1LbI5F7F4",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Another groupby method worth mentioning is `agg`, which lets you run a bunch of different functions on your DataFrame simultaneously. For example, we can generate a simple statistical summary of the dataset as follows:\n",
        "\n"
      ]
    },
    {
      "metadata": {
        "id": "SjGJ3IHHE5Ua",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "wine_reviews.groupby(['country']).price.agg([len, min, max])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "8kHbGo2bHe1m",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "We will now see something called as `multi-index`. It has multiple levels"
      ]
    },
    {
      "metadata": {
        "id": "NhowV0fdF_1v",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "countries_reviewed = wine_reviews.groupby(['country', 'province']).description.agg([len])\n",
        "countries_reviewed\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "uBsX6IT9Hx-h",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "To convert the multi index to the normal index, we will use the `reset_index` function. "
      ]
    },
    {
      "metadata": {
        "id": "sbTi17wMH5QN",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "countries_reviewed.reset_index()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "IVgFZ-bQIxey",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "## Sorting\n",
        "\n",
        "You can sort the data by using the `sort_values` method"
      ]
    },
    {
      "metadata": {
        "id": "vG0cAIxfH-hb",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "countries_reviewed = countries_reviewed.reset_index()\n",
        "countries_reviewed.sort_values(by='len')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "tSNJfzVxJCDP",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "countries_reviewed.sort_values(by='country', ascending=True)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "VrWIrXLGZguo",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "countries_reviewed.sort_index()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "IME8i5XrcaYn",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "countries_reviewed.sort_values(by=['country','len'])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "tlsK7j6uc3AO",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "FInding the datatype of a variable is very easy. You can also find the datatypes of alll the features at once"
      ]
    },
    {
      "metadata": {
        "id": "rPac_AVgcoYt",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "wine_reviews.price.dtype"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "Rh8wZ5h6dHA1",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "wine_reviews.dtypes"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "cs2Rb0VzdiK_",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "To explicitly convert a variable from one type to another we use `astype` function"
      ]
    },
    {
      "metadata": {
        "id": "bnnjNlvBdQhL",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "wine_reviews.points.astype('float64')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "HnzfPngjeZYk",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Imagine we want to replaec the name US to United States of America. We will now use the `replace` function"
      ]
    },
    {
      "metadata": {
        "id": "DW_k7b6Fd1un",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "wine_reviews.country.replace('US','United States of America')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "oxzGJC6oewZT",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "# Plotting of Data\n",
        "\n",
        "## Univariate plotting with pandas"
      ]
    },
    {
      "metadata": {
        "id": "rD7h9dIdertk",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "wine_reviews['country'].value_counts().head(10).plot.bar()\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "hiq-7aOrfW2o",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Let us now calculate the number of reviews with the range of points\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "metadata": {
        "id": "XQYjs0d_fFda",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "wine_reviews['points'].value_counts().sort_index().plot.bar()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "TPnbK4AKftpQ",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "wine_reviews['points'].value_counts().sort_index().plot.line()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "dNRk77E6ftxr",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "wine_reviews['points'].value_counts().sort_index().plot.area()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "eq2NV-oZga7F",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "The charts above work well for all the discrete variables. What if I want to plot a interval variable (eg: 10-20).We would have to plot a histogram and such graphs."
      ]
    },
    {
      "metadata": {
        "id": "NTLawFQTfj-X",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "wine_reviews['points'].plot.hist()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "qBVUwoO_h-7Q",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "## Bivariate plotting with pandas"
      ]
    },
    {
      "metadata": {
        "id": "3-TkXE9dirVq",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        ""
      ]
    },
    {
      "metadata": {
        "id": "I3xVrnQcizOP",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "# Bivariate plotting with pandas\n",
        "\n",
        "<table>\n",
        "<tr>\n",
        "<td><img src=\"https://i.imgur.com/bBj1G1v.png\" width=\"350px\"/></td>\n",
        "<td><img src=\"https://i.imgur.com/ChK9zR3.png\" width=\"350px\"/></td>\n",
        "</tr>\n",
        "<tr>\n",
        "<td style=\"font-weight:bold; font-size:16px;\">Scatter Plot</td>\n",
        "<td style=\"font-weight:bold; font-size:16px;\">Hex Plot</td>\n",
        "</tr>\n",
        "<tr>\n",
        "<td>df.plot.scatter()</td>\n",
        "<td>df.plot.hexbin()</td>\n",
        "</tr>\n",
        "<tr>\n",
        "<td>Good for interval and some nominal categorical data.</td>\n",
        "<td>Good for interval and some nominal categorical data.</td>\n",
        "</tr>\n",
        "</table>"
      ]
    },
    {
      "metadata": {
        "id": "tFl-eCZGhnjH",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "wine_reviews[wine_reviews['price'] < 100].sample(100).plot.scatter(x='price', y='points')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "KB7lXSDBjLmh",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "A  **hex plot** aggregates points in space into hexagons, and then colors those hexagons based on the values within them:"
      ]
    },
    {
      "metadata": {
        "id": "ZKQau0HaiW3e",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "wine_reviews[wine_reviews['price'] < 100].plot.hexbin(x='price', y='points', gridsize=15)\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "Q9HQ5hHijOYP",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}