lectures/0-IntroductionNotebook.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Practical Introduction to Jupyter Notebooks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Skills to take away**\n",
    ">\n",
    "> - **Basic**: Create a new notebook, create a cell, choose cell type, write/execute code cells, write simple text cells.\n",
    "> - **Medium**: Use Python help for modules and functions, basic formatting of text in Markdown.\n",
    "> - **Expert**: Advanced formatting (table, links, code, quotation, equations with LaTeX, ...)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What is a notebook"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A notebook is an environment that combines code editing/execution and text editing (for documentation, annotation, etc.) with nice formatting options. The basic element of a notebook is a **cell**, which can be either a **code cell** or a **markdown cell** (as seen later in this chapter, *markdown* is a system to format text using raw text only). The creation of a new cell can be done using the \"plus\" button in the top menu, and the type of the cell (code or markdown) can be selected using the drop-down menu (there are actually more categories, but only code and markdown matter). There are a few keyboard shortcuts, all accessible using the small \"keyboard button\" in the top menu."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cells of code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Input and output\n",
    "\n",
    "There is an example of cell code just below, in which two variables ($x$ and $y$) are defined first, and then the sum is computed. To execute the code in this cell, you can press `SHIFT`+`ENTER` (or click on the \"run\" button in the top menu - less convenient)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Variable definition\n",
    "x = 2\n",
    "y = 3\n",
    "\n",
    "# Compute the sum\n",
    "x + y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The output of the last instruction is displayed after the mention `Out[CellNumber]`, while the input (i.e. the code itself) in the cell is after the mention `In[CellNumber]`. Note that if this code were executed as a normal Python file, there would be no output in the terminal; this behavior is specific to notebooks. If the last instruction doesn't produce any result, nothing is displayed at the execution of the cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we want to remove the output of the last instruction (which can be useful when doing plots), we can use a `;` at the end of the last instruction:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Variable definition\n",
    "x = 2\n",
    "y = 3\n",
    "\n",
    "# Compute the sum\n",
    "x + y;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If the code actually prints something (as it would do in a terminal), then the same thing will be printed in the notebook but the without the mention `Out[CellNumber]`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "# Variable definition\n",
    "x = 2\n",
    "y = 3\n",
    "\n",
    "# Compute and print the sum\n",
    "print(x + y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Be careful: Order of execution matters!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When working with notebooks, we usually have several cells, each containing its own piece of code. This can lead to counter-intuitive behavior and can cause mistakes if cells are not executed in the proper order. An example is given below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "## CODE 1\n",
    "x = 2\n",
    "y = 3\n",
    "print(x+y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13\n"
     ]
    }
   ],
   "source": [
    "## CODE 2\n",
    "x = 10\n",
    "print(x+y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20\n"
     ]
    }
   ],
   "source": [
    "## CODE 3\n",
    "y = 10\n",
    "print(x+y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The order of execution impacts the final results:\n",
    "- 1 -> 2 -> 3 leads to 5, 13, 20\n",
    "- 1 -> 3 -> 2 leads to 5, 20, 12\n",
    "\n",
    "This, again, is specific to notebooks: the value of a variable in memory is used at the time when a cell is executed. In a normal Python file, every instruction is executed from A to Z when the command `python myCode.py` is launched in a terminal."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A realistic example with several code cells\n",
    "\n",
    "Usually, we can use the cell structure to organize the code. The following example shows a first cell containing initialization of some variables, a second cell with the main function defined, and a third cell with code using both the initialized variables and the function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "n1 = 10\n",
    "n2 = 50\n",
    "n3 = 99"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def SumUpToN(n):\n",
    "    '''\n",
    "    This function returns the sum of the n first integers:\n",
    "       sum = 1 + 2 + ... + n\n",
    "    '''\n",
    "    \n",
    "    # Initisalisation\n",
    "    s = 0\n",
    "    \n",
    "    # Loop over from to n\n",
    "    for i in range(n+1):\n",
    "         s = s + i\n",
    "            \n",
    "    # Return the result\n",
    "    return s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "n = 10 --> SUM = 55\n",
      "n = 50 --> SUM = 1275\n",
      "n = 99 --> SUM = 4950\n"
     ]
    }
   ],
   "source": [
    "for n in [n1, n2, n3]:\n",
    "    print('n = {} --> SUM = {}'.format(n, SumUpToN(n)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example with plots\n",
    "\n",
    "Quite often, creating plots is a valuable approach to demonstrate a point or gain intuition about data. Jupyter notebooks allow you to display plots that are produced by code, as shown in the example below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Import Python plotting tool\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Define its behavior in the notebook.\n",
    "# Note: this command needs to be run once per notebook, not per cell.\n",
    "%matplotlib inline\n",
    "\n",
    "# Define Xs = [0, 1, ..., 50].\n",
    "Xs = range(50)\n",
    "\n",
    "# Define Ys = [SumUpToN(0), SumUpToN(1), ..., SumUpToN(50)].\n",
    "Ys = [SumUpToN(x) for x in Xs]\n",
    "\n",
    "# Plot Ys vs Xs.\n",
    "plt.plot(Xs, Ys)\n",
    "\n",
    "# Add a label to the x-axis.\n",
    "# Note the \";\" to avoid having the line printed (try without to check).\n",
    "plt.xlabel('N')\n",
    "plt.ylabel('Sum of integers up to N')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### How to use Python documentation\n",
    "\n",
    "Python libraries come with documentation, both at the package level and at the function level (a package is a group of defined functions; NumPy is a package). It is possible to access the documentation while coding directly in the notebook. The example shows how to print the help of a given function from NumPy (used to generate random numbers between 0 and 1)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function rand:\n",
      "\n",
      "rand(...) method of mtrand.RandomState instance\n",
      "    rand(d0, d1, ..., dn)\n",
      "    \n",
      "    Random values in a given shape.\n",
      "    \n",
      "    Create an array of the given shape and populate it with\n",
      "    random samples from a uniform distribution\n",
      "    over ``[0, 1)``.\n",
      "    \n",
      "    Parameters\n",
      "    ----------\n",
      "    d0, d1, ..., dn : int, optional\n",
      "        The dimensions of the returned array, should all be positive.\n",
      "        If no argument is given a single Python float is returned.\n",
      "    \n",
      "    Returns\n",
      "    -------\n",
      "    out : ndarray, shape ``(d0, d1, ..., dn)``\n",
      "        Random values.\n",
      "    \n",
      "    See Also\n",
      "    --------\n",
      "    random\n",
      "    \n",
      "    Notes\n",
      "    -----\n",
      "    This is a convenience function. If you want an interface that\n",
      "    takes a shape-tuple as the first argument, refer to\n",
      "    np.random.random_sample .\n",
      "    \n",
      "    Examples\n",
      "    --------\n",
      "    >>> np.random.rand(3,2)\n",
      "    array([[ 0.14022471,  0.96360618],  #random\n",
      "           [ 0.37601032,  0.25528411],  #random\n",
      "           [ 0.49313049,  0.94909878]]) #random\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "help(np.random.rand)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is also possible to write documentation for the functions that we define in the notebook via the **docstring** (text at the beginning of the function enclosed in `'''`). This documentation is also accessible on-the-fly thanks to the keyboard shortcut `SHIFT`+`TAB` when the cursor is after the first parenthesis, or it can be printed using `help(SumUpToN)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function SumUpToN in module __main__:\n",
      "\n",
      "SumUpToN(n)\n",
      "    This function returns the sum of the n first integers:\n",
      "       sum = 1 + 2 + ... + n\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(SumUpToN)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cells of text\n",
    "\n",
    "Cells of text are used to document the notebook, for example, to explain the goal of the next code cell or to describe the context of the analysis done in the entire notebook. Notebooks support several syntax options for formatting text, and only the main features will be presented here. You can use Markdown for most formatting styles and basic $\\LaTeX$ for mathematical symbols and equations. Note that HTML syntax is also supported."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The Markdown syntax\n",
    "\n",
    "- `*italic text*` $\\to$ *italic text*\n",
    "- `**bold text**` $\\to$ **bold text**\n",
    "- ``` `line of code` ``` $\\to$ `line of code`\n",
    "- `[link](url)` $\\to$ [link](url)\n",
    "- `![name](image.jpg)` $\\to$ include an image in the notebook\n",
    "- Table formatting:\n",
    "```\n",
    "| col1 | col2 |\n",
    "|------|------|\n",
    "|   y  |   n  |\n",
    "|   y  |   y  |\n",
    "|   n  |   n  |\n",
    "```\n",
    "\n",
    "renders as\n",
    "\n",
    "| col1 | col2 |\n",
    "|------|------|\n",
    "|   y  |   n  |\n",
    "|   y  |   y  |\n",
    "|   n  |   n  |\n",
    "\n",
    "- Headers are done using `#` symbols at the beginning of a cell:\n",
    "```\n",
    "# Title\n",
    "blabla\n",
    "## Subtitle\n",
    "blabla\n",
    "### Subsubtitle\n",
    "blabla\n",
    "```\n",
    "renders as"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "# Title\n",
    "Blabla\n",
    "\n",
    "## Subtitle\n",
    "Blabla\n",
    "\n",
    "### Subsubtitle\n",
    "Blabla\n",
    "\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- We can also put some code in a Markdown cell, but it will not be executed. This can be done with a code block, where the language can be specified too:\n",
    "\n",
    "<pre>    \n",
    "```python\n",
    "# Python code\n",
    "list = [0, 1, 2, 3]\n",
    "for i in list:\n",
    "    print(i)\n",
    "```\n",
    "</pre>\n",
    "\n",
    "\n",
    "renders as \n",
    "\n",
    "\n",
    "```python\n",
    "# Python code\n",
    "list = [0, 1, 2, 3]\n",
    "for i in list:\n",
    "    print(i)\n",
    "```\n",
    "\n",
    "- It is also possible to use quotation-like formatting:\n",
    "```\n",
    "> One day, one man said this would be a nice quotation.\n",
    ">\n",
    "> Romain M.\n",
    "```\n",
    "\n",
    "renders as\n",
    "\n",
    "> One day, one man said this would be a nice quotation.\n",
    ">\n",
    "> Romain M.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Typical use of LaTeX\n",
    "\n",
    "$\\LaTeX$ is a (very rich) language on its own to format text and it will not be touched here. The typical need for $\\LaTeX$ in notebooks is for mathematical symbols and equations. For example:\n",
    "```\n",
    "$$\n",
    "\\sum_{i=0}^{n} i^2 \\neq \\int^{\\infty}_{0} \\varphi \\times f(\\theta) \\times \\sin\\left(\\frac{\\pi x}{x+1}\\right) \\, \\mathrm{d}x\n",
    "$$\n",
    "```\n",
    "renders as\n",
    "\n",
    "$$\n",
    "\\sum_{i=0}^{n} i^2 \\neq \\int^{\\infty}_{0} \\varphi \\times f(\\theta) \\times \\sin\\left(\\frac{\\pi x}{x+1}\\right) \\, \\mathrm{d}x\n",
    "$$\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Typical use of HTML\n",
    "\n",
    "The same concept applies to HTML as well. HTML is a rich language on its own, along with CSS, and it will not be touched here. Just keep in mind that you can use HTML to add some cosmetic elements. For example:\n",
    "\n",
    "```html\n",
    "<div style=\"color:white;background:blue;width:50%;padding:10px;font-size:18px;text-align:center\">\n",
    "This is a block with a HTML + CSS style!\n",
    "</div>\n",
    "```\n",
    "renders as\n",
    "\n",
    "<div style=\"color:white;background:blue;width:50%;padding:10px;font-size:18px;text-align:center\">\n",
    "This is a block with a HTML + CSS style!\n",
    "</div>"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}