21. Matplotlib.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*********************************************************************************************************\n",
    "# A Tour of Python 3  \n",
    "version 1.0.1  \n",
    "Authors: Phil Pfeiffer, Zack Bunch, and Feyisayo Oyeniyi  \n",
    "East Tennessee State University  \n",
    "Last updated June 2021  \n",
    "\n",
    "Chapter 21: author Edgar Bowlin; ed. Phil Pfeiffer  \n",
    "*********************************************************************************************************"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 21. Matplotlib  \n",
    " 21.1 [Overview](#Matplotlib-Overview)  \n",
    " 21.2 [Plotting using Pyplot](#Matplotlib-Pyplot)  \n",
    " 21.3 [Object-Oriented Plot Creation](#Matplotlib-OO-Approach)  \n",
    " 21.4 [Three Dimensional Bar Graphs](#Matplotlib-3d-graph)  \n",
    " 21.5 [Three Dimensional Surface Graphs](#Matplotlib-3d-graph-surface)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 21.1  Overview <a name='Matplotlib-Overview'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Matplotlib is a third-party, open-source module that allows its users to create intricate graphs using Python. John Hunter originally created it.\n",
    "\n",
    "Matplotlib's simple function calls allow for greater control of graphs and their formats than Excel. ",
    "The freedom of Python allows for easier manipulation of a wider variety of data formats.\n",
    "\n",
    "Matplotlib is not included in the standard Python installation. To install Matplotlib and its dependencies, first install `pip`, if you have not yet so. ",
    "Then add `pip` to your system's Path directory. ",
    "Finally, run the following command in your system's command line interpreter:\n",
    "\n",
    "            pip -m install matplotlib\n",
    "\n",
    "One of Matplotlib's dependencies, NumPy, is used extensively within this unit. ",
    "Most Matplotlib functions accept a list-like structure expect that structure to be a NumPy array. ",
    "Other data structures may cause undefined behavior.\n",
    "\n",
    "When `%matplotlib notebook` is missing from the Notebook's code section, Matplotlib runs non-interactively. ",
    "Otherwise, Matplotlib plots are interactive. For three-dimensional graphs, interactive operation allows users to rotate graphs. ",
    "When Python is run in a command line interpreter on a Windows 10 machine, plots are interactive by default.\n",
    "\n",
    "This unit does not cover Matplotlib in depth. For more information, see the [Matplotlib official documentation.](https://matplotlib.org/stable/contents.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 21.2  Plotting using Pyplot <a name='Matplotlib-Pyplot'></a> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using  `axes.plot`, Matplotlib users can generate a two-dimensional plot with relatively little work. ",
    "This approach is particularly well suited for creating isolated instances of simple graphs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 21.2  Create a simple two-dimensional plot using py plot.\n",
    "\n",
    "%matplotlib notebook\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "def printcoordinates(x,y):\n",
    "  returnable = \"\\n\"\n",
    "  for i in range(x.size):\n",
    "    returnable += f\"({x[i]},{y[i]})\\n\"\n",
    "  return returnable\n",
    "\n",
    "x = np.arange(0,100,10) # Set the plot's x coordinates, np.arrange() returns a numpy array of equally spaced numbers\n",
    "                        # given a start position, stop position, and the increment as seen in this function call. \n",
    "                        # The returned array allows for element-by-element operations\n",
    "\n",
    "y = x*x                 # Set the y coordinates based on the x coordinates. This notation implies element-by-element operations\n",
    "\n",
    "print(f\"These are the coordinates: {printcoordinates(x,y)}\")\n",
    "\n",
    "# Create the subplot to store the plot based on the above coordinates.\n",
    "axis = plt.subplot()  \n",
    "\n",
    "# Let pyplot take the coordinate data and create a plot, set some traits using named parameters.\n",
    "axis.plot(x, y,color='green', marker=\".\", linestyle=\":\")\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Matplotlib functions expect NumPy arrays. To use a list as a basis for a plot, use `np.array()` to convert it to an equivalent NumPy array."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color:blue'>",
    "&#128073;&ensp;&ensp;**Exercise 21.2.1:**\n\n",
    "</span>",
    "<span style='color:navy' >",
    "In the following code cell, ",
    "copy the previous example's code and create a graph plotting the first ten values of the Fibonacci series. ",
    "</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 21.3 Object-Oriented Plot Creation <a name='Matplotlib-OO-Approach'></a> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Matplotlib provides Object-Oriented (OO) resources for creating more elaborate plots. These resources include the following three classes:\n",
    "- *Figure* contains all the objects required to form a full graph. These include an axes object, a set of axis objects, and a canvas object, ",
    " which draws everything to the screen. The canvas object's operation is largely transparent to Matplotlib users.\n",
    "- *Axes* objects control a plot's global attributes. Calls to Figure.subplot add or retrieve them from Figures.\n",
    "- *Axis* objects are contained in Axes objects. ",
    "They define a number line-like objects that specify a plot's axes and its settings such as its label and ticks.\n",
    "\n",
    "Matplotlib's OO resources are more suitable for projects that require similar graphs made with differing data. ",
    "They allow for reuse of code and reduce the time to format individual plots. ",
    "The following example demonstrates a more granular approach to creating these plots."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 21.3  Create a two-dimensional plot using Matplotlib classes.\n",
    "\n",
    "%matplotlib notebook\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import math\n",
    "\n",
    "def printcoordinates(x,y):\n",
    "  returnable = \"\\n\"\n",
    "  for i in range(x.size):\n",
    "    returnable += f\"({x[i]},{y[i]})\\n\"\n",
    "  return returnable\n",
    "\n",
    "#use this function to create plots placed within a given figure\n",
    "def createsubplot(fig1, figure_id,xdata, ydata, title):     \n",
    "  ax = fig1.add_subplot(figure_id)                        # create an axes object to plot the data on\n",
    "  ax.plot(xdata, ydata, marker=\".\", linestyle=\":\")        # Generate the plot\n",
    "  ax.set_xlabel('X-Axis')\n",
    "  ax.set_ylabel('Y-Axis')                                 # Label its x and y axes\n",
    "  ax.set_title(title)                                     # Set its title\n",
    "  plt.grid(True)                                          # Make the grid visible\n",
    "\n",
    "# Define x coordinates and their associated y values to plot below\n",
    "x = np.arange(1,100,10)                 \n",
    "y = np.array([math.log(i) for i in x])  \n",
    "\n",
    "# Create and show a plot for a first graph with linear scaling\n",
    "fig1 = plt.figure()  \n",
    "createsubplot(fig1,111,x,y,\"Linear Scaled Plot\")          # create a plot for the first graph\n",
    "plt.show()                                                # show it\n",
    "\n",
    "# Create and show a plot for a second graph with log scaling along its y axis\n",
    "fig1 = plt.figure()                                       # create a new figure so the graphs will display separately\n",
    "createsubplot(fig1,111,x,y,\"Y Log Scaled Plot\")           # create a plot for the second graph\n",
    "plt.yscale('log')                                         # set the y-axis scaling to a log base 10 scaling\n",
    "plt.show()                                                # show the second graph\n",
    "\n",
    "# Create and show a plot for a third graph with log scaling along its x axis\n",
    "fig1 = plt.figure()                                       # create a new figure so the graphs will display separately\n",
    "createsubplot(fig1,111,x,y,\"X Log Scaled Plot\")           # create a plot for the third graph\n",
    "plt.xscale(\"log\")                                         # Set the x-axis scaling to a log base 10 scaling\n",
    "\n",
    "plt.show()                                                # Display the figure\n",
    "print(f\"These are the coordinates: {printcoordinates(x,y)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color:blue'>",
    "&#128073;&ensp;&ensp;**Exercise 21.3.1:**\n\n",
    "</span>",
    "<span style='color:navy' >",
    "In the following code cell, ",
    "Graph the function $y = 2^x + 5$ on both a log base 10 y-scaling plot and a linear y-scaling plot from 1 to 10 in increments of one. ",
    "Title the figures \"Powers of Two\" and \"Powers of Two, Y-log-scaled\" respectively.",
    "</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
   "scrolled": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 21.4 Three Dimensional Bar Graphs <a name='Matplotlib-3d-graph'></a> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Matplotlib can be used to create three dimensional graphs. ",
    "For bar graphs, the `axes.bar3d()` method allows users to manage each bar's coordinates and volumes. ",
    "The next example uses the following four NumPy functions:\n",
    "- `np.flatten()` creates a new one-dimensional array that represents the given matrices in a row major format\n",
    "- `np.ones()` generates an array that mimics the shape of this given matrix, but all elements are set to one\n",
    "- `np.zeros()` generates an array that mimics the shape of this given matrix, but all elements are set to zero\n",
    "- `np.meshgrid()` generates two matrices, the coordinate matrix and the coordinate vectors, of the two supplied arrays.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# 21.4.  Create a three-dimensional bar graph using Matplotlib classes.\n",
    "%matplotlib notebook\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import random\n",
    "\n",
    "def create3dbarchart(rows, columns, plot_title, x_axis_title, y_axis_title, z_axis_title):\n",
    "  number_of_rows = rows\n",
    "  number_of_columns = columns\n",
    "\n",
    "  x = np.array(range(0,number_of_rows),float)      # Set the number of rows of bars\n",
    "  y = np.array(range(0,number_of_columns),float)   # Set the number of columns in a row.\n",
    "  Y, X = np.meshgrid(y, x)                         # Return the coordinate matrices and coordinate vectors.\n",
    "\n",
    "  # Determines the bar's heights.\n",
    "  data = np.array([[random.randint(0,100) for i in range(number_of_columns)] for i in range(number_of_rows)]) \n",
    "\n",
    "  # Plotting.\n",
    "  fig = plt.figure()\n",
    "  ax = fig.add_subplot(projection='3d')            # sets the figure to display in a three dimensional projection.\n",
    "\n",
    "  # Defines the bars' coordinates.\n",
    "  xcoordinates = Y.flatten()                       # Create a row-major vector representation from a multidimensional array.\n",
    "  ycoordinates = X.flatten()  \n",
    "  zcoordinates = np.zeros(data.size)               # Return a zero matrix of the same size as the given matrix.\n",
    "\n",
    "  # Specify the bars' widths, depths, and heights.\n",
    "  dx = .25 * np.ones(data.size) \n",
    "  dy = .25 * np.ones(data.size) \n",
    "  dz = data.flatten()\n",
    "  ax.set_title(plot_title)\n",
    "  ax.set_xlabel(x_axis_title)\n",
    "  ax.set_ylabel(y_axis_title)\n",
    "  ax.set_zlabel(z_axis_title)\n",
    "  ax.set_xticks(y)  # Set X-axis ticks according to the numbers found in x\n",
    "  ax.bar3d(xcoordinates, ycoordinates, zcoordinates, dx, dy, dz, color = 'green')     # Generate the graph\n",
    "\n",
    "create3dbarchart(4,5,\"Random Bars\",\"x-axis\",\"y-axis\",\"z-axis\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color:blue'>",
    "&#128073;&ensp;&ensp;**Exercise 21.4.1:**\n\n",
    "</span>",
    "<span style='color:navy' >",
    "In the following code cell, ",
    " create a three-dimensional bar graph using the following z-coordinates:\n",
    "\n",
    "[[2,4,8,16],\n",
    " [32, 64, 128, 256]]\n",
    " \n",
    "Modify the previous example to accept an array for the heights of the bars.",
    "</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 21.5 Three Dimensional Surface Graphs <a name='Matplotlib-3d-graph-surface'></a> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Matplotlib's `Axes.plot_surface()` method creates surface graphs. ",
    "This function has a smaller signature than the previous example and requires less code to create. ",
    "The following example demonstrates the creation of a saddle shaped surface. \n",
    "\n",
    "The `np.outer()` function call seen here returns the outer product of the given NumPy arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 21.5.a  Create a three-dimensional surface plot using the OO method.\n",
    "\n",
    "%matplotlib notebook\n",
    "from mpl_toolkits import mplot3d\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "def plotsurface(x_lower_limit,x_upper_limit, granularity):\n",
    "  x = np.outer(np.linspace(x_lower_limit, x_upper_limit, granularity), np.ones(granularity)) \n",
    "\n",
    "  y = x.copy().T                                      # returns the transpose of matrix x\n",
    "  z = x ** 2 -  y ** 2                                # define function to plot\n",
    "\n",
    "  fig = plt.figure()\n",
    "  ax = plt.axes(projection='3d')\n",
    "  ax.plot_surface(x, y, z)\n",
    "  ax.set_title('Saddle plot')\n",
    "\n",
    "plotsurface(-1,1,10)  \n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color:blue'>",
    "&#128073;&ensp;&ensp;**Exercise 21.5.1:**\n\n",
    "</span>",
    "<span style='color:navy' >",
    "In the following code cell, create a three-dimensional surface graph that satisfies the following requirements:</span>\n",
    "- <span style='color:navy' >The x-axis ranges from -50 to 50.</span>\n",
    "- <span style='color:navy' >The axes are appropriately labelled X, Y, and Z.</span>\n",
    "- <span style='color:navy' >No tick marks are shown.</span>\n",
    "- <span style='color:navy' >Change the function determining Z and create your own surface function.</span>\n",
    "- <span style='color:navy' >Change the title of the plot to something more appropriate for the new surface function.</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}