Data_viz.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Plotting and Visualization"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Making informative visualizations (sometimes called plots) is an important task in data analysis.\n",
    "<br>\n",
    "- It may be a part of the exploratory process—for example, to help identify outliers or needed data transformations, or as a way of generating ideas for models.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## matplotlib basics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "data = np.arange(10)\n",
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Figures and Subplots"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plots in matplotlib reside within a Figure object. You can create a new figure with `plt.figure()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- this returns a blank figure\n",
    "- need to add subplots :- using the `add_subplot()` method of the figure object"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--{talk about kwargs and args of the fig object :- shift + tab}-->"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ax1 = fig.add_subplot(221)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "alternative way :- `fig.add_subplot(2,2,1)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ax3 = fig.add_subplot(223)\n",
    "ax4 = fig.add_subplot(224)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(np.random.randn(50).cumsum(), 'k--')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When you issue a plotting command like plt.plot([1.5, 3.5, -2, 1.6]), matplotlib draws on the last figure and subplot used (creating one if necessary), thus hiding the figure and subplot creation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note:- *One nuance of using Jupyter notebooks is that plots are reset after each cell is evaluated, so for more complex plots you must put all of the plotting commands in a single notebook cell.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure()\n",
    "\n",
    "ax1 = fig.add_subplot(221)\n",
    "plt.plot(np.random.randn(200),np.random.randn(200),'go')\n",
    "\n",
    "ax2 = fig.add_subplot(222)\n",
    "plt.plot(np.arange(18),5**(np.arange(18)),'y-o')\n",
    "\n",
    "ax3 = fig.add_subplot(223)\n",
    "plt.plot(np.arange(0,10,0.01),(np.sin(10*np.arange(0,10,0.01)))*(np.exp(-np.arange(0,10,0.01))),'r')\n",
    "\n",
    "ax4 = fig.add_subplot(224)\n",
    "plt.plot(np.random.randn(50).cumsum(),'--')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--{will talk about colors, markers and line styles here itself}-->"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--{talk about figsize , the cell below will be created later}-->"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize=(16,9))\n",
    "\n",
    "ax1 = fig.add_subplot(221)\n",
    "plt.plot(np.random.randn(200),np.random.randn(200),'go')\n",
    "\n",
    "ax2 = fig.add_subplot(222)\n",
    "plt.plot(np.arange(18),5**(np.arange(18)),'y-o')\n",
    "\n",
    "ax3 = fig.add_subplot(223)\n",
    "plt.plot(np.arange(0,10,0.01),(np.sin(10*np.arange(0,10,0.01)))*(np.exp(-np.arange(0,10,0.01))),'r')\n",
    "\n",
    "ax4 = fig.add_subplot(224)\n",
    "plt.plot(np.random.randn(50).cumsum(),'--')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--{talk about plotting very large numbers}-->"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--{introduce markdown:- allows to have latex, html and so on as input:-<br>\n",
    "for now}<br>-->\n",
    "note that, \"that\" ugly thing is :-\n",
    "\n",
    "\n",
    "$$y=sin(10x)e^{-x}$$\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--{talk about the last plot (abs)}-->"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "changing plots directly (using a direct call to `axes_subplot.plot()` method)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ax1.hist(np.random.randn(100), bins=20, color='k', alpha=0.3)\n",
    "ax2.scatter(np.arange(30), np.arange(30) + 3 * np.random.randn(30))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize=(16,9))\n",
    "\n",
    "ax1 = fig.add_subplot(221)\n",
    "plt.plot(np.random.randn(200),np.random.randn(200),'go')\n",
    "\n",
    "ax2 = fig.add_subplot(222)\n",
    "plt.plot(np.arange(16),5**(np.arange(16)),'y-o')\n",
    "\n",
    "ax3 = fig.add_subplot(223)\n",
    "plt.plot(np.arange(0,10,0.01),(np.sin(10*np.arange(0,10,0.01)))*(np.exp(-np.arange(0,10,0.01))),'r')\n",
    "\n",
    "ax4 = fig.add_subplot(224)\n",
    "plt.plot(np.random.randn(50).cumsum(),'--')\n",
    "\n",
    "ax1.clear()\n",
    "ax2.clear()\n",
    "\n",
    "ax1.hist(np.random.randn(100), bins=20, alpha=0.3)\n",
    "ax2.scatter(np.arange(30), np.arange(30) + 3 * np.random.randn(30))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## the efficient way "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, axes = plt.subplots(2, 3)\n",
    "axes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\"axes\" will be an array of subplots:- can be accessed as shown in the previous notebooks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "axes[0][2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Colors, Markers, and Line Styles"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure()\n",
    "plt.plot(np.random.randn(30).cumsum(),'ko--')\n",
    "# k denotes black here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "equivalent code:-<br>\n",
    "`plot(np.random.randn(30).cumsum(), color='k', linestyle='dashed', marker='o')`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "note:- if you're working in ipython or a python script, you'll need to clear plots after you're done with them and wanna plot a new one...<br>\n",
    "do that by using :-<br>\n",
    "`plt.close('all')`<br>\n",
    ".. after you've exported (discussed ahead) them if necessary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = np.random.randn(30).cumsum()\n",
    "\n",
    "fig = plt.figure(figsize=(16,9))\n",
    "\n",
    "plt.plot(data, 'k--', label='Default')\n",
    "\n",
    "plt.plot(data, 'k-', drawstyle='steps-post', label='steps-post')\n",
    "\n",
    "plt.legend(loc='best')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--{show steps-pre as well }-->"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ticks, Labels, and Legends"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Setting the title, axis labels, ticks, and ticklabels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize=(16,9))\n",
    "ax = fig.add_subplot(111)\n",
    "\n",
    "ax.plot(np.random.randn(1000).cumsum())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize=(16,9))\n",
    "ax = fig.add_subplot(111)\n",
    "\n",
    "ax.plot(np.random.randn(1000).cumsum())\n",
    "\n",
    "ticks = ax.set_xticks([0, 250, 500, 750, 1000])\n",
    "labels = ax.set_xticklabels(['one', 'two', 'three', 'four', 'five'],\n",
    "                            rotation=30, fontsize='large')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize=(16,9))\n",
    "ax = fig.add_subplot(111)\n",
    "\n",
    "ax.plot(np.random.randn(1000).cumsum())\n",
    "\n",
    "ticks = ax.set_xticks([0, 250, 500, 750, 1000])\n",
    "labels = ax.set_xticklabels(['one', 'two', 'three', 'four', 'five'],\n",
    "                            rotation=900, fontsize='large')\n",
    "\n",
    "ax.set_title('This session\\'s first titled graph ... :->',fontsize=20)\n",
    "ax.set_xlabel('Stages')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Adding legends"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize=(16,9))\n",
    "ax = fig.add_subplot(111)\n",
    "ax.plot(np.random.randn(1000).cumsum(), 'y', label='one')\n",
    "ax.plot(np.random.randn(1000).cumsum(), 'b--', label='two')\n",
    "ax.plot(np.random.randn(1000).cumsum(), 'r.', label='three')\n",
    "ax.legend(loc='best')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--{show the legend jumping around for multiple plots}-->"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Saving Plots to File"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " - file type inferred from the extension\n",
    " - possible types:\n",
    "     - pdf\n",
    "     - png\n",
    "     - jpeg\n",
    "     - and more.."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(np.random.randn(100),np.random.randn(100),\"ro\")\n",
    "plt.savefig('saved_fig.png', dpi=400, bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note:- can also be written to a file"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### matplotlib Configuration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.rc('figure', figsize=(10, 10))\n",
    "# rc:- run configs:- common end \n",
    "# configuration files in rc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "the first argument is what you want to configure.."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "can pass parameters as a dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "font_options = {'family' : 'monospace',\n",
    "                'weight' : 'bold',\n",
    "                'size'   : 10}\n",
    "\n",
    "plt.rc('font', **font_options)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plotting with pandas and seaborn"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Why seaborn:-\n",
    " - matplotlib can be a fairly low-level tool. You assemble a plot from its base components: the data display (i.e., the type of plot: line, bar, box, scatter, contour, etc.), legend, title, tick labels, and other annotations.\n",
    " -  Seaborn is a statistical graphics library created by Michael Waskom. Seaborn simplifies creating many common visualization types.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NOTE:-\n",
    "<br>    Importing seaborn modifies the default matplotlib color schemes and plot styles to improve readability and aesthetics. Even if you do not use the seaborn API, you may prefer to import seaborn as a simple way to improve the visual aesthetics of general matplotlib plots.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Line Plots"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "inbuilt functionality provided for series to produce line plots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = pd.Series(np.random.randn(10).cumsum(), index=np.arange(0, 100, 10))\n",
    "s.plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "for Data Frames:- treat as a set of series"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.DataFrame(np.random.randn(10, 4).cumsum(0),\n",
    "                  columns=['A', 'B', 'C', 'D'],\n",
    "                  index=np.arange(0, 100, 10))\n",
    "df.plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Importance of matplotlib\n",
    "Additional keyword arguments to plot are passed through to the respective matplotlib plotting function, so you can further customize these plots by learning more about the matplotlib API."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Bar Plots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, axes = plt.subplots(2, 1)\n",
    "data = pd.Series(np.random.rand(16), index=list('abcdefghijklmnop'))\n",
    "data.plot.bar(ax=axes[0], color='k', alpha=1)\n",
    "data.plot.barh(ax=axes[1], color='k', alpha=0.7)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "alpha channel:- transperency map<br>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.DataFrame(np.random.rand(6, 4),\n",
    "                  index=['one', 'two', 'three', 'four', 'five', 'six'],\n",
    "                  columns=pd.Index(['A', 'B', 'C', 'D'], name='Genus'))\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.plot.bar()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.plot.barh(stacked=True, alpha=0.7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <center>Sample</center> "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "tips = pd.read_csv('tips.csv')\n",
    "tips"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "aim:- to make stacked plot showing the percentage of data points for each party size on each day"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tips.head(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tips.tail(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "party_counts = pd.crosstab(tips['day'], tips['size'])\n",
    "party_counts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ignoring 1 and 6 :- too less "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "party_counts = party_counts.loc[:, 2:5]\n",
    "party_counts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Normalize the sum to 1 (plotting fractions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "party_counts.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "party_counts.sum(1).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "party_counts.sum(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# pcts :- percentages\n",
    "# using broadcasting here\n",
    "party_pcts = party_counts.T / party_counts.sum(1)\n",
    "party_pcts =party_pcts.T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "party_pcts.plot.bar(title = \" Fraction of parties by size on each day\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Now showing an example using seaborn "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import seaborn as sns\n",
    "\n",
    "tips['tip_pct'] = tips['tip'] / (tips['total_bill'] - tips['tip'])\n",
    "\n",
    "tips.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.barplot(x='tip_pct', y='day', data=tips)\n",
    "plt.title(\"Tipping percentage by day with error bars\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.set(style = \"whitegrid\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.barplot(x='tip_pct', y='day', hue='time', data=tips, orient='h')\n",
    "# hue allows to split the bars using another categorical variable\n",
    "plt.title(\"Tipping percentage by day and time\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.set(style = \"whitegrid\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Histograms and Density Plots"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A histogram is a kind of bar plot that gives a discretized display of value frequency. The data points are split into discrete, evenly spaced bins, and the number of data points in each bin is plotted."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tips['tip_pct'].plot.hist(bins=50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tips['tip_pct'].plot.hist(bins=100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A related plot type is a density plot, which is formed by computing an estimate of a continuous probability distribution that might have generated the observed data. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tips['tip_pct'].plot.density()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### plotting multiple distributions together"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "comp1 = np.random.normal(0, 1, size=200)\n",
    "comp2 = np.random.normal(10, 2, size=200)\n",
    "\n",
    "values = pd.Series(np.concatenate([comp1, comp2]))\n",
    "#axis is set to zero by default\n",
    "\n",
    "sns.distplot(values, bins=100, color='green')\n",
    "\n",
    "plt.title(\" Normalized histogram of normal mixture with density estimate \")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Enjoy analysing and visualizing"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}