lectures/notebooks/Lecture_01_Introduction_And_Environment_Setup.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Fundamentals of Information Systems\n",
    "\n",
    "## Python Programming (for Data Science)\n",
    "\n",
    "### Master's Degree in Data Science\n",
    "\n",
    "#### Gabriele Tolomei\n",
    "<a href=\"mailto:gtolomei@math.unipd.it\">gtolomei@math.unipd.it</a><br/>\n",
    "University of Padua, Italy<br/>\n",
    "2017/2018<br/>\n",
    "October 11, 2018"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Lecture 1: Introduction and Environment Setup"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# What is Data Science?\n",
    "<br />\n",
    "<br />\n",
    "<div>\n",
    "<center>According to [Wikipedia](https://en.wikipedia.org/wiki/Data_science):<br /><br />\n",
    "\"Data Science is an **interdisciplinary** field about scientific methods, processes, and systems to extract **knowledge** or insights from **data** in various forms, either structured or unstructured.\"</center>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# What is Data Science?\n",
    "<br />\n",
    "<center><i>A picture is worth a thousand words...</i></center>\n",
    "<center>![](./img/data_science.jpg)</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# What kind of Data?\n",
    "\n",
    "Mostly, **structured data**, which is a (vague) term that encompasses many different common forms of data, such as:\n",
    "-  Tabular data like those stored in RDBMS or tab- or comma-separated text files, each column of a different type (*string*, *numeric*, *date*, etc.).\n",
    "-  Multidimensional arrays (matrices).\n",
    "-  Multiple tables of data interrelated by key columns (what would be primary or foreign keys for a SQL user).\n",
    "-  Evenly or unevenly spaced time series.\n",
    "-  In general, any source of data with a *schema* attached. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# What kind of Data?\n",
    "\n",
    "-  The list above is by no means complete!\n",
    "-  Often, *unstructured* data sets can be transformed into a structured form that is more suitable for analysis and modeling. \n",
    "-  If not, it may be possible to **extract features** from a data set into a structured form. For example: \n",
    "    -  A collection _text documents_ could be processed into a word frequency table which could then be used to perform sentiment analysis.\n",
    "    -  A set of _images_ can be transformed into RGB matrices of fixed size to perform some visual recognition task (cat vs. dog)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Why Python?\n",
    "\n",
    "-  Since its first appearance in 1991, *Python* has become one of the most popular programming languages, along with *Perl*, *Ruby*, and others. \n",
    "-  It is often referred to as a *scripting language* to emphasize that it can be used to *quickly* write small programs (or scripts).\n",
    "-  Such \"rapid prototyping\" ability is one of the difference between Python and \"established\" programming languages like *C/C++* or *Java*.\n",
    "-  However, the term \"scripting language\" might be misleading as it seems that Python cannot be used for building more complex software systems."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Why Python for Data Science? \n",
    "\n",
    "-  Alternatives to Python in the data analysis field are still widely used, e.g., R, MATLAB, SAS, Stata, etc.\n",
    "-  In the last 10 years, Python has become one of the most important languages for **data science**, **machine learning** both in academia and industry.\n",
    "    -  Highly active and collaborative community;\n",
    "    -  Huge library support (e.g., <code>**numpy**</code>, <code>**pandas**</code>, <code>**scikit-learn**</code>).\n",
    "-  As of today, Python is the primary language for anyone approaching data science (and, possibly, computer programming in general)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Python as a glue\n",
    "\n",
    "-  Easy to integrate with existing C, C++, and FORTRAN code for scientific computing. \n",
    "-  Modern computing environments share a similar set of legacy FORTRAN and C libraries for doing linear algebra, optimization, integration, fast fourier transforms, and other such algorithms.\n",
    "-  *Portability*: Python code can be executed on any platform (provided there is a Python implementation for that platform)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## One language fits (almost) all\n",
    "\n",
    "-  Before Python, organizations used to have 2 separate development stages:\n",
    "    1. Research, prototyping, and testing using a specialized language like SAS or R;\n",
    "    2. Deployment of (some of the) prototypes in production using Java, C#, or C++.\n",
    "-  *There's a new kid on the block!* Python is a suitable language not only for research and prototyping but also building production systems.\n",
    "    -  No need to maintain two development environments when one will suffice."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Why _not_ Python?\n",
    "\n",
    "## Performance\n",
    "\n",
    "-  Python (the language) has many run-time implementations. \n",
    "    -  [CPython](https://github.com/python/cpython) (most popular): C implementation; \n",
    "    -  [Jython](http://www.jython.org/): Java implementation;\n",
    "    -  [IronPython](http://ironpython.net/): C# implementation;\n",
    "    -  ...\n",
    "    \n",
    "Note that Python (the language) is not slow; some Python run-times (e.g., CPython) can be!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### CPython\n",
    "\n",
    "-  Python source code is compiled to an intermediate language and then interpreted (i.e., executed) into a virtual machine.\n",
    "-  This is slower than native (assembly) code compiled directly from C/C++.\n",
    "-  It might also be slower than Java, which encapsulates some code optimization strategies (e.g., the Java JIT compiler)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Jython\n",
    "\n",
    "-  Python source code is compiled to Java intermediate language (*bytecode*) and then interpreted (i.e., executed) into the JVM.\n",
    "-  Performance is similar of that of a Java program."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### IronPython\n",
    "\n",
    "-  It relies on the same .NET libraries and Common Language Infrastructure (CLI) as C#. \n",
    "-  Performance is similar of that of a C# program."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Other implementations\n",
    "\n",
    "-  Python can be directly translated to native code via PyREX, PyToC, and others. \n",
    "-  In this case, it will generally perform as well as C++."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Why _not_ Python?\n",
    "\n",
    "## Concurrency\n",
    "\n",
    "-  Challenging language for building highly concurrent, multithreaded applications, particularly applications with many CPU-bound threads. \n",
    "-  This is due to the **global interpreter lock** (GIL), a mechanism which prevents the (CPython) interpreter from executing more than one Python instruction at a time.\n",
    "-  However, Python C extensions that use native multithreading (in C or C++) can run code in parallel without being impacted by the GIL, so long as they do not need to interact with Python objects."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Let's start getting our hands dirty!\n",
    "\n",
    "[<span style=\"color:red\"><b>Note:</b></span> *At this stage we assume our Python environment is correctly set up. We will dedicate a specific lecture to this later on.*]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# The Python Interpreter\n",
    "\n",
    "-  The standard Python interpreter (CPython) runs a program by executing one statement at a time. \n",
    "-  It can be invoked on the command line with the <code>**python**</code> command:\n",
    "```bash\n",
    "> python\n",
    "```\n",
    "<center>![](./img/launch_python.png)</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# The Python Interpreter\n",
    "\n",
    "-  The <font face=\"Courier New\">>>></font> is the *prompt* where you will type expressions.\n",
    "-  To exit the Python interpreter and return to the shell command prompt, you can either type <code>**exit()**</code> or press <code>**Ctrl + D**</code>."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Our first Python program: <code>Hello World!</code>\n",
    "<br />\n",
    "<center>![](./img/hello_world.png)</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Our first Python program: <code>Hello World!</code>\n",
    "\n",
    "-  Instead of running it in *interactive* mode with the interpreter, a Python program can be executed directly from the command line. To do so:\n",
    "    -  Open a file with your favorite text editor (e.g., *vi*, *emacs*) and save it with <code>**.py**</code> extension (e.g., <code>**hello_world.py**</code>)\n",
    "    -  Put in it all the instructions you want to execute:\n",
    "    ```python\n",
    "    s = \"Hello World!\"\n",
    "    print(s)\n",
    "    ```\n",
    "    -  Run the following command: <code>**> python hello_world.py**</code>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Installation and Setup\n",
    "\n",
    "-  There is no single solution for setting up Python and required add-on packages. \n",
    "-  I will try to give you detailed instructions on how to set those up on each major operating system. \n",
    "-  I recommend using the free [Anaconda](https://docs.continuum.io/) distribution provided by Continuum Analytics. \n",
    "-  Anaconda is offered in both Python 2.7 and 3.7 \"flavours\". \n",
    "-  This class assumes/encourage you to use Python 3.6 or 3.7 (more on Python 2.x vs. Python 3.x later)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<span style=\"color: red\"><b>Note:</b></span> *Your system may come shipped with a default Python interpreter. Even so, we strongly encourage to follow the steps below in order to:*<br /> \n",
    "**i)** *replicate the exact environment used in this class and*<br /> \n",
    "**ii)** *practice with possible installation/configuration issues.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Apple (OS X, macOS)\n",
    "\n",
    "-  Download the OS X Anaconda installer called something like <code>Anaconda3-5.3.0-MacOSX-x86_64.pkg</code>. \n",
    "-  Double-click the <code>.pkg</code> file to run the installer. \n",
    "-  When the installer runs, it automatically appends the Anaconda executable path (e.g., <code>/usr/local/anaconda3/bin/anaconda</code>) to your <code>/Users/$USER/.bash_profile</code> file.\n",
    "-  To verify everything is working, try launching <code>**python**</code> from the Terminal application."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Additional note for OS X and macOS\n",
    "\n",
    "-  Anaconda provides an easy way to install/setup Python as it comes with hundreds of useful packages bundled.\n",
    "-  In alternative (not recommended!), you may want to install Python interpreter alone (e.g., via <code>Homebrew</code>) and then install each package you need via <code>pip</code>, which is the default Python package manager.\n",
    "-  For those who are curious, please refer to this tutorial: http://docs.python-guide.org/en/latest/starting/install3/osx/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## GNU/Linux (1 of 3)\n",
    "\n",
    "-  Linux details will vary a bit depending on your distributions, e.g., Debian, Ubuntu, CentOS, and Fedora.\n",
    "-  Setup is similar to OS X with the exception of how Anaconda is installed.\n",
    "-  The installer is a shell script that must be executed in the terminal."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## GNU/Linux (2 of 3)\n",
    "\n",
    "-  Depending on whether you have a 32-bit or 64-bit system, you will either need to install the x86 (32-bit) or x86_64 (64-bit) installer. \n",
    "-  You will then have a file named something similar to <code>Anaconda3-5.3.0-Linux-x86_64.sh</code>. \n",
    "-  To install it, execute this script with bash:\n",
    "```bash\n",
    "bash Anaconda3-5.3.0-Linux-x86_64.sh\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## GNU Linux (3 of 3)\n",
    "\n",
    "-  After accepting the license, you will be presented with a choice of where to put the Anaconda files. \n",
    "\n",
    "-  I recommend installing the files in the default location in your home directory, for example <code>/home/$USER/anaconda</code>.\n",
    "\n",
    "-  The Anaconda installer may ask if you wish to prepend its <code>bin</code> directory to your <code>$PATH</code> variable. You can always do this yourself by modifying your <code>~/.bashrc</code> file as follows:\n",
    "\n",
    "```bash\n",
    "export PATH=/home/$USER/anaconda/bin:$PATH; source ~/.bashrc\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Windows (1 of 2)\n",
    "\n",
    "-  Download the Anaconda installer for Windows from [http://continuum.io/downloads](http://continuum.io/downloads), an executable named like <code>Anaconda3-5.3.0-Windows-x86_64.exe</code>.\n",
    "-  Run the installer and accept the default installation location, which will either be <code>C:\\Python37</code> (if run as an administrator) or <code>C:\\Users\\\\$USERNAME\\Anaconda3</code> if run as a normal user.\n",
    "-  If you had previously installed Python in this location, you may want to remove it first."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Windows (2 of 2)\n",
    "\n",
    "-  The installer will also ask you if you wish to make the Anaconda distribution the default Python on your system and whether to add it to your PATH environment variable (*recommended*).\n",
    "-  To verify that things are configured correctly: \n",
    "    -  Open a command prompt (Start Menu --> Command Prompt application);\n",
    "    -  Launch the Python interpreter by typing <code>**python**</code> and you should see a message that matches your version of Anaconda."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Installing Previous Version\n",
    "\n",
    "-  You may be interested in installing a specific version of Anaconda Python distribution (e.g., 3.6 instead of the latest 3.7)\n",
    "\n",
    "-  You can do that by clicking on the following [link](https://docs.anaconda.com/anaconda/faq#how-do-i-get-the-latest-anaconda-with-python-3-5)\n",
    "\n",
    "-  In this class we will be using Python 3.6, although the latest Python 3.7 (shipped with the latest Anaconda distribution) should work seamlessly."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Installing/Updating Packages\n",
    "\n",
    "-  To install additional Python packages which are not included in the Anaconda distribution you can either use <code>conda</code> (recommended) or <code>pip</code> as follows:\n",
    "    -  <code>conda install *package_name*</code>\n",
    "    -  <code>pip install *package_name*</code>\n",
    "-  A complete reference of available <code>conda</code> commands and comparison with <code>pip</code> can be found [here](https://conda.io/docs/commands.html?highlight=pip%20virtualenv#conda-vs-pip-vs-virtualenv-commands).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Python 2 vs. Python 3\n",
    "\n",
    "-  The first version of the Python 3.x line of interpreters was released at the end of 2008. \n",
    "\n",
    "-  It included a number of changes that made some previously-written Python 2.x code **incompatible**. \n",
    "\n",
    "-  It was the major \"breaking\" update since the very first release of Python in 1991."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Python 2 vs. Python 3\n",
    "\n",
    "-  In 2012, much of the scientific and data analysis community was still using Python 2.x because many packages had not been made fully Python 3 compatible.\n",
    "\n",
    "-  However, Python 2.x will reach its development end of life in 2020, and so it is no longer a good idea to start new projects in Python 2.x.\n",
    "\n",
    "-  A good reference to understand the main differences between the two versions can be found [here](https://wiki.python.org/moin/Python2orPython3)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Text Editors and Integrated Development Environments (IDEs)\n",
    "\n",
    "-  Most text editors like [Atom](https://atom.io/) and [Sublime Text 3](https://www.sublimetext.com/) have excellent Python support.\n",
    "\n",
    "-  However, when it comes to building/package more complex software, you may want to use a more richly-featured IDE like:\n",
    "\n",
    "    -  [PyDev](http://www.pydev.org/) (free), a plugin built for the Eclipse platform;\n",
    "    -  [PyCharm](https://www.jetbrains.com/pycharm/) from JetBrains (paid for commercial users, free for open source developers);\n",
    "    -  [Python Tools for Visual Studio](https://www.visualstudio.com/vs/python/) (for Windows users);\n",
    "    -  [Spyder](https://pythonhosted.org/spyder/) (free), an IDE currently shipped with Anaconda."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Our Development Environment: Jupyter Notebook\n",
    "\n",
    "-  In this class, we will not use text editors nor fancier Python IDEs like [PyDev](http://www.pydev.org/) (Python plugin for [Eclipse](http://www.eclipse.org/)).\n",
    "-  Instead, we will use [Jupyter Notebook](http://jupyter.org/) which is a web browser-based tool for fast developing, running and visualizing Python code.\n",
    "-  Let's see how to properly set up Jupyter Notebook's environment."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# What's Jupyter Notebook?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Overview\n",
    "\n",
    "-  In a nutshell: A web application combined with a browser-based GUI which allows to create and share documents that contain live code, equations, visualizations as well as (formatted) text, exactly like **this one**.\n",
    "\n",
    "-  You can get (another) taste of Jupyter Notebook without having to install it on your local machine! Just open your web browser and go to <a href=\"https://jupyter.org/try\" target=\"_blank\">https://jupyter.org/try</a>.\n",
    "\n",
    "-  Main documentation of Jupyter can be found [here](http://jupyter.readthedocs.org/en/latest/) (also available in [pdf](https://media.readthedocs.org/pdf/jupyter/latest/jupyter.pdf)) and [here](http://jupyter-notebook.readthedocs.io/en/latest/notebook.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## A Brief History of Jupyter and IPython\n",
    "\n",
    "-  The project [Jupyter](http://jupyter.org) (as a whole) started as a spin-off project from [IPython](https://ipython.org), \n",
    "\n",
    "-  IPython was the first attempt towards developing an advanced and flexible framework for interactive, multi-language computing environment.\n",
    "\n",
    "-  Up to IPython <b>3.x</b>, this was a monolithic project.\n",
    "\n",
    "-  Starting from IPython <b>4.0</b>, the language-agnostic parts of the project have been moved out to an independent project codenamed, indeed, Jupyter."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## IPython Today: Terminal and Kernel\n",
    "\n",
    "-  IPython itself now only refers to:\n",
    "    -  **Terminal IPython** as an *advanced* Read-Eval-Print-Loop (REPL) Python console (i.e., similar to the classic Python interpreter but with some additional features, such as tab autocompletion, color highlighting, etc.);\n",
    "    -  **IPython Kernel** that provides computation and communication (i.e., backend) capabilities to the frontend interfaces, such as (but not limited to) the (web) Notebook, the Qt console, the IPython console, and any other third-party interface."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## IPython Today: Terminal and Kernel\n",
    "\n",
    "-  Frontends, like the Notebook or the Qt console, communicate with the IPython kernel using JSON messages sent over ZeroMQ sockets.\n",
    "\n",
    "-  The architecture of IPython (kernel and terminal) is depicted below:\n",
    "\n",
    "<!--<center><img src=\"img/ipython_kernel_and_terminal.png\", width=\"480\"/></center>-->\n",
    "<center>![](./img/ipython_kernel_and_terminal.png)</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## IPython: Flexible Architecure\n",
    "\n",
    "-  IPython's architecture is designed to:\n",
    "    1. Allow easy development of different frontends based on the same kernel.\n",
    "    2. Support new languages in the same frontends, by developing kernels for those languages (e.g., **R**, **Julia**, **Haskell**, **C++**, etc.)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## IPython: Adding Support for New Kernels\n",
    "\n",
    "-  There are **two** ways to develop a kernel for another language:\n",
    "    1. **Wrapper kernels** reuse the communications machinery from IPython kernel, and implement only the core execution part.\n",
    "    2. **Native kernels** implement execution and communications in the target language."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## IPython: Wrapper vs. Native Kernels\n",
    "\n",
    "-  **Wrapper kernels** are easier to write quickly for languages that have good Python wrappers, like [octave_kernel](https://pypi.python.org/pypi/octave_kernel), or languages where it's impractical to implement the communications machinery, like [bash_kernel](https://pypi.python.org/pypi/bash_kernel). \n",
    "\n",
    "-  **Native kernels** are likely to be better maintained by the community using them, like [IJulia](https://github.com/JuliaLang/IJulia.jl) or [IHaskell](https://github.com/gibiansky/IHaskell)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## IPython: Wrapper vs. Native Kernels\n",
    "\n",
    "<center>![](./img/other_kernels.png)</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Jupyter Notebook's Overall Architecture\n",
    " \n",
    "-  Jupyter Notebook therefore refers to the combination of the IPython kernel (backend) with the web-based interface provided with Notebook (frontend).\n",
    "-  The following image describes the high-level architecture of Jupyter Notebook:\n",
    "\n",
    "<center>![](./img/architecture.png)</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Jupyter Notebook's Workflow\n",
    "\n",
    "- In addition to execute code, Jupyter Notebook stores code and output in an editable document called a *notebook*. \n",
    "\n",
    "-  Once saved, this is sent from your browser to the Notebook server, which saves it on disk as a JSON file with a <code>**.ipynb**</code> extension.\n",
    "\n",
    "-  Jupyter Notebook can be executed on a local machine without Internet access (i.e., via a web browser running on the same machine where the Notebook server is running), or on a remote server and accessed through the Internet.\n",
    "\n",
    "[<strong style=\"color: red;\">Note:</strong> *We refer to \"__Notebook__\" as the Jupyter web application, whereas \"__notebook__\" stands for the JSON file representing any session stored on the Notebook server.*]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Why Jupyter Notebook?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Overview\n",
    "\n",
    "-  Jupyter Notebook has gained momentum because represents the ideal tool for supporting Data/Machine Learning Scientists in their day-to-day work.\n",
    "\n",
    "-  There are now Jupyter Notebooks on numerous topics in many scientific disciplines. Here are a few examples of those:\n",
    "    -  [LIGO Gravitational Wave Data](https://losc.ligo.org/s/events/GW150914/GW150914_tutorial.html)\n",
    "    -  [Satellite Imagery Analysis](http://unidata.github.io/python-gallery/examples/Satellite_Example.html)\n",
    "    -  [12 Steps to Navier-Stokes](https://github.com/barbagroup/CFDPython)\n",
    "    -  [Computer Vision](http://nbviewer.jupyter.org/github/ogrisel/notebooks/blob/master/Labeled%2520Faces%2520in%2520the%2520Wild%2520recognition.ipynb)\n",
    "    -  [Machine Learning](https://nbviewer.jupyter.org/github/rhiever/Data-Analysis-and-Machine-Learning-Projects/blob/master/example-data-science-notebook/Example%2520Machine%2520Learning%2520Notebook.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Literate Programming\n",
    "\n",
    "-  The reason for Jupyter’s immense success is it excels in a form of programming called \"*literate programming*\".\n",
    "\n",
    "-  A style of software development pioneered by [Donald Knuth](http://www-cs-faculty.stanford.edu/~uno/lp.html) which emphasizes a prose-first approach where exposition with human-friendly text is punctuated with code blocks. \n",
    "\n",
    "-  Cool for **research** and **teaching** (hope so!), especially for science.\n",
    "\n",
    "-  Jupyter Notebook allows and fosters the adoption of literate programming by embracing standard web technologies (i.e., mostly HTML5, JavaScript, and CSS)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# How to Install Jupyter Notebook"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Prerequisite: Python Interpreter\n",
    "\n",
    "-  While Jupyter runs code in many programming languages, the Python interpreter is a **requirement** (Python 3.3 or greater, or Python 2.7) for installing the Jupyter Notebook.\n",
    "\n",
    "-  The Python interpreter and Jupyter Notebook can be installed separately (in fact, this could be an option if you have already installed Python on your system). \n",
    "\n",
    "-  However, for a fresh install we **strongly recommend** using the [Anaconda](https://www.continuum.io/downloads) distribution."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Anaconda Distribution: Standard\n",
    "\n",
    "-  Anaconda is available for Windows, macOS, and Unix/Linux, and it comes in two open-source flavours: standard and [Miniconda](http://conda.pydata.org/miniconda.html)\n",
    "\n",
    "-  The standard version installs the Python interpreter (either one among the following versions: 2.7.13, 3.5.3, 3.6.1, or 3.7), <code>conda</code> (i.e., the package, dependency and environment manager)\n",
    "\n",
    "-  Plus, it installs **over 100** other pre-built and tested scientific and analytic Python packages. \n",
    "\n",
    "-  Among these packages are: [NumPy](http://www.numpy.org/), [pandas](http://pandas.pydata.org/), [SciPy](https://www.scipy.org/), [matplotlib](https://matplotlib.org/), [scikit-learn](http://scikit-learn.org/stable/), and - indeed - Jupyter and IPython kernel."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Anaconda Distribution: Miniconda\n",
    "\n",
    "-  Instead, Miniconda is a very basic distribution which only contains the Python interpreter and <code>conda</code>.\n",
    "\n",
    "-  In any case, over 720 additional packages (as well as the support for other languages, like R or Scala) can easily be installed with <code>conda</code>."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Possible Alternatives\n",
    "\n",
    "-  Users who want to have more control over their systems may want to install the Python interpreter on their own (provided that either they do not have one installed on their machine or they want to install a different version of the Python interpreter already installed).\n",
    "\n",
    "-  macOS users should refer to the following [tutorial](http://docs.python-guide.org/en/latest/starting/install3/osx/)\n",
    "\n",
    "-  Linux users should look into [this](http://docs.python-guide.org/en/latest/starting/install3/linux/)\n",
    "\n",
    "-  Windows users, please follow this [tutorial](http://docs.python-guide.org/en/latest/starting/install3/win/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Installing Jupyter Notebook\n",
    "\n",
    "Following from the discussion above, there are essentially two ways of installing Jupyter Notebook:\n",
    "\n",
    "-  Using the Anaconda Python Distribution (<b>highly recommended</b>);\n",
    "-  Using [pip](https://pypi.python.org/pypi/pip) (only for skilled users)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Installing Jupyter Notebook using Anaconda\n",
    "\n",
    "-  Once Anaconda is successfully installed on your machine, Jupyter Notebook (as well as any other required dependency, including the Python interpreter) is also installed, and ready to be executed.\n",
    "\n",
    "-  To actually run the Jupyter Notebook application, just open a shell and type the following command:\n",
    "\n",
    "```bash\n",
    "> jupyter notebook\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Installing Jupyter Notebook using <code>pip</code>\n",
    "\n",
    "-  This is the most \"*pythonic*\" way of installing Jupyter Notebook and, due to that, it is better for experienced and skilled Python users.\n",
    "\n",
    "-  <strong style=\"color: red;\">IMPORTANT:</strong> Jupyter installation requires Python 3.3 or greater, or Python 2.7. To provide support for Python 3.2 and 2.6, IPython 1.x - which included the parts that later became Jupyter - needs rather to be installed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Installing Jupyter Notebook using <code>pip</code>\n",
    "\n",
    "-  Make sure you have the latest <code>pip</code> as follows:\n",
    "\n",
    "```bash\n",
    "# Python 3.3 or above\n",
    "> pip3 install --upgrade pip\n",
    "```\n",
    "```bash\n",
    "# Python 2.7.x\n",
    "> pip install --upgrade pip\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Installing Jupyter Notebook using <code>pip</code>\n",
    "\n",
    "-  Then, you can install Jupyter Notebook as follows:\n",
    "\n",
    "```bash\n",
    "# Python 3.3 or above\n",
    "> pip3 install jupyter\n",
    "```\n",
    "```bash\n",
    "# Python 2.7.x\n",
    "> pip install jupyter\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## *Optional*: How to Install Additional IPython Kernels\n",
    "\n",
    "-  Installing the Jupyter Notebook will also install the corresponding IPython kernel. This allows working on notebooks using the Python programming language.\n",
    "\n",
    "-  More specifically, if Jupyter Notebook is running on Python 3 the corresponding IPython kernel (for executing Python 3 compliant code) will be installed.\n",
    "\n",
    "-  Vice versa, if Jupyter Notebook is running on Python 2 the IPython kernel installed will allow the execution of Python 2 code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## *Optional*: How to Install Additional IPython Kernels\n",
    "\n",
    "-  Still, if you are running Jupyter Notebook on Python 3, you may want to set up an IPython 2 kernel like this:\n",
    "\n",
    "```bash\n",
    "> python2 -m pip install ipykernel\n",
    "# 'Python 2' is the name shown in Notebook menus\n",
    "> python2 -m ipykernel install \\\n",
    "--user --display-name \"Python 2\"\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## *Optional*: How to Install Additional IPython Kernels\n",
    "\n",
    "-  Or using <code>conda</code>, create a Python 2 environment:\n",
    "\n",
    "```bash\n",
    "> conda create -n ipykernel_py2 python=2 ipykernel\n",
    "# On Windows, remove the word 'source'\n",
    "> source activate ipykernel_py2\n",
    "# 'Python 2' is the name shown in Notebook menus\n",
    "> python -m ipykernel install --user \\\n",
    "--display-name \"Python 2\"\n",
    "```\n",
    "\n",
    "-  If you are running Jupyter on Python 2 and want to set up an IPython 3 kernel, follow the same steps as above, replacing <code>2</code> with <code>3</code>.\n",
    "\n",
    "-  Additional information on how to install/personalize kernels can be found [here](https://ipython.readthedocs.io/en/latest/install/kernel_install.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## *Optional*: How to Install Additional Languages (R, Julia, etc.)\n",
    "\n",
    "-  To run notebooks in languages other than Python, such as R or Julia, you will need to install additional kernels. \n",
    "\n",
    "-  The full list of available kernels can be found [here](https://github.com/jupyter/jupyter/wiki/Jupyter-kernels).\n",
    "\n",
    "[<strong style=\"color: red;\">Note:</strong> *We investigate how to integrate Jupyter Notebook with R later on this notebook.*]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# How to Use Jupyter Notebook"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Starting Up the Notebook Server\n",
    "\n",
    "-  To start the Jupyter Notebook Server, open a terminal window and type the following command:\n",
    "\n",
    "```bash\n",
    "> jupyter notebook\n",
    "```\n",
    "\n",
    "-  This will print some information about the Notebook server to the stdout of your terminal, including the URL of the web application (by default, http://localhost:8888)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Starting Up the Notebook Server\n",
    "\n",
    "-  Once the notebook server is up and running, it will then open your default web browser to this URL showing the **Notebook Dashboard**, as follows:\n",
    "\n",
    "<center>![](./img/notebook_dashboard.png)</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Startup Options\n",
    "\n",
    "-  Any further Notebook Server's command line option (e.g., listening port) can be found [here](https://jupyter.readthedocs.io/en/latest/running.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Shutting Down the Notebook Server\n",
    "\n",
    "-  Finally, to shutdown the Notebook Server just go back to the terminal window where you originally started it up and press <code>**Ctrl + C**</code> and confirm your choice typing <code>**Y**</code>."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## The Notebook Dashboard\n",
    "\n",
    "-  The dashboard contains three tabs which are as follows:\n",
    "    -  **Files:** shows all files and notebooks in the current directory (i.e., the directory which you execute the <code>jupyter notebook</code> command from);\n",
    "    -  **Running:** keeps track of all kernels (processes) currently running on your computer;\n",
    "    -  **Clusters:** allows you launch kernels for parallel computing using the IPython's parallel computing framework."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## The Notebook User Interface\n",
    "\n",
    "-  To create a new notebook, click on the **New** button (top-right corner of the dashboard) and select **Notebook (Python 3)**. A new browser tab opens up and shows the Notebook interface below:\n",
    "\n",
    "<center>![](./img/notebook_interface.png)</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## The Notebook User Interface\n",
    "\n",
    "-  Here are the main components of the interface, from top to bottom:\n",
    "    -  The *Notebook name*, which you can change by clicking on it. This is also the name of the <code>.ipynb</code> file.\n",
    "    -  The *Menu bar* gives you access to several actions pertaining to either the notebook or the kernel.\n",
    "    -  To the right of the Menu bar is the *Kernel name*. You can change the kernel language of your notebook from the Kernel menu.\n",
    "    -  The *Toolbar* contains icons for common actions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## The Structure of a Notebook Cell\n",
    "\n",
    "-  There are two main types of cells: **Markdown** cells and **Code** cells.\n",
    "\n",
    "    -  A [Markdown](http://jupyter-notebook.readthedocs.io/en/latest/examples/Notebook/Working%20With%20Markdown%20Cells.html) cell contains rich text. In addition to classic formatting options like **bold** or *italics*, we can add links, images, HTML elements, LaTeX mathematical equations, and much more (full specifications available [here](http://daringfireball.net/projects/markdown/)).\n",
    "\n",
    "    -  A Code cell contains code to be executed by the kernel. The programming language corresponds to the kernel's language.\n",
    "\n",
    "-  The type of a cell can be changed by first clicking on a cell to select it, and then choosing the cell's type in the toolbar's dropdown menu showing **Markdown** or **Code**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Markdown Cell\n",
    "\n",
    "<center>![](./img/markdown_cell.png)</center>\n",
    "\n",
    "-  The top panel shows the cell in **edit mode**, while the bottom one shows it in **render mode**.\n",
    "\n",
    "-  The edit mode lets you edit the text, while the render mode lets you display the rendered cell."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "## Example\n",
    "\n",
    "This is a Markdown cell where we can write **bold**, *italic*, or any other HTML-formatted text.\n",
    "\n",
    "We can add hyperlinks either using Markdown-specific syntax:\n",
    "\n",
    "[link using Markdown syntax](https://jupyter.readthedocs.io/en/latest/)\n",
    "\n",
    "or traditional HTML syntax:\n",
    "\n",
    "<a href=\"https://jupyter.readthedocs.io/en/latest/\" target=\"_blank\">link using HTML syntax</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "![](./img/markdown_cell_1.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Example\n",
    "\n",
    "This is a Markdown cell where we can write **bold**, *italic*, or any other HTML-formatted text.\n",
    "\n",
    "We can add hyperlinks either using Markdown-specific syntax:\n",
    "\n",
    "[link using Markdown syntax](https://jupyter.readthedocs.io/en/latest/)\n",
    "\n",
    "or traditional HTML syntax:\n",
    "\n",
    "<a href=\"https://jupyter.readthedocs.io/en/latest/\" target=\"_blank\">link using HTML syntax</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "## Example\n",
    "\n",
    "Plus, we can also include mathematics in a straightforward way, using standard LaTeX notation: \\$...\\$ for inline mathematics $\\bar{X}=\\frac{1}{N}\\sum_{i=1}^N X_i$, and \\$\\$...\\$\\$ for displayed mathematics:\n",
    "$$\\bar{X}=\\frac{1}{N}\\sum_{i=1}^N X_i$$\n",
    "\n",
    "Not to mention, we can write down code with highlight syntax:\n",
    "\n",
    "```python\n",
    "print(\"Hello world!\")\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "![](./img/markdown_cell_2.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Example\n",
    "\n",
    "Plus, we can also include mathematics in a straightforward way, using standard LaTeX notation: \\$...\\$ for inline mathematics $\\bar{X}=\\frac{1}{N}\\sum_{i=1}^N X_i$, and \\$\\$...\\$\\$ for displayed mathematics:\n",
    "$$\\bar{X}=\\frac{1}{N}\\sum_{i=1}^N X_i$$\n",
    "\n",
    "Not to mention, we can write down code with highlight syntax:\n",
    "\n",
    "```python\n",
    "print(\"Hello world!\")\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "## Example\n",
    "\n",
    "Finally, we can attach both local and remote images, again, using either Markdown-specific or HTML syntax.\n",
    "\n",
    "local/Markdown-specific:\n",
    "<center>![This is a local image using Markdown syntax](./img/jupyter_logo.svg)</center>\n",
    "local/HTML:\n",
    "<div>\n",
    "<center><img src=\"./img/jupyter_logo.svg\" title=\"This is a local image using HTML syntax\"></center>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "![](./img/markdown_cell_3.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Example\n",
    "\n",
    "Finally, we can attach both local and remote images, again, using either Markdown-specific or HTML syntax.\n",
    "\n",
    "local/Markdown-specific:\n",
    "<center>![This is a local image using Markdown syntax](./img/jupyter_logo.svg)</center>\n",
    "local/HTML:\n",
    "<div>\n",
    "<center><img src=\"./img/jupyter_logo.svg\" title=\"This is a local image using HTML syntax\"></center>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "## Example\n",
    "\n",
    "remote/Markdown-specific:\n",
    "<center>![This is a remote image using Markdown syntax](https://jupyter.readthedocs.io/en/latest/_static/_images/jupyter.svg)</center>\n",
    "remote/HTML:\n",
    "<div>\n",
    "<center><img src=\"https://jupyter.readthedocs.io/en/latest/_static/_images/jupyter.svg\" title=\"This is a remote image using HTML syntax\"></center>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "![](./img/markdown_cell_4.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Example\n",
    "\n",
    "remote/Markdown-specific:\n",
    "<center>![This is a remote image using Markdown syntax](https://jupyter.readthedocs.io/en/latest/_static/_images/jupyter.svg)</center>\n",
    "remote/HTML:\n",
    "<div>\n",
    "<center><img src=\"https://jupyter.readthedocs.io/en/latest/_static/_images/jupyter.svg\" title=\"This is a remote image using HTML syntax\"></center>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Code Cell\n",
    "\n",
    "<center>![](./img/code_cell.png)</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Code Cell\n",
    "\n",
    "-  The *Prompt number* shows the cell's number. This increases every time you run the cell (possibly unordered as you can run cells arbitrarily).\n",
    "-  The *Input area* contains a multiline text editor that lets you write code with syntax highlighting.\n",
    "-  The *Widget area* may contain graphical controls.\n",
    "-  The *Output area* can contain multiple outputs, specifically:\n",
    "    -  Standard output (text in black)\n",
    "    -  Error output (text with a red background)\n",
    "    -  Rich output (in the screenshot above, an HTML table and an image)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# This is a code cell\n",
    "def add(a, b):\n",
    "    return a + b\n",
    "\n",
    "add(5, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX0AAAD8CAYAAACb4nSYAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4xLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvAOZPmwAAIABJREFUeJzt3Xl4VeW5/vHvkxlCCFPCkBkSZpkMAUScQMVqwakKFIE6t6L2+PNUe9pqa21Pq63H1tJTOY6oiCjWUsWiqKDIGEaZAiEDGYAkBAiEzHl+f2TbphHIJiRZe3g+15XLvddeK9z7ktysrP2u9xVVxRhjjH8IcDqAMcaY9mOlb4wxfsRK3xhj/IiVvjHG+BErfWOM8SNW+sYY40es9I0xxo9Y6RtjjB+x0jfGGD8S5HSApnr06KGJiYlOxzDGGK+yadOmElWNam4/jyv9xMRE0tPTnY5hjDFeRURy3dnPLu8YY4wfsdI3xhg/YqVvjDF+xErfGGP8iFulLyKTRSRDRDJF5NGz7HeziKiIpDba9mPXcRkicnVrhDbGGNMyzY7eEZFAYB5wJZAPbBSRpaq6q8l+EcADwPpG2wYD04AhQB9ghYj0V9W61nsLxhhj3OXOmX4akKmqWapaDSwCpp5mv18CTwGVjbZNBRapapWqZgOZru9njDHGAe6M048B8ho9zwfGNN5BREYCcar6vog83OTYdU2OjWlhVmPaXVFZJRtyStl7+CS4lhYNDQ5keGwXRsZ3ITzU4251Meas3PkbK6fZ9s+FdUUkAPgfYM65Htvoe9wN3A0QHx/vRiRj2s7R8mpeXpPD37YWkHvk1D+3i+tv89fLSgcGCMNiI5k1LoFvD+tDUKCNizCez53SzwfiGj2PBQobPY8AhgIrpeGnohewVESmuHEsAKo6H5gPkJqaaiu1G0cUnajk+VVZLFx/gIqaOi7tH8VtYxMYndiNwX06E+wq9ROVNWw+cIyN2aV8tOsQ//HWNn7/0V7uubQf00bH/XM/YzyRqJ69Y0UkCNgLTAQKgI3ADFXdeYb9VwIPq2q6iAwBFtJwHb8P8AmQcrYPclNTU9WmYTDt7R87DvHjd7dTVlnL1BF9+P6l/UjpGdHscfX1yqd7ipi3MpMtB44xPDaS/7l1BH2jOrVDamP+RUQ2qWpqc/s1e6avqrUiMhdYDgQCL6nqThF5AkhX1aVnOXaniCwGdgG1wH02csd4kvKqWn7x950sTs9naExn3r51BMnRzZf91wIChEmDezJxUDTLvjrEf/31K67942p+dt1gpqfFIXK6K5zGOKfZM/32Zmf6pr0Unahk1osbyDh8gh9c1o8HJ/YnJOj8Ls0cOl7Jw29vY3VmCdPT4nny+qEEBljxm7bXamf6xviivNJTzHxxPcUnqnj1e2lc0r/ZGWnd0isyjAW3p/G7jzL488r9lFXW8D+3jDjvf0yMaS1W+sbv7D18gpkvrKeqtp437hzDyPiurfr9AwKEH00eSJeOwfx62R7KKmp4/rYL6RhiP27GeXb6YfxKXukpZvxfw03ji+8Z1+qF39jdl/TjqZuG8WVmCT94YzO1dfVt9mcZ4y4rfeM3jp+qYc7LG6iureONO8cwoJf7H9i21C2j43jy+gtYmVHMz/62A0/7DM34H/t90/iFqto67notnbzSChbckebWcMzWMmNMPPlHT/HnlfuJ7dqR+y5Pbrc/25imrPSNz1NVHnlnOxuyS/nj9JGM7du93TP859UDKDxWwdPLM4jr1pEpw/u0ewZjwC7vGD+wcMMB3ttayP+7sr9jZSsiPHXzcEYnduXHS7aTVXzSkRzGWOkbn7arsIxf/H0Xl/SPcvyySkhQAH+cPpKQoADuW7iFyhq7T9G0Pyt947NOVtUyd+FmunQI5plbhhPgATdJ9Y7swDO3jGD3wTJ++f6u5g8wppVZ6Ruf9dh7O8g5Us4fp4+kR6dQp+P80+UDo7nnkr68sf4AH2w/6HQc42es9I1P+mjnId7dUsD9V6Q48sFtcx6+egDD47rw0/e+ouRkldNxjB+x0jc+5/ipGn763g4G9e7M3Cs8c3hkcGAAT988jPKqOn6+9LQT1hrTJqz0jc958oNdHCmv5umbh3n03Pb9e0Zw/xXJvL/9IP/YccjpOMZPeO5PhDEt8PneYt7elM89l/RlaEyk03Gade9l/RjcuzM/+9sOjp+qcTqO8QNW+sZnVFTX8eN3v6JfVDgPTExxOo5bggMDeOrmYZSWV/PrZbudjmP8gJW+8Rn/u2o/Bccq+PUNFxAWHOh0HLcNjYnkjouTeCs9j615x5yOY3ycW6UvIpNFJENEMkXk0dO8fq+IfCUiW0VktYgMdm1PFJEK1/atIvKX1n4DxkDD7Jl/WbWfKcP7MMYDR+s05/4rkomKCOXxv+2gvt4mZTNtp9nSF5FAYB5wDTAYmP51qTeyUFUvUNURwFPAM41e26+qI1xf97ZWcGMa++X7uwgU4cffGuh0lBaJCAvm0ckD2ZZ/nHc25zsdx/gwd87004BMVc1S1WpgETC18Q6qWtboaThgpyqm3Xy+t5iPdh1m7hXJ9I7s4HScFrthZAyj4rvw1D/2UFZpH+qatuFO6ccAeY2e57u2/RsRuU9E9tNwpv9Ao5eSRGSLiKwSkQnnldaYJmrq6vnF33eS2L0jd05IcjrOeQkIEJ6YOpQj5dX8YcU+p+MYH+VO6Z9uwpJvnMmr6jxV7Qc8AvzUtfkgEK+qI4GHgIUi0vkbf4DI3SKSLiLpxcXF7qc3fu+tjXnsLy7nJ9cOJjTIez68PZOhMZHccmEcC9bmkFd6yuk4xge5U/r5QFyj57FA4Vn2XwRcD6CqVap6xPV4E7Af6N/0AFWdr6qpqpoaFdU6C1Qb31deVcuzK/YxOrErkwZFOx2n1fzHlf0JDBB+91GG01GMD3Kn9DcCKSKSJCIhwDRgaeMdRKTxoOhrgX2u7VGuD4IRkb5ACpDVGsGNeXF1NiUnq3j0mkGIOD+DZmvpFRnG7eOT+NvWQnYUHHc6jvExzZa+qtYCc4HlwG5gsaruFJEnRGSKa7e5IrJTRLbScBlntmv7JcB2EdkGvAPcq6qlrf4ujN85crKK51ft5+ohPbkwoe0WN3fKPZf2o0vHYH77jz1ORzE+xq3lElV1GbCsybbHGj1+8AzHLQGWnE9AY07nuU8zqaip4z+v9s4hms2J7BDM3MuTefKD3azeV8LFKT2cjmR8hN2Ra7xOXukp3lify62j40iO7uR0nDYzc2wCMV068NTyPajaKGjTOqz0jdeZ91kmgnjN/DotFRYcyIMTU9ief5xPdhc5Hcf4CCt941XySk/xzqZ8pqfFefWNWO66YVQM8d068uwne+1s37QKK33jVf70aSYBAcL3L/PMxVFaW3BgAPdfkcyOgjJW2Nm+aQVW+sZrHDhyinc25zMjLZ5ekWFOx2k3N4yMIaF7R55dYWf75vxZ6Ruv8dyn+wgKEL5/WT+no7SroMAA7r8ihZ2FZXy067DTcYyXs9I3XuHAkVO8u6WAGWPi6dnZf87yv3b9iD4k9QjnDyv22dm+OS9W+sYr/OXz/QSKcO+l/nWW/7WgwAB+cFk/dh0sY2WGzU9lWs5K33i8orJK3knP5+bUWL88y//a9SNjiOnSgXmfZTodxXgxK33j8V5YnU1tfT33XuKfZ/lfCw4M4O5L+pKee5QN2TabiWkZK33j0Y6dquaNdbl8e3gf4rt3dDqO425JjaN7eIid7ZsWs9I3Hu3VNbmUV9f53YidM+kQEsjtFyexam+xzcBpWsRK33is8qpaXl6TzaRB0Qzs9Y21d/zWbeMSiAgN4s8r7WzfnDsrfeOx3tqYx7FTNX5z9627OocFM3NcAh/uOEROSbnTcYyXsdI3Hqm2rp4XV2czOrGrT86Xf76+d1EiwQEBvLDa1iQy58ZK33ikZTsOUXCsgrsm9HU6ikeK7hzG9SP78HZ6PkdOVjkdx3gRt0pfRCaLSIaIZIrIo6d5/V4R+UpEtorIahEZ3Oi1H7uOyxCRq1szvPFNqsr8z/fTt0c4kwb1dDqOx7prQl+qaut5fd0Bp6MYL9Js6bvWuJ0HXAMMBqY3LnWXhap6gaqOAJ4CnnEdO5iGNXWHAJOBP3+9Zq4xZ7Iuq5QdBWXcOaEvAQG+s/Zta0vpGcEVA6NZsDaHypo6p+MYL+HOmX4akKmqWapaDSwCpjbeQVXLGj0NB76eHGQqsEhVq1Q1G8h0fT9jzmj+5/vpHh7CjaNinI7i8e6a0Jcj5dUs2ZzvdBTjJdwp/Rggr9HzfNe2fyMi94nIfhrO9B84l2ON+drewyf4LKOY2RclEhZsvxQ2Z2zfbgyLjeSFL7Kpr7eJ2Ezz3Cn90/1+/Y2/Xao6T1X7AY8APz2XY0XkbhFJF5H04mKbTMqfvbQ6m9CgAGaOTXA6ilcQEe6c0JfsknI+3WOLrJjmuVP6+UBco+exQOFZ9l8EXH8ux6rqfFVNVdXUqKgoNyIZX3TkZBXvbingxlGxdAsPcTqO17hmaC96R4bx0pfZTkcxXsCd0t8IpIhIkoiE0PDB7NLGO4hI4xWqrwX2uR4vBaaJSKiIJAEpwIbzj2180cL1B6iuref28YlOR/EqwYEBzL4okTX7j7CrsKz5A4xfa7b0VbUWmAssB3YDi1V1p4g8ISJTXLvNFZGdIrIVeAiY7Tp2J7AY2AX8A7hPVW2YgfmG6tp6FqzL5ZL+UaT0jHA6jteZPjqeDsGBvGxn+6YZQe7spKrLgGVNtj3W6PGDZzn2V8CvWhrQ+If3txdSfKKKp29OdDqKV4rsGMzNF8by1sY8fjR5IFERoU5HMh7K7sg1jlNVXlydTXJ0Jy7tb5/ptNSc8YlU19Xzxvpcp6MYD2albxy3MecoOwvL+N74RETsZqyW6hfViSsGRvP6ulyqau0qqjk9K33juJe/zCayQzA3jox1OorXu318EiUnq3l/20GnoxgPZaVvHFVwrIKPdh1mWlocHULsZqzzNT65O8nRnXhlTQ6qdrOW+SYrfeOo19floqrcZjdjtQoRYc5FiXxVcJzNB445Hcd4ICt945jKmjre3HCAqwb3IrarrX/bWm4YGUNEWBCvrMlxOorxQFb6xjFLtxZy7FQNc+xmrFYVHhrEralxfPjVQQ6XVTodx3gYK33jCFXl5TU5DOwVwZikbk7H8TmzxiVSp8ob62z4pvl3VvrGERuyS9l9sIw5F9kwzbYQ370jEwdG88b6AzZ80/wbK33jiAVrc4nsEMzUETbTdluZc1ESR8qrWfaVDd80/2Klb9rdweMV/GPnIaaNtmGabWl8cnf6RoXzyhq7xGP+xUrftLuF6w9Qr2pz5rcxEWH2uES25R1ja54N3zQNrPRNu6qqbRimOXFgNHHdbJhmW7txVAzhIYEsWJvjdBTjIaz0Tbv68KtDlJysZta4RKej+IWIsGBuujCW97cd5MjJKqfjGA9gpW/a1atrc+jbI5yLk3s4HcVvzBqXQHVdPYs25jW/s/F5Vvqm3WzPP8aWA8e4bVwCAQE2TLO9JEdHMD65O2+sy6W2rt7pOMZhbpW+iEwWkQwRyRSRR0/z+kMisktEtovIJyKS0Oi1OhHZ6vpa2vRY4z8WrM2lY0ggN11os2m2t1njEik8XsmK3bZ4ur9rtvRFJBCYB1wDDAami8jgJrttAVJVdRjwDvBUo9cqVHWE62sKxi8dLa9m6bZCbhgZQ+ewYKfj+J2JA6PpExnGa+tynI5iHObOmX4akKmqWapaDSwCpjbeQVU/U9VTrqfrADuVM//mrfQ8qmvr7QNchwQFBvDdsQl8mXmEzKITTscxDnKn9GOAxp8A5bu2nckdwIeNnoeJSLqIrBOR61uQ0Xi5unrl9XW5pCV1Y0AvW/TcKdNGxxESGMBra+1mLX/mTumf7hO3067OICIzgVTg6Uab41U1FZgBPCsi/U5z3N2ufxjSi4uL3YhkvMnKjCLyj1Ywa5zdjOWk7p1CuXZYb5ZsLuBkVa3TcYxD3Cn9fCCu0fNYoLDpTiIyCfgJMEVV/zkgWFULXf/NAlYCI5seq6rzVTVVVVOjomxhbF+zYG0u0RGhXD2kl9NR/N5t4xI4WVXLX7cUOB3FOMSd0t8IpIhIkoiEANOAfxuFIyIjgedpKPyiRtu7ikio63EPYDywq7XCG8+XU1LOqr3FzBgTT3CgjRB22si4LgyN6cxra205RX/V7E+hqtYCc4HlwG5gsaruFJEnROTr0ThPA52At5sMzRwEpIvINuAz4DeqaqXvR15fl0tQgDAjLd7pKIaG+XhmjUtk7+GTrMsqdTqOcUCQOzup6jJgWZNtjzV6POkMx60BLjifgMZ7VVTXsTg9j6uH9iK6c5jTcYzLlOF9+PWy3by2Lodx/bo7Hce0M/t927SZv20toKyyllk2m6ZHCQsO5JbUOJbvPMyh47acor+x0jdtQlVZsDaXgb0iSLPlED3OzDEJ1KuycMMBp6OYdmalb9rE5gNH2XWwjNvGJdhyiB4ovntHLusfxZsbDlBda/Px+BMrfdMmXl2TS0RoENfbcogea9ZFiRSfqOIfOw85HcW0Iyt90+qKT1Tx4Y6D3HRhLOGhbo0VMA64NCWKhO4deW1tjtNRTDuy0jetbtGGA9TUKbfZHbgeLSBAmDkmgY05R9lVWOZ0HNNOrPRNq6qtq+eN9QeYkNKDflGdnI5jmvGd1FhCgwJ4bZ3Nx+MvrPRNq/p412EOlVXabJpeokvHEK4fEcN7Wwo4fqrG6TimHVjpm1b16tocYrp04IqB0U5HMW66bVwCFTV1vL3JllP0B1b6ptVkHDrBuqxSbhuXQKAth+g1hsZEkprQldfW5VJfb/Px+DorfdNqFqzNITQogFtT45rd13iWWRclknvkFKv22dTmvs5K37SKssoa/rqlgCnD+9A1PMTpOOYcTR7Si6iIUBasyXE6imljVvqmVSzZlM+p6jpmX5TodBTTAiFBAcxIi2fl3mJySsqdjmPakJW+OW/19cpra3MZGd+FoTGRTscxLTRjTDyBIjZ808dZ6Zvz9vm+YrJKypljZ/lerWfnMK65oDeL0/Mot+UUfZaVvjlvr6zJISoilGuG9nY6ijlPcy5K4ERlLe/acoo+y63SF5HJIpIhIpki8uhpXn9IRHaJyHYR+UREEhq9NltE9rm+ZrdmeOO87JJyVmYU890x8YQE2TmEtxsV35ULYiJZsMaWU/RVzf6UikggMA+4BhgMTBeRwU122wKkquow4B3gKdex3YDHgTFAGvC4iHRtvfjGaa+uySE4UJgxxpZD9AUiwuyLEtlXdJI1+484Hce0AXdOzdKATFXNUtVqYBEwtfEOqvqZqp5yPV0HxLoeXw18rKqlqnoU+BiY3DrRjdNOVtXyzqZ8rr2gN9ERthyir7huWG+6h4fw8pc5TkcxbcCd0o8BGt+fne/adiZ3AB+28FjjRZZsyudkVa0N0/QxYcGBTE+L55M9h8krPdX8AcaruFP6p7uf/rQX+0RkJpAKPH0ux4rI3SKSLiLpxcV2R6A3qK9XXl2bw/DYSEbG2xU7XzNzbAKBIixYm+N0FNPK3Cn9fKDxffWxQGHTnURkEvATYIqqVp3Lsao6X1VTVTU1KirK3ezGQav2FZNVXM7tFyc5HcW0gV6RYUwe2otFG234pq9xp/Q3AikikiQiIcA0YGnjHURkJPA8DYVf1Oil5cBVItLV9QHuVa5txsu9tDqbaBum6dNuvziJE5W1LNmc73QU04qaLX1VrQXm0lDWu4HFqrpTRJ4QkSmu3Z4GOgFvi8hWEVnqOrYU+CUN/3BsBJ5wbTNebN/hE3yxr4RZ4xJsmKYPGxXflRFxXXj5yxybfdOHuLWAqaouA5Y12fZYo8eTznLsS8BLLQ1oPM/Laxpm05yeZsM0fd33xify4KKtrNxbxBUDezodx7QCO00z5+TYqWre3ZzPDSNj6N4p1Ok4po1964Le9OwcasM3fYiVvjknb27Io7KmnjnjE52OYtpBcGAAs8Yl8sW+EvYePuF0HNMKrPSN22rq6lmwNofxyd0Z2Kuz03FMO5mRFk9oUAAvrc52OoppBVb6xm0fbD/IweOV3GHDNP1K1/AQbhwVy7tbCig5WdX8AcajWekbt6gqL6zOol9UOJf1t0XP/c0dFydRXVvPa2ttrn1vZ6Vv3LIuq5QdBWXcOaEvAbboud9Jju7ExIHRvLYul8qaOqfjmPNgpW/c8sIXWXQPD+GGkTZ1kr+6Y0ISpeXV/NXm2vdqVvqmWZlFJ/lkTxEzxyYQFhzodBzjkHF9uzOkT2de+CLLbtbyYlb6plkvrs4mJCiA28YlNL+z8Vkiwl0T+rK/uJyVe4uaP8B4JCt9c1YlJ6t4d3M+N46MoYfdjOX3rh3Wm16dw5j/eZbTUUwLWembs3p1TQ7VdfXcOaGv01GMBwgODOD2ixNZl1XKtrxjTscxLWClb86ovKqWBWtzuXJQT5KjOzkdx3iI6WnxRIQF8fzn+52OYlrASt+c0Vsb8zheUcM9l/ZzOorxIBFhwcwcm8CHOw6RXVLudBxzjqz0zWnV1NXz4ups0hK7cWGCrYxl/t33xicSHBDA/31h1/a9jZW+Oa33txdScKyCey61a/nmm6Ijwrjpwhje2ZRP0YlKp+OYc2Clb75BVXl+VRb9e3bi8gE25YI5vbsm9KWmrp5XbNplr+JW6YvIZBHJEJFMEXn0NK9fIiKbRaRWRG5u8lqdazWtf66oZTzbZxlF7Dl0gnsu6WdTLpgz6hvViclDevHaulzKKmucjmPc1Gzpi0ggMA+4BhgMTBeRwU12OwDMARae5ltUqOoI19eU07xuPIiq8tynmcR27cCUEX2cjmM83A8uS+ZEZa1NxOZF3DnTTwMyVTVLVauBRcDUxjuoao6qbgfq2yCjaUdr9x9hy4Fj3HtpP4ID7eqfObsLYiO5bEAUL63OpqLaJmLzBu78VMcAeY2e57u2uStMRNJFZJ2IXH9O6Uy7+9NnmURHhHLzhbFORzFeYu7lyRwpr+bNDQecjmLc4E7pn+6i7rnMthSvqqnADOBZEfnGoG8Rudv1D0N6cXHxOXxr05o2HzjKmv1HuPuSvjaxmnFbamI3xiR1Y/7nWVTV2tm+p3On9POBuEbPY4FCd/8AVS10/TcLWAmMPM0+81U1VVVTo6Ki3P3WppXN+zSTrh2DmTEm3ukoxsvMvSKZQ2WVvLvZpl32dO6U/kYgRUSSRCQEmAa4NQpHRLqKSKjrcQ9gPLCrpWFN29lRcJxP9hRx+/gkOoYEOR3HeJmLk3swPK4Lf16ZSU2dfbTnyZotfVWtBeYCy4HdwGJV3SkiT4jIFAARGS0i+cB3gOdFZKfr8EFAuohsAz4DfqOqVvoe6A+f7KNzWBCzxyc6HcV4IRHhwYnJ5JVW8Fc72/dobp3SqeoyYFmTbY81eryRhss+TY9bA1xwnhlNG9tRcJyPdx3moSv70zks2Ok4xktdPiCa4bGRPPfZPm4YFWOjvzyU/V8xPLtiL5EdgpljZ/nmPIgIP5zUn7zSCpZsync6jjkDK30/91X+cVbsLuLOi5PsLN+ct8sGRDE8NpI/fZZJda1d2/dEVvp+zs7yTWv6+mw//2gFSzbb2b4nstL3Y1vzjvHJniLumpBEhJ3lm1Zy2YAohsd14U+fZtq4fQ9kpe/Hnl6+h27hIcy+KNHpKMaHiAj/78r+FByrYOF6u0vX01jp+6kvM0v4MvMIP7isn53lm1Y3IaUHY/t240+fZlJeVet0HNOIlb4fUlWeWp5Bn8gwZo5NcDqO8UEiwo8mD+RIeTUvrc52Oo5pxErfDy3feZhtecd4cFKKzbFj2syo+K5MGtST+Z9ncbS82uk4xsVK38/U1Su//yiDvlHh3DTKZtI0bes/rx7Ayepa/rJqv9NRjIuVvp9ZsjmffUUnefiqAQTZHZOmjQ3oFcENI2J4ZU0OhccqnI5jsNL3K6eqa/nd8gxGxHXhmqG9nI5j/MRDV/VHgd8tz3A6isFK36/M/zyLohNV/PTaQYjY2remfcR27cjt45N4d0sBX+UfdzqO37PS9xNFZZU8vyqLa4b2IjWxm9NxjJ/5weX96BYewq+W7UL1XNZgMq3NSt9P/P6jvdTW1/PI5IFORzF+qHNYMD+clMK6rFJW7C5yOo5fs9L3A7sPlrF4Ux63jU0ksUe403GMn5qeFk/fqHD++8PdttCKg6z0fZyq8vOlO4nsEMwDE5OdjmP8WHBgAD/51iCyist5dU2O03H8llulLyKTRSRDRDJF5NHTvH6JiGwWkVoRubnJa7NFZJ/ra3ZrBTfueX/7QdZnl/LwVQPo0jHE6TjGz10xMJrLB0Tx7Ip9FJ2odDqOX2q29EUkEJgHXAMMBqaLyOAmux0A5gALmxzbDXgcGAOkAY+LSNfzj23cUV5Vy68+2M2QPp2ZnmaLnRvniQiPfXsI1bX1/ObDPU7H8UvunOmnAZmqmqWq1cAiYGrjHVQ1R1W3A00v1F0NfKyqpap6FPgYmNwKuY0b5n2WyaGySp6YOoTAABuiaTxDUo9w7piQxLubC9iUW+p0HL/jTunHAHmNnue7trnjfI415yG7pJwXvsjmxpExXJhgQzSNZ5l7eTK9Oofx+NKd1NXbEM725E7pn+4U0d3/S24dKyJ3i0i6iKQXFxe7+a3NmagqP3tvByFBATx6jQ3RNJ4nPDSIn1w7iB0FZby2NsfpOH7FndLPB+IaPY8FCt38/m4dq6rzVTVVVVOjoqLc/NbmTP66pYDVmSU8MnkA0Z3DnI5jzGldN6w3l/SP4unlGTYvTztyp/Q3AikikiQiIcA0YKmb3385cJWIdHV9gHuVa5tpI6Xl1Tz5wW5Gxnfhu2NsrnzjuUSEX10/lDpVHl+60+k4fqPZ0lfVWmAuDWW9G1isqjtF5AkRmQIgIqNFJB/4DvC8iOx0HVsK/JKGfzg2Ak+4tpk28utluymrqOG/b7yAAPvw1ni4uG4d+Y9J/fl412H+seOQ03H8gnjaPBipqamanp7udAyvtCazhBkvrOcHl/XjRzbdgvEStXX1TPnTlxxyM85UAAAPdUlEQVQpr+Ljhy6lsy3f2SIisklVU5vbz+7I9REnq2r50ZLtJHbvyAMTU5yOY4zbggID+M1NF1B8ooon39/ldByfZ6XvI369bDcFxyr43XeG2xKIxusMi+3C9y/rx+L0fD7dc9jpOD7NSt8HfL63mIXrD3DXhL42bbLxWg9MTGFgrwgeXfIVx07ZmrptxUrfyx2vqOGRJdtJju7EQ1f2dzqOMS0WGhTI728ZTml5NT+30Txtxkrfy/186U6KTlTxe7usY3zAkD6R3H9FCu9tLeSD7QedjuOTrPS92Lub8/nrlgLuvyKZ4XFdnI5jTKv4weX9GBHXhUff3U5e6Smn4/gcK30vlV1Szk/f20FaUjfuv8JG6xjfERwYwHPTR4LCg4u22IIrrcxK3wtV19Zz/5ubCQkK4A/TRtgMmsbnxHXryK9vvIDNB47xhxX7nI7jU6z0vdBvPtzDjoIynrppGL0jOzgdx5g28e3hfbglNZZ5KzNZva/E6Tg+w0rfyyzdVshLX2Yz56JErhrSy+k4xrSpn08ZQkp0J+5/czP5R+36fmuw0vciew6V8cg72xmd2JX/+tYgp+MY0+Y6hgTxl5kXUlunfP/1zVTW1DkdyetZ6XuJ4xU13PPaJiLCgpg3YxQhQfa/zviHvlGdeObWEXxVcJyfvbcDT5svzNtYc3iB2rp6Hly0hcJjFfzvzFE2R77xO1cO7skDVyTz9qZ8FqzNdTqOV7PS93CqyhPv72JlRjG/mDLUlj40fuvBSf2ZNCiaX/x9J5/tKXI6jtey0vdwL3+Zw4K1udx9SV9mjIl3Oo4xjgkMEP4wbSSDendm7sLN7CosczqSV7LS92Ardh3mlx/s4uohPXnU5sc3hvDQIF6cPZqIsGDueHUjh8sqnY7kddwqfRGZLCIZIpIpIo+e5vVQEXnL9fp6EUl0bU8UkQoR2er6+kvrxvddG7JLmfvmZi6IieTZW0faKljGuPSKDOOlOaMpq6hh1osbbEbOc9Rs6YtIIDAPuAYYDEwXkcFNdrsDOKqqycD/AL9t9Np+VR3h+rq3lXL7tB0Fx7njlY306dKBl+eMpkOITaRmTGOD+3Rm/qxUskvKmf3yRk5W1TodyWu4c6afBmSqapaqVgOLgKlN9pkKvOp6/A4wUUTs1LQFMotOMuulDXTuEMzrd4yhe6dQpyMZ45HGJ/fguRkj2VFwnLsXpNsYfje5U/oxQF6j5/mubafdx7WQ+nGgu+u1JBHZIiKrRGTCeeb1aVnFJ5n5wnoCRHj9zjH06WJTLBhzNlcP6cXTNw9jzf4j3Pv6Jit+N7hT+qc7Y296d8SZ9jkIxKvqSOAhYKGIdP7GHyByt4iki0h6cXGxG5F8z97DJ7jl+XXU1NXz+p1pJPUIdzqSMV7hxlGx/PeNF7BqbzF3vppORbUV/9m4U/r5QFyj57FA4Zn2EZEgIBIoVdUqVT0CoKqbgP3AN5Z3UtX5qpqqqqlRUVHn/i683K7CMqbNX0eAwFv3jGVgr2/8u2iMOYvpafE8ddMwvtxfwpyXN1Bu1/jPyJ3S3wikiEiSiIQA04ClTfZZCsx2Pb4Z+FRVVUSiXB8EIyJ9gRQgq3Wi+4YN2aVMm7+W0KAA3rpnHMnREU5HMsYrfSc1jmdvHUF67lFmvLCekpNVTkfySM2Wvusa/VxgObAbWKyqO0XkCRGZ4trtRaC7iGTScBnn62GdlwDbRWQbDR/w3quqpa39JrzVB9sPMvOF9fSICGXxPePsko4x52nqiBj+97uj2HOwjJv+dw05JeVOR/I44mmTF6Wmpmp6errTMdqUqvLi6mye/GA3qQld+b9ZqXQND3E6ljE+Y1PuUe58dSMiwguzUxkV39XpSG1ORDapampz+9kdue2ssqaOh9/ezpMf7Oaaob14/c4xVvjGtLILE7qy5PsX0Sk0iGnz17F4Y17zB/kJK/12VHCsgu/8ZS1LNufz4MQU5s0YRViw3XhlTFvoG9WJ9+4bT1piN360ZDs/fe8rqmttvd0gpwP4i0/3HObht7dTU1vP/81K5crBPZ2OZIzP6xYewivfG83TH2Xw/KosdhaW8cdpI4nr1tHpaI6xM/02VllTx+N/28Htr6TTs3MY780db4VvTDsKCgzgx9cMYt6MUWQWneRbf/iC97YUOB3LMXam34a25x/jP9/eTsbhE9xxcRI/mjyA0CC7nGOME64d1pvhcZH8x1tb+eFbW/l0TxE/nzKEbn72mZqVfhs4VV3LMx/t5aUvs4mKCOXV29O4tL//3XRmjKeJ7dqRN+8ay59X7ue5T/exOrOEx64bzNQRffCX6cJsyGYrUlU+2nWYJz/YRV5pBTPGxPPoNQPpHBbsdDRjTBMZh07wyJLtbM07xiX9o3jsusEkR3dyOlaLuTtk00q/lewqLOOX7+9ibdYRkqM78avrhzKmb/fmDzTGOKauXlmwNodnPtrLqZo6bhubwA8npdClo/dd8rHSbyfZJeX88ZN9/G1rAZ07BPPQlf2ZkRZPUKB9Rm6Mtyg5WcUzH+9l0YYDdAoN4q4JfZkzPpEIL/ot3Uq/jWUWneQvq/bz7uZ8QoICmDUukfsuSyayo/f8JTHG/LvdB8v4/UcZrNhdRJeOwdw1oS8zxyYQ2cHzf66t9NuAqrIuq5QXvsjikz1FhAYFMHNsAvdc2pfoiDCn4xljWsm2vGM8u2Ivn2UUEx4SyC2j47h9fJJHj++30m9FR8ureXdLAW9tPMDewyfpFh7CbWMTuG1cAj1sZStjfNaOguO8uDqbv28rpE6VS/tHMW10PBMHRRPsYZdwrfTPU2VNHZ/uKeLv2wr5ZHcR1XX1DI/rwoy0OKaOiLHpE4zxI4eOV/LG+lwWp+dxuKyKHp1CuW5Yb749vA+j4rt4xHBPK/0WOHaqmpUZxazYfZjP9hRRXl1Hj04hXDesD7eOjmNQb1vcxBh/VltXz6q9xSxOz+OzjGKqa+uJ6dKBq4b0ZOLAnqQldSMkyJnfAKz03VBVW8eWA8dYk1nCl/uPsDXvGHX1So9OoUwaFM23h/dhTFI3G4ljjPmGssoaPt55mA++OsiXmSVU1dYTERrE2H7dGd+vO+OTe5Ac3andfguw0m9CVck/WsGOguNsyTvG5tyjbC84TnVtPQECF8R2YUJyDyYOimZ4bBcCApz/dc0Y4x1OVdfyZeYRPt1zmNWZJeSVVgDQtWMwo+K7MiqhK8NjuzCkT+c2m0q9VUtfRCYDfwACgRdU9TdNXg8FFgAXAkeAW1U1x/Xaj4E7gDrgAVVdfrY/63xLX1U5XFZFdkk5mcUn2Xf4BHsPn2BXYRlllQ3rZoYEBjA0pjMXJnRldGI3xvTt7hVDsowx3iGv9BRr9x8hPbeUTblH2V/8rxW8Yrp0YFDvCFJ6RtC/Zyf6RXUisUf4ed+5727pNzv3jmuN23nAlTQsgL5RRJaq6q5Gu90BHFXVZBGZBvwWuFVEBtOwpu4QoA+wQkT6q2qrL1dfVFbJrJc2kHvkFBU1//r2nUKDSOnZieuG92FIn84M7RPJgF4R9kGsMabNxHXrSFy3jtwyOg5o+LxwR0EZOwuPs6OwjIxDZazaW0xN3b9OuruFhzA+uQfPTR/ZptncmXAtDchU1SwAEVkETAUal/5U4Oeux+8Af5KGC1lTgUWqWgVku9bQTQPWtk78f+nSMYTYrh0Yn9yDxB7hJHbvSHJ0J3p1DvOIT9aNMf6rS8cQLk7pwcUpPf65raaunpyScrJKysk9Uk52ySm6hbf9FQd3Sj8GaLzWWD4w5kz7qGqtiBwHuru2r2tybEyL055FSFAAL8we3Rbf2hhjWl1wYAApPRsu87Qnd4alnO40uekHAWfax51jEZG7RSRdRNKLi4vdiGSMMaYl3Cn9fCCu0fNYoPBM+4hIEBAJlLp5LKo6X1VTVTU1KsrmnTfGmLbiTulvBFJEJElEQmj4YHZpk32WArNdj28GPtWGYUFLgWkiEioiSUAKsKF1ohtjjDlXzV7Td12jnwssp2HI5kuqulNEngDSVXUp8CLwmuuD2lIa/mHAtd9iGj70rQXua4uRO8YYY9zjNzdnGWOML3N3nL7NL2CMMX7ESt8YY/yIlb4xxvgRj7umLyLFQO55fIseQEkrxXGSr7wPsPfiqXzlvfjK+4Dzey8JqtrsmHePK/3zJSLp7nyY4el85X2AvRdP5SvvxVfeB7TPe7HLO8YY40es9I0xxo/4YunPdzpAK/GV9wH2XjyVr7wXX3kf0A7vxeeu6RtjjDkzXzzTN8YYcwY+V/oi8ksR2S4iW0XkIxHp43SmlhKRp0Vkj+v9/FVEujidqaVE5DsislNE6kXE60ZaiMhkEckQkUwRedTpPOdDRF4SkSIR2eF0lvMhInEi8pmI7Hb93XrQ6UwtJSJhIrJBRLa53ssv2uzP8rXLOyLSWVXLXI8fAAar6r0Ox2oREbmKhhlLa0XktwCq+ojDsVpERAYB9cDzwMOq6jUTLLmWDN1LoyVDgelNlgz1GiJyCXASWKCqQ53O01Ii0hvoraqbRSQC2ARc743/X1wrDYar6kkRCQZWAw+q6rpmDj1nPnem/3Xhu4RzmkVbvIWqfqSqta6n62hYj8ArqepuVc1wOkcL/XPJUFWtBr5eMtQrqernNMyG69VU9aCqbnY9PgHspo1W5mtr2uCk62mw66tNusvnSh9ARH4lInnAd4HHnM7TSm4HPnQ6hJ863ZKhXlkuvkpEEoGRwHpnk7SciASKyFagCPhYVdvkvXhl6YvIChHZcZqvqQCq+hNVjQPeAOY6m/bsmnsvrn1+QsN6BG84l7R57rwXL+XWsp/GGSLSCVgC/LDJb/peRVXrVHUEDb/Rp4lIm1x6c2dhdI+jqpPc3HUh8AHweBvGOS/NvRcRmQ1cB0xUD/8A5hz+v3gbt5b9NO3Pdf17CfCGqr7rdJ7WoKrHRGQlMBlo9Q/bvfJM/2xEJKXR0ynAHqeynC8RmQw8AkxR1VNO5/Fj7iwZatqZ68PPF4HdqvqM03nOh4hEfT06T0Q6AJNoo+7yxdE7S4ABNIwUyQXuVdUCZ1O1jGv5yVDgiGvTOi8eiXQD8BwQBRwDtqrq1c6mcp+IfAt4ln8tGforhyO1mIi8CVxGw4yOh4HHVfVFR0O1gIhcDHwBfEXDzzvAf6nqMudStYyIDANepeHvVwCwWFWfaJM/y9dK3xhjzJn53OUdY4wxZ2alb4wxfsRK3xhj/IiVvjHG+BErfWOM8SNW+sYY40es9I0xxo9Y6RtjjB/5/+DyTToHTL9MAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x10c6546d8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "\n",
    "import matplotlib\n",
    "import math\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.mlab as mlab\n",
    "import numpy as np\n",
    "\n",
    "mu = 0\n",
    "variance = 1\n",
    "sigma = math.sqrt(variance)\n",
    "x = np.linspace(mu-3*variance,mu+3*variance, 100)\n",
    "_ = plt.plot(x,mlab.normpdf(x, mu, sigma))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Modal Interface: Edit vs. Command Mode\n",
    "\n",
    "-  The Notebook implements a modal interface similar to some text editors such as <code>vim</code>."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Edit Mode\n",
    "\n",
    "-  Use the **edit mode** to write code (the selected cell has a green border, and a pen icon appears at the top right of the interface). \n",
    "\n",
    "-  Click inside a cell or press <code>Enter</code> to enable the edit mode for this cell (you need to double-click with Markdown cells)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Command Mode\n",
    "\n",
    "-  Use the **command mode** to operate on cells (the selected cell has a light-blue border, and there is no pen icon).\n",
    "    \n",
    "-  Click outside the text area of a cell to enable the command mode (or press the <code>**Esc**</code> key).\n",
    "\n",
    "-  Type <tt>**H**</tt> (when in command mode) to show the list of available keyboard shortcuts."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Keyboard Shortcuts (available in *both* modes)\n",
    "\n",
    "-  Here are a few keyboard shortcuts that are always available when a cell is selected:\n",
    "    -  <code>**Ctrl + Enter**</code>: run the cell\n",
    "    -  <code>**Shift + Enter**</code>: run the cell and select the cell below\n",
    "    -  <code>**Alt + Enter**</code>: run the cell and insert a new cell below\n",
    "    -  <code>**Ctrl + S**</code> (Windows/Linux) or <code>**Cmd + S**</code> (Mac): save the notebook"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Keyboard Shortcuts (available in the *edit* mode)\n",
    "\n",
    "-  In the edit mode, you can type code as usual, and you have access to the following keyboard shortcuts:\n",
    "    -  <code>**Esc**</code>: switch to command mode\n",
    "    -  <code>**Ctrl + Shift + -**</code>: split the cell"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Keyboard Shortcuts (available in the *command* mode)\n",
    "\n",
    "-  In the command mode, keystrokes are bound to cell operations. Don't write code in command mode or unexpected things will happen! For example, typing <code>**DD**</code> in command mode will delete the selected cell! Here are some keyboard shortcuts available in command mode:\n",
    "    -  <code>**Enter**</code>: switch to edit mode\n",
    "    -  <code>**Up**</code> or <code>**K**</code>: select the previous cell\n",
    "    -  <code>**Down**</code> or <code>**J**</code>: select the next cell\n",
    "    -  <code>**Y**</code>/<code>**M**</code>: change the cell type to Code cell/Markdown cell\n",
    "    -  <code>**A**</code>/<code>**B**</code>: insert a new cell above/below the current cell\n",
    "    -  <code>**X**</code>/<code>**C**</code>/<code>**V**</code>: cut/copy/paste the current cell\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Keyboard Shortcuts (available in the *command* mode)\n",
    "\n",
    "-  (Continue):\n",
    "    -  <code>**DD**</code>: delete the current cell\n",
    "    -  <code>**Z**</code>: undo the last delete operation\n",
    "    -  <code>**Shift + M**</code>: merge multiple cells into a single one\n",
    "    -  <code>**H**</code>: display the help menu with the list of keyboard shortcuts\n",
    "    \n",
    "-  Remember that some keyboard shortcuts may be different on different platforms (Windows/Linux and Mac).\n",
    "\n",
    "-  Please, have a look at [28 Jupyter Notebook tips, tricks and shortcuts](https://www.dataquest.io/blog/jupyter-notebook-tips-tricks-shortcuts/) and [Jupyter (IPython) notebooks features](http://arogozhnikov.github.io/2016/09/10/jupyter-features.html) for any further details."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Jupyter Notebook (Advanced)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Jupyter and <code>conda</code> for R\n",
    "\n",
    "-  We already said that Jupyter began with Python but now has kernels for 50 different languages, including R, which is widely used by statisticians.\n",
    "\n",
    "-  [IRKernel](http://irkernel.github.io/) is the native R kernel for Jupyter.\n",
    "\n",
    "-  Therefore, those who are more familiar with R than Python still can benefit from Jupyter."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Setup Jupyter for R: Get IRKernel\n",
    "\n",
    "-  The first step to do is to use <code>conda</code> package manager to download \"[R Essentials](http://anaconda.org/r/r-essentials)\" bundle.\n",
    "\n",
    "-  This bundle contains IRKernel and over 80 of the most widely-used R packages for data science, including <code>dplyr</code>, <code>shiny</code>, <code>ggplot2</code>, <code>tidyr</code>, <code>caret</code>, and <code>nnet</code>."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Setup Jupyter for R: Install <code>r-essentials</code>\n",
    "\n",
    "-  Provided that <code>conda</code> is already available on your system, \"R Essentials\" can be installed in the current environment by issuing the following shell command:\n",
    "\n",
    "```bash\n",
    "> conda install -c r r-essentials\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Setup Jupyter for R: Install <code>r-essentials</code> on a dedicated environment\n",
    "\n",
    "-  Alternatively, if you want to create a dedicated environment just for R (e.g., called <code>R-env</code>), you can type as follows:\n",
    "\n",
    "```bash\n",
    "> conda create -n R-env -c r r-essentials\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Setup Jupyter for R: Install <code>r-essentials</code> on a dedicated environment \n",
    "\n",
    "-  This will require you to **activate** that environment in order for Jupyter Notebook to use it with the following command:\n",
    "\n",
    "```bash\n",
    "> source activate R-env\n",
    "```\n",
    "\n",
    "-  Then, you can start Jupyter Notebook as usual:\n",
    "\n",
    "```bash\n",
    "> jupyter notebook\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Share Jupyter Notebooks\n",
    "\n",
    "-  Remember that notebooks are just JSON documents that contain text, source code, rich media output, and metadata. Each segment of the document is stored in a cell.\n",
    "\n",
    "-  Ideally, you don't want to go around and share your notebooks with others as JSON files."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Share Jupyter Notebooks\n",
    "\n",
    "-  Under the *File* menu, Jupyter gives you the option to download your notebook as a Notebook (<code>.ipynb</code>), Python script (<code>.py</code>), HTML (<code>.html</code>), Markdown (<code>.md</code>), reStructuredText (<code>.rst</code>), LaTeX (<code>.tex</code>) or PDF (<code>.pdf</code>) file.\n",
    "\n",
    "-  Alternatively, you can use the <code>nbconvert</code> command to convert your notebook document file to another static format."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Converting Jupyter Notebook to Slides\n",
    "\n",
    "-  Jupyter can convert a notebook into an online slide deck for talks and tutorials (like this one!).\n",
    "\n",
    "-  To convert a notebook into a [reveal.js](http://lab.hakim.se/reveal-js/#/) presentation, go to the *View* menu and set *Cell Toolbar* to *Slideshow*.\n",
    "\n",
    "- Organize the cells of your notebook into *slides* and *subslides*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Converting Jupyter Notebook to Slides\n",
    "\n",
    "-  Convert it to the slide format using <code>nbconvert</code> as follows:\n",
    "\n",
    "```bash\n",
    "> jupyter nbconvert {NOTEBOOK_NAME}.ipynb --to slides --post serve\n",
    "```\n",
    "\n",
    "-  This will generate a <code>{NOTEBOOK_NAME}.slides.html</code> file in the same directory of your notebook file\n",
    "\n",
    "-  You can open it on a new tab of your system default browser at <code>http://<span></span>localhost:8888/{NOTEBOOK_NAME}.slides.html#/</code>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Converting Jupyter Notebook to Slides (alternative way)\n",
    "\n",
    "-  Install <code>RISE</code> plugin as a Jupyter Notebook extension as follows:\n",
    "\n",
    "```bash\n",
    "> conda install -c damianavila82 rise\n",
    "```\n",
    "\n",
    "-  Other possible ways of installation can be found [here](https://github.com/damianavila/RISE).\n",
    "\n",
    "-  This deck has been generated with <code>RISE</code>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'height': 768,\n",
       " 'scroll': True,\n",
       " 'start_slideshow_at': 'selected',\n",
       " 'theme': 'sky',\n",
       " 'transition': 'zoom',\n",
       " 'width': 1280}"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# The following piece of code will generate a JSON configuration (livereveal.json) file \n",
    "# under your Jupyter configuration path (e.g., /usr/local/anaconda3/etc/jupyter/nbconfig)\n",
    "from traitlets.config.manager import BaseJSONConfigManager\n",
    "path = \"path/to/your/jupyter/nbconfig\" # e.g., \"/usr/local/anaconda3/etc/jupyter/nbconfig\"\n",
    "cm = BaseJSONConfigManager(config_dir=path)\n",
    "cm.update('livereveal', {\n",
    "              'theme': 'sky', # change the default slide's background theme\n",
    "              'transition': 'zoom', # zooming when transitioning from one slide to the other\n",
    "              'start_slideshow_at': 'selected', # start with the selected cell of the notebook (instead of the first one)\n",
    "              'width': 1280, # slide's width\n",
    "              'height': 768, # slide's height\n",
    "              'scroll': True # vertical scroll (default is False)\n",
    "})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Printing Jupyter Notebook\n",
    "\n",
    "At least, there are 3 ways to print out your notebook and each of them needs to transform the original notebook file (<code>{NOTEBOOK_NAME}.ipynb</code>) into a <code>{NOTEBOOK_NAME}.pdf</code> file."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Method 1: <code>LaTeX</code>\n",
    "\n",
    "-  Use the *File --> Download as --> PDF via LaTeX (.pdf)*\n",
    "\n",
    "-  This will (attempt to) produce a PDF file which mimics the original notebook layout by taking advantage of the <code>pdflatex</code> tool.\n",
    "\n",
    "-  You might get some errors/unexpected behavior due to LaTeX issues on any of the cells of your notebook."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Method 2: <code>nbconvert</code> to HTML\n",
    "\n",
    "An alternative (and possibly better) solution could be the following:\n",
    "-  Transform your notebook into a \"static\" HTML file using <code>nbconvert</code>:\n",
    "```bash\n",
    "> jupyter nbconvert {NOTEBOOK_NAME}.ipynb --to html\n",
    "```\n",
    "-  This will generate a <code>{NOTEBOOK_NAME}.html</code> file in the same directory of your notebook file.\n",
    "\n",
    "-  Finally, you can open this HTML file with your favourite web browser and use the \"Print PDF\" dialog to save it as a pdf file."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Method 3: <code>nbconvert</code> to slides\n",
    "\n",
    "If you have already transformed your notebook to slides using <code>nbconvert</code> and you want to get a pdf-printable version of them here is one possible trick:\n",
    "\n",
    "-  Replace the original address<br/>\n",
    "    <code>http://<span></span>localhost:8888/{NOTEBOOK_NAME}.slides.html<strong style=\"color:red\">#/</strong></code><br/>\n",
    "    with the following<br/>\n",
    "    <code>http://<span></span>localhost:8888/{NOTEBOOK_NAME}.slides.html<strong style=\"color:green\">?print-pdf</strong></code><br/>\n",
    "    \n",
    "Note however that due to some issues with <code>reveal.js</code> this might lead to sloppy results (e.g., text overlapping, wrong page breaks, etc.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Method 4: DeckTape + <code>RISE</code> slides\n",
    "\n",
    "-  Instead, a much better result is given by creating slideshow with <code>RISE</code> and use [DeckTape](https://github.com/astefanutti/decktape) to transform slides into pdf.\n",
    "\n",
    "-  First of all, install RISE and DeckTape as follows:\n",
    "\n",
    "```bash\n",
    "> conda install -c damianavila82 rise # Install RISE\n",
    "> npm install -g decktape # Install DeckTape\n",
    "> npm update -g decktape # Update DeckTape\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Method 4: DeckTape + <code>RISE</code> slides (conversion)\n",
    "\n",
    "-  Assuming you have launched your notebook at <code>http://<span></span>localhost:8888/{NOTEBOOK_NAME}.ipynb</code> and let <code>{TOKEN}</code> be the token associated with your notebook then run the following command:\n",
    "\n",
    "```bash\n",
    "> decktape rise http://localhost:8888/{NOTEBOOK_NAME}.ipynb?token={TOKEN} \\\n",
    "--size 1920x1080 path/to/outputfile.pdf\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Jupyter Notebooks for Data Science Teams: Best Practices\n",
    "\n",
    "-  Jonathan Whitmore wrote in his [article](https://www.svds.com/tbt-jupyter-notebook-best-practices-data-science/?utm_source=kdnuggets&utm_medium=referral) some practices for using notebooks for data science, such as the following:\n",
    "    -  Use two types of notebooks for a data science project, a **lab** notebook and a **deliverable** notebook; individuals control the lab notebook, whilst the whole team manage the deliverable.\n",
    "    -  Use some type of versioning control (e.g., <code>GitHub</code>). Don't forget to commit also the HTML file if your version control system lacks rendering capabilities.\n",
    "    -  Use explicit rules on the naming of your documents."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Learn From The Best Notebooks (not exhaustive list!)\n",
    "\n",
    "-  Notebooks are also used to complement books, such as the *Python Data Science Handbook*. You can find the notebooks [here](https://github.com/jakevdp/PythonDataScienceHandbook).\n",
    "\n",
    "-  A report on a [Kaggle](https://www.kaggle.com/) competition is written down in [this blog](http://danielfrg.com/blog/2013/03/07/kaggle-bulldozers-basic-cleaning/), generated from a notebook.\n",
    "\n",
    "-  This [matplotlib tutorial](http://nbviewer.jupyter.org/github/jrjohansson/scientific-python-lectures/blob/master/Lecture-4-Matplotlib.ipynb) is a great example of how well a notebook can serve as a means of teaching other people topics such as scientific Python.\n",
    "\n",
    "-  Lastly, make sure to also check out [The Importance of Preprocessing in Data Science and the Machine Learning Pipeline](https://www.datacamp.com/community/tutorials/the-importance-of-preprocessing-in-data-science-and-the-machine-learning-pipeline-i-centering-scaling-and-k-nearest-neighbours/) tutorial series that was generated from a notebook."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# By the end of Week 1\n",
    "\n",
    "-  Install the full Anaconda distribution on your own system, using the steps described before.\n",
    "\n",
    "-  Familiarize with the Python shell interpreter (i.e., execute <code>**python**</code> from the command line).\n",
    "\n",
    "-  Familiarize with Jupyter Notebook (i.e., execute <code>**jupyter notebook**</code>, play with code/markdown cells, edit/command mode, etc.)"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}