jupyter_tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Jupyter tutorial\n",
    "\n",
    "Follow this tutorial in order. Some parts depend on previous parts being run."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "---\n",
    "# Part I: Cell Types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are three types of cells: code, markdown, and raw.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print \"This is a code cell. It has the 'In []' to the left. You can run code in it.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "### This is a markdown cell. \n",
    "\n",
    "*You can think of it like a **text** cell.*\n",
    "\n",
    "> You can use special characters (aka **markdown**) to create different text `effects` / sizes\n",
    "\n",
    "\n",
    "Try the following:\n",
    "1. Double click on this cell\n",
    "2. See how you can make different effects\n",
    "3. Try it yourself\n",
    "    - it's pretty swell!\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "This is a raw cell. It just has plain text. (zzz)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "You can switch between cell types by going to `Cell > Cell Type` in the menu above. Or you can use the following hotkeys:\n",
    "- m - switch to markdown\n",
    "- y - switch to code\n",
    "- r - switch to raw"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "---\n",
    "# Part II: The Kernel (this is important)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When you launch a notebook, a Python \"kernel\" will automatically be started for that notebook. You can think of this as just an instance of Python that's waiting for you to give it code to run.\n",
    "\n",
    "When code is running, you'll see the circle at the top right of the notebook will be filled in gray. If you hover over it, it'll say \"Kernel busy\". The kernel can only do one thing at a time, so you have to wait for it to finish before you can run another cell. However, you can still edit cells while you wait.\n",
    "\n",
    "Sometimes you may want to stop the kernel while it's busy. This is called \"interrupting\" the kernel. To do this, hit the button with the square symbol up in the toolbar.\n",
    "\n",
    "The code below creates what's called an \"endless loop\". It will keep running forever until you force it to stop. **Try running it and use the kernel interrupt button to stop it.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "while True:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All the variables you create in a given notebook are saved by the kernel until you either (1) restart the kernel, or (2) close the notebook. \n",
    "\n",
    "This means that when you create a variable in one cell, you can use that variable anywhere else in your notebook. Try this with the two cells below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "cat = \"Mittensworth\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print cat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes you might want to clear all the stuff that's being stored by the kernel and start fresh. To do this, go to `Kernel > Restart`. You can also choose to `Restart and clear all output`. This will additionall clear the output underneath each cell. However, both clear the stored variables, so it doesn't matter which you pick. (The latter will probably lead to less confusion, though.)\n",
    "\n",
    "**Try restarting the kernel.** Then run the code below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print cat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It should give you an error, because \"cat\" is no longer a variable known to the kernel. You would need to re-run the cell that defines the cat variable first for this to work.\n",
    "\n",
    "Note, restarting is different than interrupting. Interrupting doesn't cause you to lose your variables; restarting does."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "---\n",
    "# Part III: Other stuff with cells"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can do a lot of things with cells: \n",
    "- create them\n",
    "- delete them\n",
    "- move them\n",
    "- copy and paste them\n",
    "- merge and split them\n",
    "\n",
    "Explore the menus at the top and try it out.\n",
    "\n",
    "Sometimes you will write code that produces a lot of output. **You can collapse the output by clicking (or double clicking) to the left of the output.** Try it with the code below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "for i in range(100):\n",
    "    print i"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "---\n",
    "# Part IV: Hotkeys"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using Jupyter is a lot easier once you learn the hotkeys. Here are my favorites:\n",
    "\n",
    "- h - view all hotkeys\n",
    "- a - insert cell above selected cell\n",
    "- b - insert cell below selected cell\n",
    "- d,d (hit d twice) - delete selected cell\n",
    "- m / y - switch between markdown/code cells\n",
    "\n",
    "You can only use these hotkeys when you're not \"inside\" a cell. Just hit `Esc` or click somewhere outside the cells to get out."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "---\n",
    "# Part V: Autocompletion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One of my favorite features of Jupyter is autocompletion! \n",
    "\n",
    "If you start typing the name of a variable that you've already created and then hit `tab`, it will fill in the rest of the variable name.\n",
    "\n",
    "Try it below. **Put your cursor right after the incomplete variable name in the print statement (\"te\") and hit tab.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "temperature = 37\n",
    "\n",
    "print te"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If there is more than one variable name that matches, it will show you a list. Use your arrow keys to select the one you want. Try it below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "numBananas = 20\n",
    "numApples = 12\n",
    "numGrapes = 256\n",
    "\n",
    "print nu"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Autocompletion also works for file names on your computer! If you start typing a string that looks like a file name, Jupyter will try to autocomplete it for you. More on this later when we start doing file reading."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### !!!Warning!!! autocompletion of ( ), [ ], {}, \" \", ' '\n",
    "\n",
    "On the flip side, one of the most annoying features of Jupyter (in my opinion...) is that it autocompletes braces and quotes. Usually it's not an issue, but in certain circumstances it can be a big pain and cause your code to have unexpected bugs.\n",
    "\n",
    "The problem is that when you type a closing bracket (or quote) in front of an existing bracket (or quote), it does NOT insert a new bracket (quote). Instead, it jumps over the existing bracket.\n",
    "\n",
    "**In the example below, try typing a `)` immediately after the 3:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print (1 + (2 - 3) * 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you realize that this has happened, then it's not a big deal to correct (just type the closing bracket after). The problem is when you don't notice!"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [Root]",
   "language": "python",
   "name": "Python [Root]"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}