udemy-ML/04-Matplotlib/.ipynb_checkpoints/00-Matplotlib-Basics-checkpoint.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "___\n",
    "\n",
    "<a href='http://www.pieriandata.com'> <img src='../Pierian_Data_Logo.png' /></a>\n",
    "___\n",
    "\n",
    "# MATPLOTLIB\n",
    "\n",
    "----\n",
    "## Matplotlib Basics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Matplotlib is the \"grandfather\" library of data visualization with Python. It was created by John Hunter. He created it to try to replicate MatLab's (another programming language) plotting capabilities in Python. So if you happen to be familiar with matlab, matplotlib will feel natural to you.\n",
    "\n",
    "It is an excellent 2D and 3D graphics library for generating scientific figures. \n",
    "\n",
    "Some of the major Pros of Matplotlib are:\n",
    "\n",
    "* Generally easy to get started for simple plots\n",
    "* Support for custom labels and texts\n",
    "* Great control of every element in a figure\n",
    "* High-quality output in many formats\n",
    "* Very customizable in general\n",
    "\n",
    "Matplotlib allows you to create reproducible figures programmatically. Let's learn how to use it! Before continuing this lecture, I encourage you just to explore the official Matplotlib web page: http://matplotlib.org/\n",
    "\n",
    "## Installation \n",
    "\n",
    "If you are using our environment, its already installed for you. If you are not using our environment (not recommended), you'll need to install matplotlib first with either:\n",
    "\n",
    "    conda install matplotlib\n",
    "or\n",
    "\n",
    "    pip install matplotlib\n",
    "    \n",
    "## Importing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Import the `matplotlib.pyplot` module under the name `plt` (the tidy way):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# COMMON MISTAKE!\n",
    "# DON'T FORGET THE .PYPLOT part\n",
    "\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**NOTE: If you are using an older version of jupyter, you need to run a \"magic\" command to see the plots inline with the notebook. Users of jupyter notebook 1.0 and above, don't need to run the cell below:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**NOTE: For users running .py scripts in an IDE like PyCharm or Sublime Text Editor. You will not see the plots in a notebook, instead if you are using another editor, you'll use: *plt.show()* at the end of all your plotting commands to have the figure pop up in another window.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# Basic Example\n",
    "\n",
    "Let's walk through a very simple example using two numpy arrays:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Basic Array Plot\n",
    "\n",
    "Let's walk through a very simple example using two numpy arrays. You can also use lists, but most likely you'll be passing numpy arrays or pandas columns (which essentially also behave like arrays).\n",
    "\n",
    "**The data we want to plot:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.arange(0,10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = 2*x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  2,  4,  6,  8, 10, 12, 14, 16, 18])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Using Matplotlib with plt.plot() function calls\n",
    "\n",
    "## Basic Matplotlib Commands\n",
    "\n",
    "We can create a very simple line plot using the following ( I encourage you to pause and use Shift+Tab along the way to check out the document strings for the functions we are using)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(x, y) \n",
    "plt.xlabel('X Axis Title Here')\n",
    "plt.ylabel('Y Axis Title Here')\n",
    "plt.title('String Title Here')\n",
    "plt.show() # Required for non-jupyter users , but also removes Out[] info"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Editing more figure parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(x, y) \n",
    "plt.xlabel('X Axis Title Here')\n",
    "plt.ylabel('Y Axis Title Here')\n",
    "plt.title('String Title Here')\n",
    "plt.xlim(0,6) # Lower Limit, Upper Limit\n",
    "plt.ylim(0,12) # Lower Limit, Upper Limit\n",
    "plt.show() # Required for non-jupyter users , but also removes Out[] info"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exporting a plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function savefig in module matplotlib.pyplot:\n",
      "\n",
      "savefig(*args, **kwargs)\n",
      "    Save the current figure.\n",
      "    \n",
      "    Call signature::\n",
      "    \n",
      "      savefig(fname, dpi=None, facecolor='w', edgecolor='w',\n",
      "              orientation='portrait', papertype=None, format=None,\n",
      "              transparent=False, bbox_inches=None, pad_inches=0.1,\n",
      "              frameon=None, metadata=None)\n",
      "    \n",
      "    The output formats available depend on the backend being used.\n",
      "    \n",
      "    Parameters\n",
      "    ----------\n",
      "    \n",
      "    fname : str or PathLike or file-like object\n",
      "        A path, or a Python file-like object, or\n",
      "        possibly some backend-dependent object such as\n",
      "        `matplotlib.backends.backend_pdf.PdfPages`.\n",
      "    \n",
      "        If *format* is not set, then the output format is inferred from\n",
      "        the extension of *fname*, if any, and from :rc:`savefig.format`\n",
      "        otherwise.  If *format* is set, it determines the output format.\n",
      "    \n",
      "        Hence, if *fname* is not a path or has no extension, remember to\n",
      "        specify *format* to ensure that the correct backend is used.\n",
      "    \n",
      "    Other Parameters\n",
      "    ----------------\n",
      "    \n",
      "    dpi : [ *None* | scalar > 0 | 'figure' ]\n",
      "        The resolution in dots per inch.  If *None*, defaults to\n",
      "        :rc:`savefig.dpi`.  If 'figure', uses the figure's dpi value.\n",
      "    \n",
      "    quality : [ *None* | 1 <= scalar <= 100 ]\n",
      "        The image quality, on a scale from 1 (worst) to 95 (best).\n",
      "        Applicable only if *format* is jpg or jpeg, ignored otherwise.\n",
      "        If *None*, defaults to :rc:`savefig.jpeg_quality` (95 by default).\n",
      "        Values above 95 should be avoided; 100 completely disables the\n",
      "        JPEG quantization stage.\n",
      "    \n",
      "    optimize : bool\n",
      "        If *True*, indicates that the JPEG encoder should make an extra\n",
      "        pass over the image in order to select optimal encoder settings.\n",
      "        Applicable only if *format* is jpg or jpeg, ignored otherwise.\n",
      "        Is *False* by default.\n",
      "    \n",
      "    progressive : bool\n",
      "        If *True*, indicates that this image should be stored as a\n",
      "        progressive JPEG file. Applicable only if *format* is jpg or\n",
      "        jpeg, ignored otherwise. Is *False* by default.\n",
      "    \n",
      "    facecolor : color spec or None, optional\n",
      "        The facecolor of the figure; if *None*, defaults to\n",
      "        :rc:`savefig.facecolor`.\n",
      "    \n",
      "    edgecolor : color spec or None, optional\n",
      "        The edgecolor of the figure; if *None*, defaults to\n",
      "        :rc:`savefig.edgecolor`\n",
      "    \n",
      "    orientation : {'landscape', 'portrait'}\n",
      "        Currently only supported by the postscript backend.\n",
      "    \n",
      "    papertype : str\n",
      "        One of 'letter', 'legal', 'executive', 'ledger', 'a0' through\n",
      "        'a10', 'b0' through 'b10'. Only supported for postscript\n",
      "        output.\n",
      "    \n",
      "    format : str\n",
      "        The file format, e.g. 'png', 'pdf', 'svg', ... The behavior when\n",
      "        this is unset is documented under *fname*.\n",
      "    \n",
      "    transparent : bool\n",
      "        If *True*, the axes patches will all be transparent; the\n",
      "        figure patch will also be transparent unless facecolor\n",
      "        and/or edgecolor are specified via kwargs.\n",
      "        This is useful, for example, for displaying\n",
      "        a plot on top of a colored background on a web page.  The\n",
      "        transparency of these patches will be restored to their\n",
      "        original values upon exit of this function.\n",
      "    \n",
      "    bbox_inches : str or `~matplotlib.transforms.Bbox`, optional\n",
      "        Bbox in inches. Only the given portion of the figure is\n",
      "        saved. If 'tight', try to figure out the tight bbox of\n",
      "        the figure. If None, use savefig.bbox\n",
      "    \n",
      "    pad_inches : scalar, optional\n",
      "        Amount of padding around the figure when bbox_inches is\n",
      "        'tight'. If None, use savefig.pad_inches\n",
      "    \n",
      "    bbox_extra_artists : list of `~matplotlib.artist.Artist`, optional\n",
      "        A list of extra artists that will be considered when the\n",
      "        tight bbox is calculated.\n",
      "    \n",
      "    metadata : dict, optional\n",
      "        Key/value pairs to store in the image metadata. The supported keys\n",
      "        and defaults depend on the image format and backend:\n",
      "    \n",
      "        - 'png' with Agg backend: See the parameter ``metadata`` of\n",
      "          `~.FigureCanvasAgg.print_png`.\n",
      "        - 'pdf' with pdf backend: See the parameter ``metadata`` of\n",
      "          `~.backend_pdf.PdfPages`.\n",
      "        - 'eps' and 'ps' with PS backend: Only 'Creator' is supported.\n",
      "    \n",
      "    pil_kwargs : dict, optional\n",
      "        Additional keyword arguments that are passed to `PIL.Image.save`\n",
      "        when saving the figure.  Only applicable for formats that are saved\n",
      "        using Pillow, i.e. JPEG, TIFF, and (if the keyword is set to a\n",
      "        non-None value) PNG.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(plt.savefig)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(x,y)\n",
    "plt.savefig('example.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---------------------\n",
    "\n",
    "--------------------"
   ]
  }
 ],
 "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}