Lesson_7_Plotting/plotting_student.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "alien-continent",
   "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_student.ipynb)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "favorite-lancaster",
   "metadata": {},
   "source": [
    "# Plotting in Python\n",
    "By the end of the lesson you will learn how to make simple plots using the matplotlib library"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "direct-persian",
   "metadata": {},
   "source": [
    "## Learning objectives\n",
    "1. Basics of plotting\n",
    "2. How to scale and color\n",
    "3. Different types of plots\n",
    "    - Scatter plots\n",
    "    - Boxplots\n",
    "    - Histograms\n",
    "4. matplotlib axes\n",
    " \n",
    "We're going to use matplotlib to accomplish these learning objectives"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "departmental-symbol",
   "metadata": {},
   "source": [
    "### What is matplotlib?\n",
    "\n",
    "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 included in the library, and tutorials. If you are 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": "later-camera",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "expensive-branch",
   "metadata": {},
   "source": [
    "To start plotting, first let's create a vector containing values from 0 to 100:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "instant-equality",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "x = np.arange(0, 100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "shaped-geneva",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(x) #use plot to plot our values\n",
    "plt.show() #to show the plot in the notebook"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "physical-southwest",
   "metadata": {},
   "source": [
    "It assumed our single data list to be the y-values and in the absence of an x-values list, [0, 1, 2, 3, ... 100] was used instead"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cooked-organ",
   "metadata": {},
   "outputs": [],
   "source": [
    "y = np.arange(0, 1, 0.01)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "noticed-weekly",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(x, y)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "thirty-namibia",
   "metadata": {},
   "source": [
    "Now we are passing in two lists to ```plt.plot```, which explicitly sets the x-values\n",
    "\n",
    "NOTE: when you pass in two lists to ```plt.plot```, their lengths must match. Here, our lists both contain 100 values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "monetary-telling",
   "metadata": {},
   "outputs": [],
   "source": [
    "y1 = np.arange(0, 1, 0.01)\n",
    "y2 = np.arange(2, 3, 0.01)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "enhanced-karaoke",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(x, y1)\n",
    "plt.plot(x, y2)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "expanded-tractor",
   "metadata": {},
   "source": [
    "You can plot multiple curves on the same plot, but they have to be all the same length\n",
    "\n",
    "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": "daily-narrow",
   "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": "given-writer",
   "metadata": {},
   "source": [
    "We can also add labels to the axes and a title"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "empty-fourth",
   "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": "joined-ferry",
   "metadata": {},
   "source": [
    "You can also change the line type (using ```linestyle```) and color (using ```color```)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "sharp-lunch",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(x, y1, linestyle=\":\", label=\"line 1\") #include linestyle to change the appearance of the line\n",
    "plt.plot(x, y2, color=\"red\", label=\"line 2\") #include color to change the line's color\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": "drawn-fence",
   "metadata": {},
   "source": [
    "You can change the scaling of either axis by using either ```xlim``` or ```ylim```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "designing-separation",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(x, y1, linestyle=\":\", label=\"line 1\")\n",
    "plt.plot(x, y2, color=\"red\", label=\"line 2\")\n",
    "plt.xlim(0, 60) #sets the lower and upper bound of the x axis\n",
    "plt.ylim(0, 2.5) #sets the lower and upper bound of the y axis\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": "wrong-editor",
   "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": "purple-summary",
   "metadata": {},
   "source": [
    "## Other types of plots in matplotlib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "freelance-architecture",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Scatter plot\n",
    "x = np.random.rand(50)\n",
    "y = np.random.rand(50)\n",
    "plt.scatter(x, y)\n",
    "plt.xlabel(\"x axis\")\n",
    "plt.ylabel(\"y axis\")\n",
    "plt.title(\"Scatter plot\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "compressed-diameter",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Boxplot\n",
    "data = np.random.rand(50)\n",
    "plt.boxplot(data)\n",
    "plt.ylabel(\"y axis\")\n",
    "plt.title(\"Boxplot\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ideal-connection",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Multiple boxplots\n",
    "data1 = np.random.rand(50)\n",
    "data2 = np.random.rand(50)\n",
    "\n",
    "# Make a list of the two datasets\n",
    "data = [data1, data2]\n",
    "plt.boxplot(data)\n",
    "plt.ylabel(\"y axis\")\n",
    "plt.title(\"Boxplots for two datasets\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "residential-intent",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Histogram\n",
    "data = np.random.rand(100)\n",
    "plt.hist(data, bins=10, facecolor='green', edgecolor='black')\n",
    "#edgecolor outlines the edges of the bars with a certain color\n",
    "plt.xlabel(\"x axis\")\n",
    "plt.ylabel(\"y axis\")\n",
    "plt.title(\"Histogram\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "annual-methodology",
   "metadata": {},
   "source": [
    "# Plotting multiple graphs in one figure\n",
    "In matplotlib, there is a distinction between a \"figure\" 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 the 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": "sitting-chart",
   "metadata": {},
   "source": [
    "In order to create a figure with multiple subplots dynamically, meaning you create the data for each plot at the same time you're plotting, you can use a ```for``` loop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "drawn-malaysia",
   "metadata": {},
   "outputs": [],
   "source": [
    "num_rows = 2\n",
    "num_cols = 2\n",
    "count = 0\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(np.random.rand(50), np.random.rand(50))\n",
    "        ax.set_title(f'Subplot {count}') \n",
    "        #set_title is used for an axes object, whereas a plt object uses just title\n",
    "fig.suptitle('Main title')\n",
    "fig.tight_layout()\n",
    "plt.show()\n",
    "\n",
    "#code adapted from above towardsdatascience link"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "abroad-twins",
   "metadata": {},
   "source": [
    "The above example used iterative plotting to create and plot multiple plots in a ```for``` loop. However, if you have a set of plots already made that you want to include, you can use a different command called ```subplot```. The format is ```plt.subplot(number of rows, number of columns, plot number)```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cleared-banking",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(16, 12)) #to specify how big the figure should be in order to make it readable\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": "clinical-blade",
   "metadata": {},
   "source": [
    "# In class exercise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "respective-demographic",
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install wget\n",
    "import wget"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "native-stadium",
   "metadata": {},
   "outputs": [],
   "source": [
    "#If running in colab, need to get the IRIS.csv file from github\n",
    "wget.download('https://raw.githubusercontent.com/How-to-Learn-to-Code/python-class/master/Lesson_7_Plotting/IRIS.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "clear-sandwich",
   "metadata": {},
   "source": [
    "Read in the IRIS.csv dataset from the file you just downloaded\n",
    "\n",
    "Dataset from: https://www.kaggle.com/datasets/arshid/iris-flower-dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "other-nickname",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "precise-decision",
   "metadata": {},
   "source": [
    "Extract the petal_length and petal_width columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "negative-engagement",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "charming-convert",
   "metadata": {},
   "source": [
    "Make a scatter plot of petal length vs width\n",
    "\n",
    "Bonus: color the points based on species. (Hint: the scatter plot function has a c option to specify color)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "rental-rating",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "liberal-edgar",
   "metadata": {},
   "source": [
    "Label the x axis \"petal length\" and the y axis \"petal width\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "owned-convenience",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "pregnant-veteran",
   "metadata": {},
   "source": [
    "Title the plot as \"Iris flower petal length vs width\"\n",
    "\n",
    "If you colored by species, include a legend"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "public-bryan",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "rural-fluid",
   "metadata": {},
   "source": [
    "# Homework"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "organizational-steering",
   "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}