Part 1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# A brief introduction to Jupyter Notebook\n",
    "\n",
    "We're going to use jupyter notebooks for this lesson. Jupyter is a rich tool, but we're going to focus on just enough to keep you moving forward learning about `pandas`. If you want to go deeper, be sure to check out the \"help\" menu, which has a link to this [Notebook Help](http://nbviewer.jupyter.org/github/ipython/ipython/blob/3.x/examples/Notebook/Index.ipynb) and a lot more. You can also check out the [Official Jupyter Documentation](http://jupyter.readthedocs.org/en/latest/)\n",
    "\n",
    "Each jupyter notebook is a series of cells. Each cell is either a _markdown_ cell (like this one, which can be converted to HTML) or a _code_ cell, like the next one, in which you can execute code.\n",
    "\n",
    "Let's see what that means. Put your cursor in the next cell and type the following command, and then type shift-return to execute the code.\n",
    "\n",
    "    print \"hello world\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello world\n"
     ]
    }
   ],
   "source": [
    "print \"hello world\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "Pretty simple, right? You can run any python code you want in one of these cells, as long as the libraries are installed. Try this:\n",
    "\n",
    "```\n",
    "from random import choice\n",
    "choices = ['chocolate', 'vanilla', 'spumoni', 'rocky road']\n",
    "for i in range(0,4):\n",
    "    print \"Choice {}: {}\".format(i,choice(choices))\n",
    "```\n",
    "\n",
    "Remember, after you type the code, you can run the cell with shift-enter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Choice 0: chocolate\n",
      "Choice 1: spumoni\n"
     ]
    }
   ],
   "source": [
    "from random import choice\n",
    "choices = ['chocolate', 'vanilla', 'spumoni', 'rocky road']\n",
    "for i in range(0,2):\n",
    "    print \"Choice {}: {}\".format(i,choice(choices))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "It's important to keep in mind that what happens in any given cell affects your entire notebook. So in the next cell, enter this code and then _shift-enter_\n",
    "\n",
    "    print i\n",
    "    print choices[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "spumoni\n"
     ]
    }
   ],
   "source": [
    "print i\n",
    "print choices[2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "Unless you have changed other things, you should have seen\n",
    "\n",
    "    3\n",
    "    spumoni\n",
    "\n",
    "even though those weren't present in that code cell\n",
    "\n",
    "One way this can be confusing is if you run the same command twice, and the first time changes things so that the second time you execute the command you get an error. To see that in action, execute\n",
    "\n",
    "```python\n",
    "choices.pop()\n",
    "```\n",
    "\n",
    "five consecutive times, and the last time, you'll get an `IndexError` because the array is empty."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "pop from empty list",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-9-820386935ae5>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mchoices\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpop\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m: pop from empty list"
     ]
    }
   ],
   "source": [
    "choices.pop()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "Another cool thing about the jupyter environment is that you can interact with the local filesystem in a pretty natural way, so you can use commands like `%ls` and `%cd` and `%mkdir`. These special `%` commands are called \"magics.\"\n",
    "\n",
    "To make you even more efficient, if the only thing in a cell is one of these commands, you can leave off the leading `%`, like this:\n",
    "\n",
    "    cd ~\n",
    "\n",
    "If you have multiple commands, or if you're mixing \"magic\" commands and python code, you must prefix the commands with `%`. \n",
    "\n",
    "If you want to know all of the special \"magic\" commands, you can use `%lsmagic`. Using `%magic` will pop open extensive documentation about these features. Browse it to get an idea of what's possible, but don't worry about knowing all of it.\n",
    "\n",
    "Try the sample commands below, and play around further if you want."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "%ls\n",
    "%lsmagic"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# A few tricks\n",
    "\n",
    "Since we're going to ask you to type a lot of code for yourself, you should take advantage of jupyter's tricks for productivity.\n",
    "\n",
    "* First, use tab-completion. If you type part of a python package, function or variable name and then press _tab_, jupyter will complete your thought. If there is more than one possible completion, it will give you a menu. \n",
    "* Did we mention how cool tab-completion is? It can also complete \n",
    "    * file names\n",
    "    * directories\n",
    "    * dictionary keys\n",
    "    * keyword argument keys for function calls\n",
    "    * package names you haven't imported yet\n",
    "* tab-completion can't totally read your mind, so in some cases you will need to run some code before it's ready to do all the completions, so that it knows the relevant options. You'll get the gist of it.\n",
    "* Use _shift-tab_ for help. If you type it at the end of a function, or after the opening parentheses, it will show you the documentation for the function. If you use _shift-tab_ three times in sequence, it opens the documentation in a separate pane.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# on with the show\n",
    "\n",
    "When you're done playing around with notebooks, [let's take a look at `pandas`](Part%202.ipynb)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}