Day11_25Sept2020/Day11_25Sept2020_Matplotlib_Cont.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href=\"https://apssdc.in\"><img src=\"https://drive.google.com/uc?export=download&id=15AKQ6_-BixW4K6mL6RPphF5EKXqYF2zj\" width=\"800\" align=\"center\"></a>\n",
    "\n",
    "<h1><center> Data Analysis Using Python Day11</h1></center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Visualization using Matplotlib and Seaborn"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Normalization\n",
    "- Data Imputation - Fill the Missing Values - mean, median, most frequent, constant\n",
    "- Matplotlib\n",
    "- line Plot - identify the changes in the data \n",
    "- Scatter - find the relationship between 2 variable\n",
    "- Bar Graph - count Categorical data\n",
    "- Text"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 11 Objectives\n",
    "- Sub plots\n",
    "- Bar Graphs\n",
    "- Histogram\n",
    "- Pie chart\n",
    "- Box plot\n",
    "- Seaborn\n",
    "- Styles\n",
    "- Color Palletes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sub Plots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 6 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "ax = plt.subplots(2, 3) # row, colum\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function subplots in module matplotlib.pyplot:\n",
      "\n",
      "subplots(nrows=1, ncols=1, sharex=False, sharey=False, squeeze=True, subplot_kw=None, gridspec_kw=None, **fig_kw)\n",
      "    Create a figure and a set of subplots.\n",
      "    \n",
      "    This utility wrapper makes it convenient to create common layouts of\n",
      "    subplots, including the enclosing figure object, in a single call.\n",
      "    \n",
      "    Parameters\n",
      "    ----------\n",
      "    nrows, ncols : int, optional, default: 1\n",
      "        Number of rows/columns of the subplot grid.\n",
      "    \n",
      "    sharex, sharey : bool or {'none', 'all', 'row', 'col'}, default: False\n",
      "        Controls sharing of properties among x (`sharex`) or y (`sharey`)\n",
      "        axes:\n",
      "    \n",
      "        - True or 'all': x- or y-axis will be shared among all subplots.\n",
      "        - False or 'none': each subplot x- or y-axis will be independent.\n",
      "        - 'row': each subplot row will share an x- or y-axis.\n",
      "        - 'col': each subplot column will share an x- or y-axis.\n",
      "    \n",
      "        When subplots have a shared x-axis along a column, only the x tick\n",
      "        labels of the bottom subplot are created. Similarly, when subplots\n",
      "        have a shared y-axis along a row, only the y tick labels of the first\n",
      "        column subplot are created. To later turn other subplots' ticklabels\n",
      "        on, use `~matplotlib.axes.Axes.tick_params`.\n",
      "    \n",
      "    squeeze : bool, optional, default: True\n",
      "        - If True, extra dimensions are squeezed out from the returned\n",
      "          array of `~matplotlib.axes.Axes`:\n",
      "    \n",
      "          - if only one subplot is constructed (nrows=ncols=1), the\n",
      "            resulting single Axes object is returned as a scalar.\n",
      "          - for Nx1 or 1xM subplots, the returned object is a 1D numpy\n",
      "            object array of Axes objects.\n",
      "          - for NxM, subplots with N>1 and M>1 are returned as a 2D array.\n",
      "    \n",
      "        - If False, no squeezing at all is done: the returned Axes object is\n",
      "          always a 2D array containing Axes instances, even if it ends up\n",
      "          being 1x1.\n",
      "    \n",
      "    num : int or str, optional, default: None\n",
      "        A `.pyplot.figure` keyword that sets the figure number or label.\n",
      "    \n",
      "    subplot_kw : dict, optional\n",
      "        Dict with keywords passed to the\n",
      "        `~matplotlib.figure.Figure.add_subplot` call used to create each\n",
      "        subplot.\n",
      "    \n",
      "    gridspec_kw : dict, optional\n",
      "        Dict with keywords passed to the `~matplotlib.gridspec.GridSpec`\n",
      "        constructor used to create the grid the subplots are placed on.\n",
      "    \n",
      "    **fig_kw\n",
      "        All additional keyword arguments are passed to the\n",
      "        `.pyplot.figure` call.\n",
      "    \n",
      "    Returns\n",
      "    -------\n",
      "    fig : `~.figure.Figure`\n",
      "    \n",
      "    ax : `.axes.Axes` object or array of Axes objects.\n",
      "        *ax* can be either a single `~matplotlib.axes.Axes` object or an\n",
      "        array of Axes objects if more than one subplot was created.  The\n",
      "        dimensions of the resulting array can be controlled with the squeeze\n",
      "        keyword, see above.\n",
      "    \n",
      "        Typical idioms for handling the return value are::\n",
      "    \n",
      "            # using the variable ax for single a Axes\n",
      "            fig, ax = plt.subplots()\n",
      "    \n",
      "            # using the variable axs for multiple Axes\n",
      "            fig, axs = plt.subplots(2, 2)\n",
      "    \n",
      "            # using tuple unpacking for multiple Axes\n",
      "            fig, (ax1, ax2) = plt.subplot(1, 2)\n",
      "            fig, ((ax1, ax2), (ax3, ax4)) = plt.subplot(2, 2)\n",
      "    \n",
      "        The names ``ax`` and pluralized ``axs`` are preferred over ``axes``\n",
      "        because for the latter it's not clear if it refers to a single\n",
      "        `~.axes.Axes` instance or a collection of these.\n",
      "    \n",
      "    Examples\n",
      "    --------\n",
      "    ::\n",
      "    \n",
      "        # First create some toy data:\n",
      "        x = np.linspace(0, 2*np.pi, 400)\n",
      "        y = np.sin(x**2)\n",
      "    \n",
      "        # Create just a figure and only one subplot\n",
      "        fig, ax = plt.subplots()\n",
      "        ax.plot(x, y)\n",
      "        ax.set_title('Simple plot')\n",
      "    \n",
      "        # Create two subplots and unpack the output array immediately\n",
      "        f, (ax1, ax2) = plt.subplots(1, 2, sharey=True)\n",
      "        ax1.plot(x, y)\n",
      "        ax1.set_title('Sharing Y axis')\n",
      "        ax2.scatter(x, y)\n",
      "    \n",
      "        # Create four polar axes and access them through the returned array\n",
      "        fig, axs = plt.subplots(2, 2, subplot_kw=dict(polar=True))\n",
      "        axs[0, 0].plot(x, y)\n",
      "        axs[1, 1].scatter(x, y)\n",
      "    \n",
      "        # Share a X axis with each column of subplots\n",
      "        plt.subplots(2, 2, sharex='col')\n",
      "    \n",
      "        # Share a Y axis with each row of subplots\n",
      "        plt.subplots(2, 2, sharey='row')\n",
      "    \n",
      "        # Share both X and Y axes with all subplots\n",
      "        plt.subplots(2, 2, sharex='all', sharey='all')\n",
      "    \n",
      "        # Note that this is the same as\n",
      "        plt.subplots(2, 2, sharex=True, sharey=True)\n",
      "    \n",
      "        # Create figure number 10 with a single subplot\n",
      "        # and clears it if it already exists.\n",
      "        fig, ax = plt.subplots(num=10, clear=True)\n",
      "    \n",
      "    See Also\n",
      "    --------\n",
      "    .pyplot.figure\n",
      "    .pyplot.subplot\n",
      "    .pyplot.axes\n",
      "    .Figure.subplots\n",
      "    .Figure.add_subplot\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(plt.subplots)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x19fe348e970>]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = np.array([1, 2, 3, 4, 5])\n",
    "\n",
    "plt.subplot(2, 2, 1) #row, column, index\n",
    "plt.plot(x, x **2, marker = '>', c = 'g')\n",
    "plt.plot(x, x ** 0.5, marker = '<', c = 'b')\n",
    "plt.xlabel('Y = X **2')\n",
    "plt.title('Subplot one')\n",
    "plt.legend(['Y = X ** 2', 'Y = X ** 0.5'])\n",
    "plt.subplot(2,2,2)\n",
    "plt.plot(x, x ** 3)\n",
    "plt.subplot(2,2,3)\n",
    "plt.plot(x, np.sin(x))\n",
    "plt.subplot(2,2,4)\n",
    "plt.plot(x, np.exp(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function bar in module matplotlib.pyplot:\n",
      "\n",
      "bar(x, height, width=0.8, bottom=None, *, align='center', data=None, **kwargs)\n",
      "    Make a bar plot.\n",
      "    \n",
      "    The bars are positioned at *x* with the given *align*\\ment. Their\n",
      "    dimensions are given by *width* and *height*. The vertical baseline\n",
      "    is *bottom* (default 0).\n",
      "    \n",
      "    Each of *x*, *height*, *width*, and *bottom* may either be a scalar\n",
      "    applying to all bars, or it may be a sequence of length N providing a\n",
      "    separate value for each bar.\n",
      "    \n",
      "    Parameters\n",
      "    ----------\n",
      "    x : sequence of scalars\n",
      "        The x coordinates of the bars. See also *align* for the\n",
      "        alignment of the bars to the coordinates.\n",
      "    \n",
      "    height : scalar or sequence of scalars\n",
      "        The height(s) of the bars.\n",
      "    \n",
      "    width : scalar or array-like, optional\n",
      "        The width(s) of the bars (default: 0.8).\n",
      "    \n",
      "    bottom : scalar or array-like, optional\n",
      "        The y coordinate(s) of the bars bases (default: 0).\n",
      "    \n",
      "    align : {'center', 'edge'}, optional, default: 'center'\n",
      "        Alignment of the bars to the *x* coordinates:\n",
      "    \n",
      "        - 'center': Center the base on the *x* positions.\n",
      "        - 'edge': Align the left edges of the bars with the *x* positions.\n",
      "    \n",
      "        To align the bars on the right edge pass a negative *width* and\n",
      "        ``align='edge'``.\n",
      "    \n",
      "    Returns\n",
      "    -------\n",
      "    container : `.BarContainer`\n",
      "        Container with all the bars and optionally errorbars.\n",
      "    \n",
      "    Other Parameters\n",
      "    ----------------\n",
      "    color : scalar or array-like, optional\n",
      "        The colors of the bar faces.\n",
      "    \n",
      "    edgecolor : scalar or array-like, optional\n",
      "        The colors of the bar edges.\n",
      "    \n",
      "    linewidth : scalar or array-like, optional\n",
      "        Width of the bar edge(s). If 0, don't draw edges.\n",
      "    \n",
      "    tick_label : str or array-like, optional\n",
      "        The tick labels of the bars.\n",
      "        Default: None (Use default numeric labels.)\n",
      "    \n",
      "    xerr, yerr : scalar or array-like of shape(N,) or shape(2, N), optional\n",
      "        If not *None*, add horizontal / vertical errorbars to the bar tips.\n",
      "        The values are +/- sizes relative to the data:\n",
      "    \n",
      "        - scalar: symmetric +/- values for all bars\n",
      "        - shape(N,): symmetric +/- values for each bar\n",
      "        - shape(2, N): Separate - and + values for each bar. First row\n",
      "          contains the lower errors, the second row contains the upper\n",
      "          errors.\n",
      "        - *None*: No errorbar. (Default)\n",
      "    \n",
      "        See :doc:`/gallery/statistics/errorbar_features`\n",
      "        for an example on the usage of ``xerr`` and ``yerr``.\n",
      "    \n",
      "    ecolor : scalar or array-like, optional, default: 'black'\n",
      "        The line color of the errorbars.\n",
      "    \n",
      "    capsize : scalar, optional\n",
      "       The length of the error bar caps in points.\n",
      "       Default: None, which will take the value from\n",
      "       :rc:`errorbar.capsize`.\n",
      "    \n",
      "    error_kw : dict, optional\n",
      "        Dictionary of kwargs to be passed to the `~.Axes.errorbar`\n",
      "        method. Values of *ecolor* or *capsize* defined here take\n",
      "        precedence over the independent kwargs.\n",
      "    \n",
      "    log : bool, optional, default: False\n",
      "        If *True*, set the y-axis to be log scale.\n",
      "    \n",
      "    orientation : {'vertical',  'horizontal'}, optional\n",
      "        *This is for internal use only.* Please use `barh` for\n",
      "        horizontal bar plots. Default: 'vertical'.\n",
      "    \n",
      "    See also\n",
      "    --------\n",
      "    barh: Plot a horizontal bar plot.\n",
      "    \n",
      "    Notes\n",
      "    -----\n",
      "    The optional arguments *color*, *edgecolor*, *linewidth*,\n",
      "    *xerr*, and *yerr* can be either scalars or sequences of\n",
      "    length equal to the number of bars.  This enables you to use\n",
      "    bar as the basis for stacked bar charts, or candlestick plots.\n",
      "    Detail: *xerr* and *yerr* are passed directly to\n",
      "    :meth:`errorbar`, so they can also have shape 2xN for\n",
      "    independent specification of lower and upper errors.\n",
      "    \n",
      "    Other optional kwargs:\n",
      "    \n",
      "    Properties:\n",
      "        agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      "        alpha: float or None\n",
      "        animated: bool\n",
      "        antialiased or aa: unknown\n",
      "        capstyle: {'butt', 'round', 'projecting'}\n",
      "        clip_box: `.Bbox`\n",
      "        clip_on: bool\n",
      "        clip_path: Patch or (Path, Transform) or None\n",
      "        color: color\n",
      "        contains: callable\n",
      "        edgecolor or ec: color or None or 'auto'\n",
      "        facecolor or fc: color or None\n",
      "        figure: `.Figure`\n",
      "        fill: bool\n",
      "        gid: str\n",
      "        hatch: {'/', '\\\\', '|', '-', '+', 'x', 'o', 'O', '.', '*'}\n",
      "        in_layout: bool\n",
      "        joinstyle: {'miter', 'round', 'bevel'}\n",
      "        label: object\n",
      "        linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}\n",
      "        linewidth or lw: float or None\n",
      "        path_effects: `.AbstractPathEffect`\n",
      "        picker: None or bool or float or callable\n",
      "        rasterized: bool or None\n",
      "        sketch_params: (scale: float, length: float, randomness: float)\n",
      "        snap: bool or None\n",
      "        transform: `.Transform`\n",
      "        url: str\n",
      "        visible: bool\n",
      "        zorder: float\n",
      "    \n",
      "    .. note::\n",
      "        In addition to the above described arguments, this function can take a\n",
      "        **data** keyword argument. If such a **data** argument is given, the\n",
      "        following arguments are replaced by **data[<arg>]**:\n",
      "    \n",
      "        * All positional and all keyword arguments.\n",
      "    \n",
      "        Objects passed as **data** must support item access (``data[<arg>]``) and\n",
      "        membership test (``<arg> in data``).\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(plt.bar)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<BarContainer object of 5 artists>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "sub = ['python', 'c', 'c++', 'Java', 'DA']\n",
    "c1 = [55, 65, 80, 70, 60]\n",
    "c2 = [50, 60, 75, 65, 50]\n",
    "\n",
    "plt.bar(sub, c1)\n",
    "plt.bar(sub, c2, bottom = c2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<BarContainer object of 5 artists>"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "sub = ['python', 'c', 'c++', 'Java', 'DA']\n",
    "c1 = [55, 65, 80, 70, 60]\n",
    "c2 = [50, 60, 75, 65, 50]\n",
    "\n",
    "plt.bar(sub, c1, fill = False, hatch = '*')\n",
    "plt.bar(sub, c2, bottom = c2, fill = False, hatch = '.', linestyle = '-.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function barh in module matplotlib.pyplot:\n",
      "\n",
      "barh(y, width, height=0.8, left=None, *, align='center', **kwargs)\n",
      "    Make a horizontal bar plot.\n",
      "    \n",
      "    The bars are positioned at *y* with the given *align*\\ment. Their\n",
      "    dimensions are given by *width* and *height*. The horizontal baseline\n",
      "    is *left* (default 0).\n",
      "    \n",
      "    Each of *y*, *width*, *height*, and *left* may either be a scalar\n",
      "    applying to all bars, or it may be a sequence of length N providing a\n",
      "    separate value for each bar.\n",
      "    \n",
      "    Parameters\n",
      "    ----------\n",
      "    y : scalar or array-like\n",
      "        The y coordinates of the bars. See also *align* for the\n",
      "        alignment of the bars to the coordinates.\n",
      "    \n",
      "    width : scalar or array-like\n",
      "        The width(s) of the bars.\n",
      "    \n",
      "    height : sequence of scalars, optional, default: 0.8\n",
      "        The heights of the bars.\n",
      "    \n",
      "    left : sequence of scalars\n",
      "        The x coordinates of the left sides of the bars (default: 0).\n",
      "    \n",
      "    align : {'center', 'edge'}, optional, default: 'center'\n",
      "        Alignment of the base to the *y* coordinates*:\n",
      "    \n",
      "        - 'center': Center the bars on the *y* positions.\n",
      "        - 'edge': Align the bottom edges of the bars with the *y*\n",
      "          positions.\n",
      "    \n",
      "        To align the bars on the top edge pass a negative *height* and\n",
      "        ``align='edge'``.\n",
      "    \n",
      "    Returns\n",
      "    -------\n",
      "    container : `.BarContainer`\n",
      "        Container with all the bars and optionally errorbars.\n",
      "    \n",
      "    Other Parameters\n",
      "    ----------------\n",
      "    color : scalar or array-like, optional\n",
      "        The colors of the bar faces.\n",
      "    \n",
      "    edgecolor : scalar or array-like, optional\n",
      "        The colors of the bar edges.\n",
      "    \n",
      "    linewidth : scalar or array-like, optional\n",
      "        Width of the bar edge(s). If 0, don't draw edges.\n",
      "    \n",
      "    tick_label : str or array-like, optional\n",
      "        The tick labels of the bars.\n",
      "        Default: None (Use default numeric labels.)\n",
      "    \n",
      "    xerr, yerr : scalar or array-like of shape(N,) or shape(2, N), optional\n",
      "        If not ``None``, add horizontal / vertical errorbars to the\n",
      "        bar tips. The values are +/- sizes relative to the data:\n",
      "    \n",
      "        - scalar: symmetric +/- values for all bars\n",
      "        - shape(N,): symmetric +/- values for each bar\n",
      "        - shape(2, N): Separate - and + values for each bar. First row\n",
      "          contains the lower errors, the second row contains the upper\n",
      "          errors.\n",
      "        - *None*: No errorbar. (default)\n",
      "    \n",
      "        See :doc:`/gallery/statistics/errorbar_features`\n",
      "        for an example on the usage of ``xerr`` and ``yerr``.\n",
      "    \n",
      "    ecolor : scalar or array-like, optional, default: 'black'\n",
      "        The line color of the errorbars.\n",
      "    \n",
      "    capsize : scalar, optional\n",
      "       The length of the error bar caps in points.\n",
      "       Default: None, which will take the value from\n",
      "       :rc:`errorbar.capsize`.\n",
      "    \n",
      "    error_kw : dict, optional\n",
      "        Dictionary of kwargs to be passed to the `~.Axes.errorbar`\n",
      "        method. Values of *ecolor* or *capsize* defined here take\n",
      "        precedence over the independent kwargs.\n",
      "    \n",
      "    log : bool, optional, default: False\n",
      "        If ``True``, set the x-axis to be log scale.\n",
      "    \n",
      "    See also\n",
      "    --------\n",
      "    bar: Plot a vertical bar plot.\n",
      "    \n",
      "    Notes\n",
      "    -----\n",
      "    The optional arguments *color*, *edgecolor*, *linewidth*,\n",
      "    *xerr*, and *yerr* can be either scalars or sequences of\n",
      "    length equal to the number of bars.  This enables you to use\n",
      "    bar as the basis for stacked bar charts, or candlestick plots.\n",
      "    Detail: *xerr* and *yerr* are passed directly to\n",
      "    :meth:`errorbar`, so they can also have shape 2xN for\n",
      "    independent specification of lower and upper errors.\n",
      "    \n",
      "    Other optional kwargs:\n",
      "    \n",
      "    Properties:\n",
      "        agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array\n",
      "        alpha: float or None\n",
      "        animated: bool\n",
      "        antialiased or aa: unknown\n",
      "        capstyle: {'butt', 'round', 'projecting'}\n",
      "        clip_box: `.Bbox`\n",
      "        clip_on: bool\n",
      "        clip_path: Patch or (Path, Transform) or None\n",
      "        color: color\n",
      "        contains: callable\n",
      "        edgecolor or ec: color or None or 'auto'\n",
      "        facecolor or fc: color or None\n",
      "        figure: `.Figure`\n",
      "        fill: bool\n",
      "        gid: str\n",
      "        hatch: {'/', '\\\\', '|', '-', '+', 'x', 'o', 'O', '.', '*'}\n",
      "        in_layout: bool\n",
      "        joinstyle: {'miter', 'round', 'bevel'}\n",
      "        label: object\n",
      "        linestyle or ls: {'-', '--', '-.', ':', '', (offset, on-off-seq), ...}\n",
      "        linewidth or lw: float or None\n",
      "        path_effects: `.AbstractPathEffect`\n",
      "        picker: None or bool or float or callable\n",
      "        rasterized: bool or None\n",
      "        sketch_params: (scale: float, length: float, randomness: float)\n",
      "        snap: bool or None\n",
      "        transform: `.Transform`\n",
      "        url: str\n",
      "        visible: bool\n",
      "        zorder: float\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(plt.barh)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<BarContainer object of 5 artists>"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "sub = ['python', 'c', 'c++', 'Java', 'DA']\n",
    "c1 = [55, 65, 80, 70, 60]\n",
    "c2 = [50, 60, 75, 65, 50]\n",
    "\n",
    "plt.barh(sub, c1, fill = False, hatch = '*')\n",
    "plt.barh(sub, c2, left = c2, fill = False, hatch = '.', linestyle = '-.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function hist in module matplotlib.pyplot:\n",
      "\n",
      "hist(x, bins=None, range=None, density=False, weights=None, cumulative=False, bottom=None, histtype='bar', align='mid', orientation='vertical', rwidth=None, log=False, color=None, label=None, stacked=False, *, data=None, **kwargs)\n",
      "    Plot a histogram.\n",
      "    \n",
      "    Compute and draw the histogram of *x*.  The return value is a tuple\n",
      "    (*n*, *bins*, *patches*) or ([*n0*, *n1*, ...], *bins*, [*patches0*,\n",
      "    *patches1*,...]) if the input contains multiple data.  See the\n",
      "    documentation of the *weights* parameter to draw a histogram of\n",
      "    already-binned data.\n",
      "    \n",
      "    Multiple data can be provided via *x* as a list of datasets\n",
      "    of potentially different length ([*x0*, *x1*, ...]), or as\n",
      "    a 2-D ndarray in which each column is a dataset.  Note that\n",
      "    the ndarray form is transposed relative to the list form.\n",
      "    \n",
      "    Masked arrays are not supported.\n",
      "    \n",
      "    The *bins*, *range*, *weights*, and *density* parameters behave as in\n",
      "    `numpy.histogram`.\n",
      "    \n",
      "    Parameters\n",
      "    ----------\n",
      "    x : (n,) array or sequence of (n,) arrays\n",
      "        Input values, this takes either a single array or a sequence of\n",
      "        arrays which are not required to be of the same length.\n",
      "    \n",
      "    bins : int or sequence or str, optional\n",
      "        If *bins* is an integer, it defines the number of equal-width bins\n",
      "        in the range.\n",
      "    \n",
      "        If *bins* is a sequence, it defines the bin edges, including the\n",
      "        left edge of the first bin and the right edge of the last bin;\n",
      "        in this case, bins may be unequally spaced.  All but the last\n",
      "        (righthand-most) bin is half-open.  In other words, if *bins* is::\n",
      "    \n",
      "            [1, 2, 3, 4]\n",
      "    \n",
      "        then the first bin is ``[1, 2)`` (including 1, but excluding 2) and\n",
      "        the second ``[2, 3)``.  The last bin, however, is ``[3, 4]``, which\n",
      "        *includes* 4.\n",
      "    \n",
      "        If *bins* is a string, it is one of the binning strategies\n",
      "        supported by `numpy.histogram_bin_edges`: 'auto', 'fd', 'doane',\n",
      "        'scott', 'stone', 'rice', 'sturges', or 'sqrt'.\n",
      "    \n",
      "        The default is :rc:`hist.bins`.\n",
      "    \n",
      "    range : tuple or None, optional\n",
      "        The lower and upper range of the bins. Lower and upper outliers\n",
      "        are ignored. If not provided, *range* is ``(x.min(), x.max())``.\n",
      "        Range has no effect if *bins* is a sequence.\n",
      "    \n",
      "        If *bins* is a sequence or *range* is specified, autoscaling\n",
      "        is based on the specified bin range instead of the\n",
      "        range of x.\n",
      "    \n",
      "        Default is ``None``\n",
      "    \n",
      "    density : bool, optional\n",
      "        If ``True``, the first element of the return tuple will\n",
      "        be the counts normalized to form a probability density, i.e.,\n",
      "        the area (or integral) under the histogram will sum to 1.\n",
      "        This is achieved by dividing the count by the number of\n",
      "        observations times the bin width and not dividing by the total\n",
      "        number of observations. If *stacked* is also ``True``, the sum of\n",
      "        the histograms is normalized to 1.\n",
      "    \n",
      "        Default is ``False``.\n",
      "    \n",
      "    weights : (n, ) array-like or None, optional\n",
      "        An array of weights, of the same shape as *x*.  Each value in *x*\n",
      "        only contributes its associated weight towards the bin count\n",
      "        (instead of 1).  If *normed* or *density* is ``True``,\n",
      "        the weights are normalized, so that the integral of the density\n",
      "        over the range remains 1.\n",
      "    \n",
      "        Default is ``None``.\n",
      "    \n",
      "        This parameter can be used to draw a histogram of data that has\n",
      "        already been binned, e.g. using `np.histogram` (by treating each\n",
      "        bin as a single point with a weight equal to its count) ::\n",
      "    \n",
      "            counts, bins = np.histogram(data)\n",
      "            plt.hist(bins[:-1], bins, weights=counts)\n",
      "    \n",
      "        (or you may alternatively use `~.bar()`).\n",
      "    \n",
      "    cumulative : bool or -1, optional\n",
      "        If ``True``, then a histogram is computed where each bin gives the\n",
      "        counts in that bin plus all bins for smaller values. The last bin\n",
      "        gives the total number of datapoints.\n",
      "    \n",
      "        If *density* is also ``True`` then the histogram is normalized such\n",
      "        that the last bin equals 1.\n",
      "    \n",
      "        If *cumulative* is a number less than 0 (e.g., -1), the direction\n",
      "        of accumulation is reversed.  In this case, if *density* is also\n",
      "        ``True``, then the histogram is normalized such that the first bin\n",
      "        equals 1.\n",
      "    \n",
      "    bottom : array-like, scalar, or None, default: None\n",
      "        Location of the bottom of each bin, ie. bins are drawn from\n",
      "        ``bottom`` to ``bottom + hist(x, bins)`` If a scalar, the bottom\n",
      "        of each bin is shifted by the same amount. If an array, each bin\n",
      "        is shifted independently and the length of bottom must match the\n",
      "        number of bins. If None, defaults to 0.\n",
      "    \n",
      "    histtype : {'bar', 'barstacked', 'step',  'stepfilled'}, optional\n",
      "        The type of histogram to draw.\n",
      "    \n",
      "        - 'bar' is a traditional bar-type histogram.  If multiple data\n",
      "          are given the bars are arranged side by side.\n",
      "        - 'barstacked' is a bar-type histogram where multiple\n",
      "          data are stacked on top of each other.\n",
      "        - 'step' generates a lineplot that is by default unfilled.\n",
      "        - 'stepfilled' generates a lineplot that is by default filled.\n",
      "    \n",
      "        Default is 'bar'\n",
      "    \n",
      "    align : {'left', 'mid', 'right'}, optional\n",
      "        Controls how the histogram is plotted.\n",
      "    \n",
      "        - 'left': bars are centered on the left bin edges.\n",
      "        - 'mid': bars are centered between the bin edges.\n",
      "        - 'right': bars are centered on the right bin edges.\n",
      "    \n",
      "        Default is 'mid'\n",
      "    \n",
      "    orientation : {'horizontal', 'vertical'}, optional\n",
      "        If 'horizontal', `~matplotlib.pyplot.barh` will be used for\n",
      "        bar-type histograms and the *bottom* kwarg will be the left edges.\n",
      "    \n",
      "    rwidth : scalar or None, optional\n",
      "        The relative width of the bars as a fraction of the bin width.  If\n",
      "        ``None``, automatically compute the width.\n",
      "    \n",
      "        Ignored if *histtype* is 'step' or 'stepfilled'.\n",
      "    \n",
      "        Default is ``None``\n",
      "    \n",
      "    log : bool, optional\n",
      "        If ``True``, the histogram axis will be set to a log scale. If\n",
      "        *log* is ``True`` and *x* is a 1D array, empty bins will be\n",
      "        filtered out and only the non-empty ``(n, bins, patches)``\n",
      "        will be returned.\n",
      "    \n",
      "        Default is ``False``\n",
      "    \n",
      "    color : color or array-like of colors or None, optional\n",
      "        Color or sequence of colors, one per dataset.  Default (``None``)\n",
      "        uses the standard line color sequence.\n",
      "    \n",
      "        Default is ``None``\n",
      "    \n",
      "    label : str or None, optional\n",
      "        String, or sequence of strings to match multiple datasets.  Bar\n",
      "        charts yield multiple patches per dataset, but only the first gets\n",
      "        the label, so that the legend command will work as expected.\n",
      "    \n",
      "        default is ``None``\n",
      "    \n",
      "    stacked : bool, optional\n",
      "        If ``True``, multiple data are stacked on top of each other If\n",
      "        ``False`` multiple data are arranged side by side if histtype is\n",
      "        'bar' or on top of each other if histtype is 'step'\n",
      "    \n",
      "        Default is ``False``\n",
      "    \n",
      "    Returns\n",
      "    -------\n",
      "    n : array or list of arrays\n",
      "        The values of the histogram bins. See *density* and *weights* for a\n",
      "        description of the possible semantics.  If input *x* is an array,\n",
      "        then this is an array of length *nbins*. If input is a sequence of\n",
      "        arrays ``[data1, data2, ...]``, then this is a list of arrays with\n",
      "        the values of the histograms for each of the arrays in the same\n",
      "        order.  The dtype of the array *n* (or of its element arrays) will\n",
      "        always be float even if no weighting or normalization is used.\n",
      "    \n",
      "    bins : array\n",
      "        The edges of the bins. Length nbins + 1 (nbins left edges and right\n",
      "        edge of last bin).  Always a single array even when multiple data\n",
      "        sets are passed in.\n",
      "    \n",
      "    patches : list or list of lists\n",
      "        Silent list of individual patches used to create the histogram\n",
      "        or list of such list if multiple input datasets.\n",
      "    \n",
      "    Other Parameters\n",
      "    ----------------\n",
      "    **kwargs : `~matplotlib.patches.Patch` properties\n",
      "    \n",
      "    See also\n",
      "    --------\n",
      "    hist2d : 2D histograms\n",
      "    \n",
      "    Notes\n",
      "    -----\n",
      "    \n",
      "    \n",
      "    .. note::\n",
      "        In addition to the above described arguments, this function can take a\n",
      "        **data** keyword argument. If such a **data** argument is given, the\n",
      "        following arguments are replaced by **data[<arg>]**:\n",
      "    \n",
      "        * All arguments with the following names: 'weights', 'x'.\n",
      "    \n",
      "        Objects passed as **data** must support item access (``data[<arg>]``) and\n",
      "        membership test (``<arg> in data``).\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(plt.hist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([  2.,   7.,  35.,  90., 189., 265., 205., 146.,  51.,  10.]),\n",
       " array([-3.76680373, -3.10851272, -2.45022171, -1.79193069, -1.13363968,\n",
       "        -0.47534867,  0.18294234,  0.84123335,  1.49952437,  2.15781538,\n",
       "         2.81610639]),\n",
       " <a list of 10 Patch objects>)"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "x = np.random.randn(1000)\n",
    "plt.hist(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "python = np.random.randint(1, 100, 100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([11.,  8., 13.,  8.,  5., 10.,  8., 16., 12.,  9.]),\n",
       " array([ 1. , 10.8, 20.6, 30.4, 40.2, 50. , 59.8, 69.6, 79.4, 89.2, 99. ]),\n",
       " <a list of 10 Patch objects>)"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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.hist(python)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pie Chart"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sub = ['Python', 'Pandas', 'Numpy', 'Matplotlib']\n",
    "y = [35, 25, 20, 20]\n",
    "\n",
    "plt.pie(y, labels=sub,labeldistance=0.5, radius=1.5, explode = [0, 0.25,0,0])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Seaborn - Color Palletes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAj8AAABICAYAAAAZFJRnAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAACpElEQVR4nO3csUpXYRzG8d+JTBeHKCEhCpG2HCLXIrqJoIY2b6FLaIuWlmhrC7qEuoLaiqBB2kIwAqeG4m1pySERfHv9n+fz2Tyc4flNfuGIU2utAABSnBk9AADgfxI/AEAU8QMARBE/AEAU8QMARBE/AECUs0e9ME3TTlXtVFVNSys3ly5c7j5qlK1pd/SErj4unxs9oZvNr6MX9HWwemX0hK7ar73RE7o6v3xp9ISu9qeD0RO6WV39NnpCV7u1OXpCVz8/f9pvra0dfj4d5//8LK9fa+sPn57osNPky8r90RO62tqY7y/QV49/jp7Q1ds7z0ZP6OrH9yejJ3R1b+PR6AldvVh5M3pCN7duvxw9oasH0+vRE7rau3vjfWtt+/Bzn70AgCjiBwCIIn4AgCjiBwCIIn4AgCjiBwCIIn4AgCjiBwCIIn4AgCjiBwCIIn4AgCjiBwCIIn4AgCjiBwCIIn4AgCjiBwCIIn4AgCjiBwCIIn4AgCjiBwCIIn4AgCjiBwCIIn4AgCjiBwCIIn4AgCjiBwCIIn4AgCjiBwCIIn4AgCjiBwCIIn4AgCjiBwCIIn4AgCjiBwCIIn4AgCjiBwCIIn4AgCjiBwCIIn4AgCjiBwCIIn4AgCjiBwCIIn4AgCjiBwCIIn4AgCjiBwCIIn4AgCjiBwCIIn4AgCjiBwCIIn4AgCjiBwCIMrXW/v3CNO1U1c6fH69X1Yfeowa6WFX7o0d0Mufbqty36Ny3uOZ8W5X7Ft3V1tra4YdHxs9fL0/Tu9ba9onOOkXmfN+cb6ty36Jz3+Ka821V7psrn70AgCjiBwCIctz4ed5lxekx5/vmfFuV+xad+xbXnG+rct8sHetvfgAAFp3PXgBAFPEDAEQRPwBAFPEDAEQRPwBAlN+4l3KDiAVmOQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 720x72 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Calling with no arguments returns all colors from the current default color cycle:\n",
    "#Here, the palplot() is used to plot the array of colors horizontally\n",
    "import seaborn as sns\n",
    "sns.palplot(sns.color_palette())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWAAAABICAYAAADI6S+jAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAACEklEQVR4nO3asY5MYRjG8fc7EXZZCjElSgWisFegUbgDFzDXstewV6BwBXsNFBIqCiXJhkSzIpJPozHBZpL5PDPH79fNySmet/kXJ9N67wXAvzelBwD8rwQYIESAAUIEGCBEgAFCBBgg5MJ5L7TWllW1rKram6aHt/b2h49Kuby4mp4w1HTtenrCMN+mi+kJQ30++56eMNSnL1/TE4Y6+/DutPe+WH3e1vkf8J0rB/347v2NDtsmD5aP0hOGOnj8ND1hmPeXbqYnDPX8zcf0hKGenbxNTxjq1dGTl733w9XnPkEAhAgwQIgAA4QIMECIAAOECDBAiAADhAgwQIgAA4QIMECIAAOECDBAiAADhAgwQIgAA4QIMECIAAOECDBAiAADhAgwQIgAA4QIMECIAAOECDBAiAADhAgwQIgAA4QIMECIAAOECDBAiAADhAgwQIgAA4QIMECIAAOECDBAiAADhAgwQIgAA4QIMECIAAOECDBAiAADhAgwQIgAA4QIMECIAAOECDBAiAADhAgwQIgAA4QIMEBI673//YXWllW1/PnzXlW9Hj0q6EZVnaZHDDLn26rct+vmft/t3vti9eG5Af7l5dZe9N4PNzpri8z5vjnfVuW+XTf3+/7EJwiAEAEGCFk3wMdDVmyPOd8359uq3Lfr5n7fb631DRiAzfEJAiBEgAFCBBggRIABQgQYIOQHFPpTGzElrsIAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x72 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "current_palette = sns.color_palette(\"RdBu\")\n",
    "sns.palplot(current_palette)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAj8AAABICAYAAAAZFJRnAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAACmElEQVR4nO3csUpQYRjG8feUJZYFRU4RETa2KbQI3Uiz19I1NHUp0VxbtUXgEEE2FVkpfS0tOSSCX5/nPL/f5uEMz7vIH444tdYKACDFhdEDAAD+J/EDAEQRPwBAFPEDAEQRPwBAFPEDAERZOemFaZp2q2q3qmq1pq3bK6vdR42yun559ISuLl9bGz2hm4tX10dP6Gv1yugFXR1NJ/4qmrWDw1+jJ3T15cfR6AndfD04HD2hq5/fF37f5/f7rbWN48+n0/yfn81La+3JjXtnOuw8ub9zZ/SEru48ejB6QjfXH+6MntDX5tboBV3tr9wcPaGrN5++jZ7Q1fN3n0dP6ObF64+jJ3S19/bD6Ald7T17/Kq1tn38uc9eAEAU8QMARBE/AEAU8QMARBE/AEAU8QMARBE/AEAU8QMARBE/AEAU8QMARBE/AEAU8QMARBE/AEAU8QMARBE/AEAU8QMARBE/AEAU8QMARBE/AEAU8QMARBE/AEAU8QMARBE/AEAU8QMARBE/AEAU8QMARBE/AEAU8QMARBE/AEAU8QMARBE/AEAU8QMARBE/AEAU8QMARBE/AEAU8QMARBE/AEAU8QMARBE/AEAU8QMARBE/AEAU8QMARBE/AEAU8QMARBE/AEAU8QMARBE/AEAU8QMARBE/AEAU8QMARBE/AEAU8QMARJlaa/9+YZp2q2r3z48Pqup171ED3aqq/dEjOlnybVXumzv3zdeSb6ty39zdba1tHH94Yvz89fI0vWytbZ/prHNkyfct+bYq982d++ZrybdVuW+pfPYCAKKIHwAgymnj52mXFefHku9b8m1V7ps7983Xkm+rct8inepvfgAA5s5nLwAgivgBAKKIHwAgivgBAKKIHwAgym/OcHWDrbIuHgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 720x72 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.palplot(sns.color_palette(\"RdBu\", n_colors=10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAj8AAABICAYAAAAZFJRnAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAACnklEQVR4nO3cP0uWYRjG4etRMe3/kNBQ1BxCQ0JbTX0Vl75RS2NfoqU9IUgaGvoCWkGBKRh3S0sGieDd7fucx7G9L89wXsvLDx5xaq0VAECKpdEDAAD+J/EDAEQRPwBAFPEDAEQRPwBAFPEDAERZOe2BaZq2q2q7qmp1uR5tXJ26jxplfX119ISuLl25NnpCNyvr10dP6Gpp5fLoCV0d1/LoCV0d/DwePaGrb0dHoyd08/3gYPSErg5/HI6e0NfnL/uttY2TX09n+T8/d24utedP1s5110Xy8MHd0RO6uv/46egJ3dzefDZ6QldrG1ujJ3S1N90YPaGrna97oyd09frTx9ETunnz7v3oCV192N0dPaGvl692Wmt//YB67QUARBE/AEAU8QMARBE/AEAU8QMARBE/AEAU8QMARBE/AEAU8QMARBE/AEAU8QMARBE/AEAU8QMARBE/AEAU8QMARBE/AEAU8QMARBE/AEAU8QMARBE/AEAU8QMARBE/AEAU8QMARBE/AEAU8QMARBE/AEAU8QMARBE/AEAU8QMARBE/AEAU8QMARBE/AEAU8QMARBE/AEAU8QMARBE/AEAU8QMARBE/AEAU8QMARBE/AEAU8QMARBE/AEAU8QMARBE/AEAU8QMARBE/AEAU8QMARBE/AEAU8QMARBE/AEAU8QMARBE/AECUqbX27wemabuqtn9/3Kyq3d6jBrpVVfujR3Qy59uq3Lfo3Le45nxblfsW3b3W2sbJL0+Nnz8enqa3rbWtc511gcz5vjnfVuW+Ree+xTXn26rcN1deewEAUcQPABDlrPHzosuKi2PO9835tir3LTr3La4531blvlk609/8AAAsOq+9AIAo4gcAiCJ+AIAo4gcAiCJ+AIAovwCnW3OD4aJuswAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 720x72 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Diverging palettes use two different colors. \n",
    "#Each color represents variation in the value ranging from a common point in either direction.\n",
    "\n",
    "#Assume plotting the data ranging from -1 to 1. \n",
    "#The values from -1 to 0 takes one color and 0 to +1 takes another color.\n",
    "sns.palplot(sns.color_palette(\"BrBG\", 10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAV0AAABECAYAAAAiJuZQAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAB70lEQVR4nO3YMWpUURiG4ZMwAVGCQRkyiI2ljRtwAcEyjW0WEEs7axuxjAtQsJSUWUHWYBMQQpCAKNGQIF6da5PGQqfxfL+Y52lOcU/xFZe3OEvjOI4NgIjl6gEAl4noAgSJLkCQ6AIEiS5AkOgCBE0WXfhy8LbNhyGxJW7t7r32bnevekY3dzYftP1nr6tndHFweNK2drbby0cvqqd0sbWz3R5vPqme0c3z3adt4/7D6hldrM+m7dWb3/+XC6M7H4Y2H7791VH/ku9n59UTuvp6clo9oYvTD59/Of9HH48/VU/o6v3RcfWEEp4XAIJEFyBIdAGCRBcgSHQBgkQXIEh0AYJEFyBIdAGCRBcgSHQBgkQXIEh0AYJEFyBIdAGCRBcgSHQBgkQXIEh0AYJEFyBIdAGCRBcgSHQBgkQXIEh0AYJEFyBIdAGCRBcgSHQBgkQXIEh0AYJEFyBIdAGCRBcgSHQBgkQXIEh0AYJEFyBIdAGCRBcgSHQBgkQXIEh0AYJEFyBIdAGCRBcgSHQBgkQXIEh0AYJEFyBIdAGCJosuLK+sJHaUmVy7Wj2hqytrq9UTulid/rg4rxcv6efm7Eb1hK5u3Z5VT+hifTb94/elcRzH0BaAS8/zAkCQ6AIEiS5AkOgCBIkuQJDoAgT9BA0uOaohDksSAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x72 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Customized cubixhelix \n",
    "\n",
    "sns.set()\n",
    "sns.palplot(sns.cubehelix_palette())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAV0AAABECAYAAAAiJuZQAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAB8klEQVR4nO3aPWoVUQCG4XPlCopKVAwZSKMbcAeSPViEdFmErcUtbGPjBrTzB9yDnTuwVCQXEpBEjEExF08aGwu9jec7cfI8zRRzio8pXoZhJrXWWgCIuNB7AMB5IroAQaILECS6AEGiCxAkugBB02UH3u1+KSeLcf5Vdvf2Snn95n3vGc3c37hTHj9923tGE/MPH8vObLM8mL3sPaWJndlm2dp+1HtGM8+fPSz3NrZ6z2hiGFbLqxdP/nh/aXRPFrX8WPz8p6POkuNvi94Tmvp89L33hCY+HXz97TpG+/uHvSc0NZ/v9Z7Qhc8LAEGiCxAkugBBogsQJLoAQaILECS6AEGiCxAkugBBogsQJLoAQaILECS6AEGiCxAkugBBogsQJLoAQaILECS6AEGiCxAkugBBogsQJLoAQaILECS6AEGiCxAkugBBogsQJLoAQaILECS6AEGiCxAkugBBogsQJLoAQaILECS6AEGiCxAkugBBogsQJLoAQaILECS6AEGiCxAkugBBogsQJLoAQaILECS6AEGiCxAkugBB02UHLk4nZcxtvnJ56SP4r12/dqn3hCaOb14tpZRy69d1jNbWbvSe0NT6+tB7QhPDsPrX+5Naaw1tATj3xvsKC3AGiS5AkOgCBIkuQJDoAgSJLkDQKamQOaGn1q51AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x72 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.palplot(sns.cubehelix_palette(rot=-0.1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAV0AAABECAYAAAAiJuZQAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAB9ElEQVR4nO3YMUuVUQDG8aNXr4OCCXohEcSxoaEP0dAg2OTgZFNzsziEs5NfwaFNqM0v4BJRX6G4F66BCDoYxNvk0FB36Twnrr/f8g7vGZ53+b9wZrqu6woAEbOtBwA8JKILECS6AEGiCxAkugBBogsQNDfpwItXL8twPEpsifv84aI8f7PTekY158dnZf/kdesZVWxtbpTD7YPy9v1R6ylVHG4flHefTlvPqGb32V75MvrYekYV871+eTJ4+sf3E6M7HI/K19G3fzrqfzL8Pp0/lHvj68vWE6p4dLtYSinl6vaq8ZJ6bu5uWk+o6sfPu9YTmnC9ABAkugBBogsQJLoAQaILECS6AEGiCxAkugBBogsQJLoAQaILECS6AEGiCxAkugBBogsQJLoAQaILECS6AEGiCxAkugBBogsQJLoAQaILECS6AEGiCxAkugBBogsQJLoAQaILECS6AEGiCxAkugBBogsQJLoAQaILECS6AEGiCxAkugBBogsQJLoAQaILECS6AEGiCxAkugBBogsQJLoAQaILECS6AEGiCxAkugBBogsQNDfpwPrgcWJHM+ur0/19g+W11hOqWFlc+e05jZYWllpPqKrfW2g9oYr5Xv+v72e6rutCWwAePNcLAEGiCxAkugBBogsQJLoAQaILEPQL3UMzfjTcMlgAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x72 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.palplot(sns.cubehelix_palette(start=2.1, rot=-.1,reverse = True))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAV0AAABECAYAAAAiJuZQAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAB70lEQVR4nO3YMWqUQRzG4cm6XwhKYogEUwlCGs+QE1gGy4AX0DKkSZ1GbD2AhY1NSvEAuYCNpY3IhkWJBEVU/CysLMw2zvsX8zzNFDPFW/2KWRrHcWwAREyqBwBcJqILECS6AEGiCxAkugBBogsQNF304P69B+10Nk9siXt58rzt7x5Wz+jm8fFRe/rwSfWMLrZvrbedg7128uhZ9ZQudg722pvjF9Uzurm9e7edvX5VPaOLyTC0te07f7xfGN3T2by9ezv7q6P+Je9nH6ondHU+/1g9oYsva1d+nWfnxUv6+f7pc/WErn58+1o9oYTvBYAg0QUIEl2AINEFCBJdgCDRBQgSXYAg0QUIEl2AINEFCBJdgCDRBQgSXYAg0QUIEl2AINEFCBJdgCDRBQgSXYAg0QUIEl2AINEFCBJdgCDRBQgSXYAg0QUIEl2AINEFCBJdgCDRBQgSXYAg0QUIEl2AINEFCBJdgCDRBQgSXYAg0QUIEl2AINEFCBJdgCDRBQgSXYAg0QUIEl2AINEFCBJdgCDRBQgSXYAg0QUIEl2AoOmiBze3NhM7ytzY2qie0NXq5vXqCV2srK/+dv6PpteuVk/oajIsV0/oYjIMF94vjeM4hrYAXHq+FwCCRBcgSHQBgkQXIEh0AYJEFyDoJ+toM3HSoBRMAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x72 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.palplot(sns.cubehelix_palette(reverse=True))"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}