tutorial_1_jupyter_notebook.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to Jupyter notebooks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first thing we'll do, [discussed later](#Best-practices-for-code-cells), is import all the modules we'll need.  You should in general do this at the very beginning of each notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import numerical packages\n",
    "import numpy as np\n",
    "\n",
    "# Import pyplot for plotting\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Magic function to make matplotlib inline; other style specs must come AFTER\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this tutorial, you will learn the basics on how to use Jupyter notebooks.  Most of your homework will be submitted as Jupyter notebooks, so this is something you will need to master.  It will be useful for you to go over **Tutorial  2** to learn how to use $\\LaTeX$ to write mathematical notations and statements in your Jupyter notebooks. You should, of course, read [the official Jupyter documentation](http://jupyter-notebook.readthedocs.org/) as well."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Contents\n",
    "* [What is Jupyter](#What-is-Jupyter?)\n",
    "* [Launching a Jupyter notebook](#Launching-a-Jupyter-notebook)\n",
    "* [Cells](#Cells)\n",
    "* [Code cells](#Code-cells)\n",
    "    - [Display of graphics](#Display-of-graphics)\n",
    "    - [Proper formatting of cells](#Proper-formatting-of-cells)\n",
    "    - [Best practices for code cells](#Best-practices-for-code-cells)\n",
    "* [Markdown cells](#Markdown-cells)\n",
    "* [Styling your notebook](#Styling-your-notebook)\n",
    "* [Collaborating with Google Drive](#Collaborating-with-Google-Drive)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What is Jupyter?\n",
    "[Jupyter](http://jupyter.org) is a way to combine text (with math!) and code (which runs and can display graphic output!) in an easy-to-read document that renders in a web browser.  The notebook itself is stored as a text file in [JSON](http://json.org) format.  This text file is what you will email the course instructor when submitting your homework.\n",
    "\n",
    "It is language agnostic as its name suggests.  The name \"Jupyter\" is a combination of [Julia](http://julialang.org/) (a new language for scientific computing), [Python](http://python.org/) (which you know and love, or at least will when the course is over), and [R](https://www.r-project.org) (the dominant tool for statistical computation).  However, you currently can run over 40 different languages in a Jupyter notebook, not just Julia, Python, and R."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Launching a Jupyter notebook\n",
    "To launch a Jupyter notebook, you can use the Anaconda launcher and select \"Jupyter Notebook\" (or \"Jupyter Lab\"). A Jupyter notebook will then launch in your default web browser.\n",
    "\n",
    "When you launch  Jupyter Notebook, you will be presented with a menu of files in your current working directory to choose to edit.  You can also navigate around the files on your computer to find a file you wish to edit by clicking the \"Upload\" button in the upper right corner.  You can also click \"New\" in the upper right corner to get a new Jupyter notebook.  After selecting the file you wish to edit, it will appear in a new window in your browser, beautifully formatted and ready to edit. (\"Jupyter Lab\" is slightly different from \"Jupyter Notebook.) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cells\n",
    "A Jupyter notebook consists of **cells**.  The two main types of cells you will use are **code cells** and **markdown cells**, and we will go into their properties in depth momentarily.  First, an overview.\n",
    "\n",
    "A **code cell** contains actual code that you want to run.  You can specify a cell as a code cell using the pulldown menu in the toolbar in your Jupyter notebook.  Or, you can  hit `esc` and then `y` (denoted \"`esc, y`\") while a cell is selected to specify that it is a code cell.  \n",
    "\n",
    "If you want to execute the code in a code cell, hit \"`shift + enter`.\"  Note that code cells are executed in the order you execute them. If you did not explicitly execute a cell early in the document, its results are now known to the Python interpreter.\n",
    "\n",
    "**Markdown cells** contain text.  The text is written in **markdown**, a lightweight markup language.  You can read about its syntax [here](http://daringfireball.net/projects/markdown/syntax).  Note that you can also insert HTML into markdown cells, and this will be rendered properly.  As you are typing the contents of these cells, the results appear as text.  Hitting \"`shift + enter`\" renders the text in the formatting you specify.\n",
    "\n",
    "You can specify a cell as being a markdown cell in the Jupyter toolbar, or by hitting \"`esc, m`\" in the cell.  Again, you have to hit enter after using the quick keys to bring the cell into edit mode.\n",
    "\n",
    "In general, when you want to add a new cell, you can use the \"Insert\" pulldown menu from the Jupyter toolbar.  The shortcut to insert a cell below is \"`esc, b`\" and to insert a cell above is \"`esc, a`.\"  Alternatively, you  can execute a cell and automatically add a new one below it by hitting \"`alt + enter`.\" There is another shot cut, \"`ctrl+enter`\", which execute a cell but not add a new line below. In order to switch an existing code or markdown cell into editing mode, just double clik the cell to edit it.   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Code cells\n",
    "Below is an example of a code cell printing `hello, world.`  Notice that the output of the print statement appears in the same cell, though separate from the code block."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Say hello to the world.\n",
    "print('hello, world.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you evaluate a Python expression that returns a value, that value is displayed as output of the code cell.  This only happens, however, for the last line of the code cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Would show 9 if this were the last line, but it is not, so shows nothing\n",
    "4 + 5\n",
    "\n",
    "# I hope we see 11.\n",
    "5 + 6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note, however, if the last line does not return a value, such as if we assigned a variable, there is no visible output from the code cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Variable assignment, so no visible output.\n",
    "a = 5 + 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# However, now if we ask for a, its value will be displayed\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Output is asynchronous"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All output is displayed asynchronously as it is generated in the Kernel. If you execute the next cell, you will see the output one piece at a time, not all at the end."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import time, sys\n",
    "for i in range(8):\n",
    "    print(i)\n",
    "    time.sleep(0.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Large outputs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To better handle large outputs, the output area can be collapsed. Run the following cell and then single- or double- click on the active area to the left of the output:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "for i in range(50):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Beyond a certain point, output will scroll automatically:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for i in range(500):\n",
    "    print(2**i - 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Display of graphics\n",
    "When displaying graphics, you should have them **inline**, meaning that they are displayed directly in the Jupyter notebook and not in a separate window.  You can specify that, as I did at the top of this document, using the `%matplotlib inline` magic function.  Below is an example of graphics displayed inline."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Generate data to plot\n",
    "x = np.linspace(0, 2 * np.pi, 200)\n",
    "y = np.exp(np.sin(np.sin(x)))\n",
    "\n",
    "# Make plot\n",
    "plt.plot(x, y)\n",
    "plt.xlim((0, 2 * np.pi))\n",
    "plt.xlabel(r'$x$')\n",
    "plt.ylabel(r'$\\mathrm{e}^{\\sin{x}}$')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The plot is included inline with the styling we specified using Seaborn at the beginning of the document. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Markdown cells\n",
    "Markdown cells contain text.  The text is written in **markdown**, a lightweight markup language.  The list of syntactical constructions at [this link](http://daringfireball.net/projects/markdown/syntax) are pretty much all you need to know for standard markdown.  Note that you can also insert HTML into markdown cells, and this will be rendered properly.  As you are typing the contents of these cells, the results appear as text.  Hitting \"`shift + enter`\" renders the text in the formatting you specify.\n",
    "\n",
    "You can specify a cell as being a markdown cell in the Jupyter tool bar, or by hitting \"`esc, m`\" in the cell.  Again, you have to hit enter after using the quick keys to bring the cell into edit mode.\n",
    "\n",
    "In addition to HTML, some $\\LaTeX$ expressions may be inserted into markdown cells.  $\\LaTeX$ (pronounced \"lay-tech\") is a document markup language that uses the $\\TeX$ typesetting software.  It is particularly well-suited for beautiful typesetting of mathematical expressions.  In Jupyter notebooks, the $\\LaTeX$  mathematical input is rendered using software called MathJax.  This is run off of a remote server, so if you are not connected to the internet, your equations will not be rendered.  You will use $\\LaTeX$ extensively in preparation of your assignments.  There are plenty of resources on the internet for getting started with $\\LaTeX$, but you will only need a tiny subset of its functionality in your assignments, and **Tutorial 2**, plus cheat sheets you may find by Google (such as [this one](https://wch.github.io/latexsheet/latexsheet-a4.pdf)) are useful."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "TensorFlow-GPU",
   "language": "python",
   "name": "tf-gpu"
  },
  "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}