Lesson_7_Plotting/Lesson_7_Plotting.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "designing-latest",
   "metadata": {},
   "source": [
    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/How-to-Learn-to-Code/python-class/blob/master/Lesson_7_Plotting/plotting_teacher.ipynb)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "addressed-flush",
   "metadata": {},
   "source": [
    "# Lesson 7: Plotting"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "interior-vampire",
   "metadata": {},
   "source": [
    "## Learning Objectives\n",
    "\n",
    "Students will be introduced to `matplotlib` and will learn how to make and customize simple plots. \n",
    "\n",
    "* [Introduction to `matplotlib`](#introduction-to-matplotlib)\n",
    "* [Basics of Plotting](#basics-of-plotting)\n",
    "* [Different Types of Plots](#different-types-of-plots)\n",
    "* [`matplotlib` Figure and Axes](#matplotlib-axes)\n",
    "* [In-Class Exercises](#in-class-exercises)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "005a7f08",
   "metadata": {},
   "source": [
    "### Introduction to `matplotlib` <a id=\"introduction-to-matplotlib\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "independent-growing",
   "metadata": {},
   "source": [
    "`matplotlib` is a Python library used for visualizing data. The [website](https://matplotlib.org/stable/users/index) has a helpful user guide that contains documentation, information on how to get started (including package installation), an overview of plot types, and tutorials. If you are ever stuck or need help figuring out how to make the plot you have in mind, this website is a great place to start.\n",
    "\n",
    "Most of the functions that people use from the `matplotlib` library are in the `pyplot` submodule, and to make it easier to access those functions, it is usually imported as `plt`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "double-signature",
   "metadata": {},
   "outputs": [],
   "source": [
    "#%pip install matplotlib\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c566299c",
   "metadata": {},
   "source": [
    "We'll also be using NumPy in this lesson, so we'll import that as well."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bbaac104",
   "metadata": {},
   "outputs": [],
   "source": [
    "#%pip install numpy\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "994fad79",
   "metadata": {},
   "source": [
    "### Basics of Plotting <a id=\"basics-of-plotting\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "german-penguin",
   "metadata": {},
   "source": [
    "To start plotting, first let's use our NumPy skills to create a vector containing values from 0 to 100:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "opposed-richards",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "0e186081",
   "metadata": {},
   "source": [
    "We can simply use `plt.plot` to plot our values. This function will create a line plot by default, but it'll be on an invisible axis. We can use `plt.show()` to display the plot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "electoral-lafayette",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(x) \n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dedicated-running",
   "metadata": {},
   "source": [
    "Since we passed in only one `np.array`, it assumed our data to be y-values and, in the absence of an x-values list, used [0, 1, 2, 3, ..., 100].\n",
    "\n",
    "We can also pass in two arrays to `plt.plot` to plot x and y values. It will use the first array as x-values and the second as y-values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "white-donor",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.arange(0, 100)\n",
    "y = np.arange(0, 1, 0.01)\n",
    "\n",
    "plt.plot(x, y)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "alternative-lloyd",
   "metadata": {},
   "source": [
    "**Note:** When you pass in two arrays to `plt.plot`, their lengths must match. Here, our arrays both contain 100 values.\n",
    "\n",
    "You can plot multiple curves on the same plot by simply calling `plt.plot` multiple times before calling `plt.show()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "nuclear-breach",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.arange(0, 100)\n",
    "y1 = np.arange(0, 1, 0.01)\n",
    "y2 = np.arange(2, 3, 0.01)\n",
    "\n",
    "plt.plot(x, y1)\n",
    "plt.plot(x, y2)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "changing-woman",
   "metadata": {},
   "source": [
    "Right now, it's hard to tell by glancing which line belongs to which data. We can add labels and show a legend to make it easier to tell them apart"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ongoing-alliance",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(x, y1, label=\"plot 1\")\n",
    "plt.plot(x, y2, label=\"plot 2\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "formal-wisdom",
   "metadata": {},
   "source": [
    "We can also add labels to the axes and a title. Notice that we apply these customizations prior to calling `plt.show()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "automated-circuit",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(x, y1, label=\"plot 1\")\n",
    "plt.plot(x, y2, label=\"plot 2\")\n",
    "plt.xlabel(\"x axis\")\n",
    "plt.ylabel(\"y axis\")\n",
    "plt.title(\"This is a plot of two datasets\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "serious-agency",
   "metadata": {},
   "source": [
    "You can also change the line type (using `linestyle` or `ls`) and color (using `color` or `c`) in the `plt.plot` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "important-peace",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(x, y1, linestyle=\":\", color=\"purple\", label=\"line 1\")\n",
    "plt.plot(x, y2, ls=\"--\", c=\"red\", label=\"line 2\")\n",
    "plt.xlabel(\"x axis\")\n",
    "plt.ylabel(\"y axis\")\n",
    "plt.title(\"This is a plot of two datasets\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eastern-absence",
   "metadata": {},
   "source": [
    "You can change the scaling of either axis by using `xlim` or `ylim` and passing in the minimum and maximum values for that axis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "athletic-husband",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(x, y1, linestyle=\":\", color=\"purple\", label=\"line 1\")\n",
    "plt.plot(x, y2, ls=\"--\", c=\"red\", label=\"line 2\")\n",
    "plt.xlim(0, 60)\n",
    "plt.ylim(0, 2.5)\n",
    "plt.xlabel(\"x axis\")\n",
    "plt.ylabel(\"y axis\")\n",
    "plt.title(\"This is a plot of two datasets\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "exposed-vatican",
   "metadata": {},
   "source": [
    "You can see that this is the same plot as above, except it's more zoomed in because we changed the axes."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "daaeaf0f",
   "metadata": {},
   "source": [
    "### Different Types of Plots <a id=\"different-types-of-plots\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bf51b4af",
   "metadata": {},
   "source": [
    "We can also create scatter plots using `plt.scatter`. This function takes in x and y values, and you can customize the size and color of the points using the `s` and `c` arguments, respectively. `marker` can be used to change the shape of the points."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "later-jordan",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Scatter plot\n",
    "x = np.random.rand(50)\n",
    "y = np.random.rand(50)\n",
    "plt.scatter(x, y, c=\"red\", s=20, marker=\"x\")\n",
    "plt.xlabel(\"x axis\")\n",
    "plt.ylabel(\"y axis\")\n",
    "plt.title(\"Scatter plot\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "feb000f3",
   "metadata": {},
   "source": [
    "We can also create box plots using `plt.boxplot`. This function takes in a list of data arrays and plots them as box plots. You can add labels to the individual box plots for more customizability."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "republican-layout",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Multiple boxplots\n",
    "data1 = np.random.rand(50)\n",
    "data2 = np.random.rand(50)\n",
    "plt.boxplot([data1, data2])\n",
    "plt.ylabel(\"y axis\")\n",
    "plt.xlabel(\"x axis\")\n",
    "plt.xticks([1, 2], [\"data1\", \"data2\"])\n",
    "plt.title(\"Boxplots for two datasets\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8434ee31",
   "metadata": {},
   "source": [
    "We can also create histograms using `plt.hist`. This function takes in a list of data arrays and plots them as histograms. You can customize the number of bins and the color of the bars."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "liable-challenge",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Histogram\n",
    "data = np.random.rand(100)\n",
    "plt.hist(data, bins=10, facecolor='green', edgecolor='black')\n",
    "plt.xlabel(\"x axis\")\n",
    "plt.ylabel(\"y axis\")\n",
    "plt.title(\"Histogram\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c639e83",
   "metadata": {},
   "source": [
    "### `matplotlib` Figure and Axes <a id=\"matplotlib-axes\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "beautiful-partition",
   "metadata": {},
   "source": [
    "In `matplotlib`, there is a distinction between a `Figure` object and something called an `Axes` object (see image below). The figure contains your plots and can be made up of more than one plot. Each plot is inside of an axes object. In all examples so far, we've only had one plot so there was only one axes object inside of each figure. Think of the figure like a sheet of paper. We can draw multiple plots inside of boxes on the paper. The boxes represent the axes object. \n",
    "![Representation of the figure structure in matplotlib](matplotlib_figure.png)\n",
    "\n",
    "Figure from: https://towardsdatascience.com/what-are-the-plt-and-ax-in-matplotlib-exactly-d2cf4bf164a9"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "romantic-explanation",
   "metadata": {},
   "source": [
    "In order to create a figure with multiple subplots dynamically, you can use a `for` loop. The `plt.subplots` function creates a figure and a grid of subplots. You can specify the number of rows and columns in the grid. The function returns a figure object and an array of axes objects. You can then iterate through the axes objects to plot on each subplot. Notice that we call the scatter plot function on the axes object, not on `plt`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "filled-venture",
   "metadata": {},
   "outputs": [],
   "source": [
    "num_rows = 2\n",
    "num_cols = 2\n",
    "count = 0\n",
    "\n",
    "x_data = [np.random.rand(50) for _ in range(num_rows * num_cols)]\n",
    "y_data = [np.random.rand(50) for _ in range(num_rows * num_cols)]\n",
    "\n",
    "fig, axes = plt.subplots(num_rows, num_cols)\n",
    "for row_num in range(num_rows):\n",
    "    for col_num in range(num_cols):\n",
    "        count += 1\n",
    "        ax = axes[row_num][col_num]\n",
    "        ax.scatter(x_data[row_num + col_num], y_data[row_num + col_num])\n",
    "        ax.set_title(f'Subplot {count}')\n",
    "fig.suptitle('Main title')\n",
    "fig.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "crude-entrepreneur",
   "metadata": {},
   "source": [
    "Another way you can do this is to use a different command called `plt.subplot`. The format is `plt.subplot(number of rows, number of columns, plot number)` where the plot number starts at 1 and increments left to right, top to bottom. This command creates a new axes object and sets it as the current axes object. You can then plot on this axes object. In the end, you can call `plt.show()` to display the figure."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "small-bonus",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(16, 12))\n",
    "plt.subplot(3, 1, 1)\n",
    "x = np.random.rand(50)\n",
    "y = np.random.rand(50)\n",
    "plt.scatter(x, y)\n",
    "plt.ylabel(\"y axis\")\n",
    "plt.title(\"Scatter plot\")\n",
    "\n",
    "plt.subplot(3, 1, 2)\n",
    "data = np.random.rand(50)\n",
    "plt.boxplot(data)\n",
    "plt.ylabel(\"y axis\")\n",
    "plt.title(\"Boxplot\")\n",
    "\n",
    "plt.subplot(3, 1, 3)\n",
    "data = np.random.rand(1000)\n",
    "plt.hist(data, bins=10, facecolor='green')\n",
    "plt.xlabel(\"x axis\")\n",
    "plt.ylabel(\"y axis\")\n",
    "plt.title(\"Histogram\")\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "opened-buying",
   "metadata": {},
   "source": [
    "### In-Class Exercises <a id=\"in-class-exercises\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d0b53a50",
   "metadata": {},
   "source": [
    "For these exercises, we'll be using the famous iris flower dataset (https://www.kaggle.com/datasets/arshid/iris-flower-dataset). This dataset contains 150 samples of iris flowers, each with four features: sepal length, sepal width, petal length, and petal width. The flowers belong to one of three species: setosa, versicolor, or virginica."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cordless-catering",
   "metadata": {},
   "outputs": [],
   "source": [
    "!wget https://raw.githubusercontent.com/How-to-Learn-to-Code/python-class/master/Lesson_7_Plotting/IRIS.csv"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aging-album",
   "metadata": {},
   "source": [
    "Use `pandas` to read in the IRIS.csv dataset from the file you just downloaded. (You might need to import `pandas`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "satellite-ebony",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "prompt-michael",
   "metadata": {},
   "source": [
    "Extract the petal_length and petal_width columns and store them in their own variables `petal_length` and `petal_width`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "super-breach",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "collectible-dinner",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "proved-passport",
   "metadata": {},
   "source": [
    "Use `matplotlib` to make a scatter plot of petal length vs petal width. Add an appropriate title and x- and y-axis labels."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "looking-printer",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "small-vietnamese",
   "metadata": {},
   "source": [
    "As mentioned earlier, the iris dataset contains three species of flowers. Use `pandas` to extract the species column and store it in a variable `species`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cb698d25",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "e9e56425",
   "metadata": {},
   "source": [
    "We can use the `unique` method to get the unique values in the species column. Use this method to get the unique species in the dataset. Store the result in a variable `unique_species`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d326ce03",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "6c249472",
   "metadata": {},
   "source": [
    "Use a `for` loop to create a scatter plot of petal length vs petal width for each species. Use a different color for each species. Add an appropriate title and x- and y-axis labels. (Hint: You can get subsets of the dataframe by using `df[df['column_name'] == value]`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a3ab2af3",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "closed-powder",
   "metadata": {},
   "source": [
    "If you want more practice, there are a few basic exercises [here](https://www.w3resource.com/graphics/matplotlib/basic/index.php). There is a built-in text editor for you to use and solutions are given. \n",
    "\n",
    "If you want more challenging exercises, you can try out the plotting exercise [here](https://pynative.com/python-matplotlib-exercise/). The company sales dataset they use is included for download on the page and it has you make a few plot types we didn't cover. They also give solutions, but you'll have to use your own text editor (you could make a notebook in Colab!). "
   ]
  }
 ],
 "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.12.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}