part_1.introducing_jupyter.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Part 1: Introducing the Jupyter Notebook"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What is the Jupyter Notebook?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Jupyter Notebook is an interactive computing environment that enables users to author notebook documents that include:\n",
    "\n",
    "* Live code\n",
    "* Interactive widgets\n",
    "* Plots\n",
    "* Narrative text\n",
    "* Equations\n",
    "* Images\n",
    "* Video\n",
    "\n",
    "These documents provide a complete and self-contained record of a computation that can be converted to various formats and shared with others using email, Dropbox, version control systems (like git/GitHub) or nbviewer.jupyter.org."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Components\n",
    "The Jupyter Notebook combines three components:\n",
    "\n",
    "* **The notebook web application**: An interactive web application for writing and running code interactively and authoring notebook documents.\n",
    "* **Kernels**: Separate processes started by the notebook web application that runs users' code in a given language and returns output back to the notebook web application. The kernel also handles things like computations for interactive widgets, tab completion and introspection.\n",
    "* **Notebook documents**: Self-contained documents that contain a representation of all content visible in the notebook web application, including inputs and outputs of the computations, narrative text, equations, images, and rich media representations of objects. Each notebook document has its own kernel.\n",
    "\n",
    "This enables the user to both **edit** and **run** code in the browser."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Kernels\n",
    "Through Jupyter's kernel and messaging architecture, the Notebook allows code to be run in a range of different programming languages. For each notebook document that a user opens, the web application starts a kernel that runs the code for that notebook. Each kernel is capable of running code in a single programming language and there are kernels available in the following languages:\n",
    "\n",
    "* Python (https://github.com/ipython/ipython)\n",
    "* Julia (https://github.com/JuliaLang/IJulia.jl)\n",
    "* R (https://github.com/takluyver/IRkernel)\n",
    "* Ruby (https://github.com/minrk/iruby)\n",
    "* Haskell (https://github.com/gibiansky/IHaskell)\n",
    "* Scala (https://github.com/Bridgewater/scala-notebook)\n",
    "* node.js (https://gist.github.com/Carreau/4279371)\n",
    "* Go (https://github.com/takluyver/igo)\n",
    "\n",
    "The default kernel runs Python code. The notebook provides a simple way for users to pick which of these kernels is used for a given notebook."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Notebook cells"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A Jupyter notebook is made up of consecutive cells. There are two basic types of cells:\n",
    "* Markdown cells\n",
    "* Code cells"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can turn a cell into a markdown cell by pressing `m` when it is selected (but the cursor is **not** inside it). To turn it to a code cell use `y`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### More comands:\n",
    "* 'Escape' outside of a cell using `Esc`.\n",
    "* Add a cell above the current cell using `a`.\n",
    "* Add a cell above the current cell using `b`.\n",
    "* Copy the current cell using `c`.\n",
    "* Delete the current cell using `dd`.\n",
    "* Edit the current cell using `Enter`.\n",
    "* Execute a cell using `shift`+`Enter`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Markdown Cells\n",
    "\n",
    "This cell is a markdown cell. This means you can use markdown to write *italic text* by surrounding you text with *asterisks* or _underscores_.\n",
    "Strong emphasis, aka bold, with **asterisks** or __underscores__.\n",
    "Combined emphasis with **asterisks and _underscores_**.\n",
    "Strikethrough uses two tildes. ~~Scratch this.~~\n",
    "\n",
    "Here be headers:\n",
    "# H1\n",
    "## H2\n",
    "### etc...\n",
    "\n",
    "You can create bulleted lists using\n",
    "* Asterisks\n",
    "- Or minuses\n",
    "+ Or pluses\n",
    "\n",
    "### Ordered lists\n",
    "1. First ordered list item\n",
    "2. Another item\n",
    "  * Unordered sub-list. \n",
    "1. Actual numbers don't matter, just that it's a number\n",
    "  1. Ordered sub-list.\n",
    "  \n",
    "   An un-numbered indented paragraph.\n",
    "4. And another item.\n",
    "\n",
    "[And of course add links](https://www.google.com)\n",
    "\n",
    "You can find a nice full markdown cheatsheet here: https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-warning\" role=\"alert\" style=\"margin: 10px\">\n",
    "<p>**NOTICE**</p>\n",
    "\n",
    "<p>HTML tags can also be used inside markdown cells.</p>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Code Cells"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# this is a code cell\n",
    "a = 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# a line containing only an object will print it\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# unless it ends with a semicolon\n",
    "a;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# you can also define functions\n",
    "def foo(a, b):\n",
    "    \"\"\"Foo documentation.\"\"\"\n",
    "    return a*5 + 2/b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25.25"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# and then use them!\n",
    "foo(5,8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 62.9 ms, sys: 20.5 ms, total: 83.4 ms\n",
      "Wall time: 84.7 ms\n"
     ]
    }
   ],
   "source": [
    "# you can also use IPython magic functions!\n",
    "%time numbers = [x for x in range(1000000)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100 loops, best of 3: 5.83 ms per loop\n"
     ]
    }
   ],
   "source": [
    "%timeit numbers = [x for x in range(100000)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is also easy to display plots inside a Jupyter notebook. We'll see this later."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "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.5.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}