Week2/notebooks/intro2py.ipynb

{
 "metadata": {
  "name": "",
  "signature": "sha256:bd7e87576f170c3d751f994460f355fef9a6fbdbdb99f5ad726c2e18bd149ad8"
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "<DIV ALIGN=CENTER>\n",
      "\n",
      "# Introduction to the Python Programming Language\n",
      "## Professor Robert J. Brunner\n",
      "  \n",
      "</DIV>  \n",
      "-----\n",
      "-----"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Why Python\n",
      "\n",
      "[Python][1] is an open-source, high-level, general purpose programming\n",
      "language that was originally developed by [Guido van Rossum][gv]. [What\n",
      "this means][2] is that anyone can view (and optionally make\n",
      "contributions to) the actual language implementation, the language\n",
      "simplifies many tasks for the programmer, especially when compared to\n",
      "other programming languages like C or Java, and that Python programs can\n",
      "easily be developed to tackle a wide range of problems including network\n",
      "communication, scientific calculations, data processing and archiving\n",
      "tasks and graphical tool development. In addition, the syntax and form\n",
      "of the Python programming language is designed to allow Python programs\n",
      "to be quickly developed, simplifying development time and costs while\n",
      "also reducing maintenance costs since a well-written Python program is\n",
      "easy to comprehend.\n",
      "\n",
      "![Python logo](https://www.python.org/static/community_logos/python-logo-master-v3-TM.png)\n",
      "\n",
      "A large number of Python modules, which extend the base programming\n",
      "language, have been developed and are now widely used, simplifying the\n",
      "development of new Python programs. These modules can be broadly\n",
      "classified into three types. The first type are commonly used modules\n",
      "that are part of the official Python distribution, know as the [standard\n",
      "library][sl], such as the [`math`][i], [`os.path`][ii], [`pickle`][ip],\n",
      "[`sqlite3`][sql], [`bz2`][iii], or [`csv`][iv] modules. The second type\n",
      "are modules that are also commonly used, but not (yet) part of the\n",
      "official standard library. Relevant example modules in theis type are\n",
      "the [`numpy`][np], [`pandas`][pd], [`matplotlib`][mp], or [`scipy`][sp]\n",
      "modules. The last type of module are developed by communities for a\n",
      "special purpose that are currently less commonly used (but this may\n",
      "change in time). These include modules like the [`seaborn`][sb],\n",
      "[`bokeh`][bk], or [`pygresql`][pg]. Of course, any developer can write a\n",
      "Python module thus offering a wide array of possible add-on\n",
      "functionality. The availability of these extra modules, however, needs\n",
      "to be carefully balanced with the need of a developer is to minimize\n",
      "software dependencies to reduce development and maintenance issues.\n",
      "\n",
      "Python is maintained by the Python Software Foundation, and currently\n",
      "comes in [two versions][3]: Python 2 and Python 3, which is\n",
      "intentionally backwards incompatible. Sometime around the turn of the\n",
      "millenium, [Python developers][4] began to consider improvements to the\n",
      "Python language that might produce incompatibilities with the existing\n",
      "Python language. One such change, which has been introduced with Python 3,\n",
      "is that the Python programming language is now consistently object-oriented,\n",
      "now everything is an _object_. These changes were considered necessary\n",
      "to enable the language to continue to grow and develop. The development\n",
      "of this new version, originally entitled Python 3000 or Python 3K, now\n",
      "shortened to just Python 3, took a number of years as new ideas were\n",
      "carefully developed abd tested, and to provide sufficient time for the\n",
      "existing community to participate in the progression of the Python\n",
      "language. \n",
      "\n",
      "Now, nearly fifteen years later, Python 3 is an improved version of the\n",
      "original Python language and offers a number of [important advances][5].\n",
      "Thus, Python 2 is primarily used to maintain backwards compatibility\n",
      "with legacy Python codes that are too difficult or expensive to port to\n",
      "the newer version. Python 3 also uniformly  In this class, we will\n",
      "exclusively use Python 3 since it represents the future and all\n",
      "libraries we will use have already been successfully ported to the new\n",
      "version. As you browse different websites, IPython notebooks, or other\n",
      "resources, you should keep in mind this language split and be sure to\n",
      "focus primarily on Python 3 material in order to minimize confusion\n",
      "arising from these language differences.\n",
      "\n",
      "The following code block, when executed, displays what might be called the Python Zen.\n",
      "\n",
      "-----\n",
      "[gv]: https://www.python.org/~guido/\n",
      "[i]: https://docs.python.org/3/library/math.html\n",
      "[ii]: https://docs.python.org/3/library/os.path.html\n",
      "[iii]: https://docs.python.org/3/library/bz2.html\n",
      "[iv]: https://docs.python.org/3/library/csv.html\n",
      "[ip]: https://docs.python.org/3/library/pickle.html\n",
      "[sl]: https://docs.python.org/3/library/\n",
      "[sql]: https://docs.python.org/3/library/sqlite3.html\n",
      "[np]: http://www.numpy.org\n",
      "[mp]: http://matplotlib.org\n",
      "[pd]: http://pandas.pydata.org\n",
      "[sp]: http://www.scipy.org\n",
      "[sb]: http://web.stanford.edu/~mwaskom/software/seaborn/index.html\n",
      "[bk]: http://bokeh.pydata.org/en/latest/\n",
      "[pg]: http://www.pygresql.org\n",
      "[1]: https://www.python.org\n",
      "[2]: https://en.wikipedia.org/wiki/Python_(programming_language)\n",
      "[3]: https://wiki.python.org/moin/Python2orPython3\n",
      "[4]: https://wiki.python.org/moin/Python3000/FAQ\n",
      "[5]: https://docs.python.org/3.0/whatsnew/3.0.html"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import this"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "The Zen of Python, by Tim Peters\n",
        "\n",
        "Beautiful is better than ugly.\n",
        "Explicit is better than implicit.\n",
        "Simple is better than complex.\n",
        "Complex is better than complicated.\n",
        "Flat is better than nested.\n",
        "Sparse is better than dense.\n",
        "Readability counts.\n",
        "Special cases aren't special enough to break the rules.\n",
        "Although practicality beats purity.\n",
        "Errors should never pass silently.\n",
        "Unless explicitly silenced.\n",
        "In the face of ambiguity, refuse the temptation to guess.\n",
        "There should be one-- and preferably only one --obvious way to do it.\n",
        "Although that way may not be obvious at first unless you're Dutch.\n",
        "Now is better than never.\n",
        "Although never is often better than *right* now.\n",
        "If the implementation is hard to explain, it's a bad idea.\n",
        "If the implementation is easy to explain, it may be a good idea.\n",
        "Namespaces are one honking great idea -- let's do more of those!\n"
       ]
      }
     ],
     "prompt_number": 1
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "-----\n",
      "## Basic Concepts\n",
      "\n",
      "While Python is a relatively easy language to learn, there are a few\n",
      "basic concepts that need to be reviewed before we begin to discuss the\n",
      "Python programming language. A fundamental concept to remember is that\n",
      "good Python code should be easy to read. To help programmers adhere to\n",
      "this guideline, Python has the following guidelines:\n",
      "\n",
      "1. White space is important,\n",
      "2. Names should be descriptive,\n",
      "3. Code blocks are indented four spaces (not hard tabs) and follow a colon,\n",
      "4. Lines of code should be limited to less than 80 characters, and\n",
      "5. Good code should be throughly documented both with comments and descriptive documentation strings.\n",
      "\n",
      "If lines need to be longer than 80 characters, the recommend practice is\n",
      "to use parentheses to group operations and to use suitable indentation\n",
      "to maintain readability. In the event this is insufficient, a line\n",
      "continuation character, `/`, can be used to allow code to extend over as\n",
      "many line as necessary.\n",
      "\n",
      "\n",
      "Python supports\n",
      "[REPL](https://en.wikipedia.org/wiki/Read\u2013eval\u2013print_loop), which is an\n",
      "abbreviation for Read-Eval-Print-Loop, allowing a developer to write,\n",
      "run, and test code iteratively, which aids in quickly developing new\n",
      "programs. Python also is is Unicode complaint, so character coding can\n",
      "be specified (for example, UTF-8) at the start of a program (or in string\n",
      "literals) allowing a wider range of characters to be used to write\n",
      "descriptive text.\n",
      "\n",
      "### Python Identifiers\n",
      "\n",
      "A Python identifier is a name that is composed of a sequence of letters,\n",
      "numbers, and underscore characters that must adhere to the following\n",
      "rules:\n",
      "\n",
      "1. The first character must be a letter or an underscore character.\n",
      "2. Variable and Function names traditionally start with a lowercase letter.\n",
      "3. Classes traditionally start with an upper-case letter.\n",
      "4. The identifier can not be one of the reserved Python keywords, listed in the code block below.\n",
      "\n",
      "While not explicitly prevented, it is also recommended to avoid names of\n",
      "objects from common Python libraries, like the string, list, or tuple in\n",
      "order to minimize name collisions and any resultant confusion.\n",
      "\n",
      "----"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "help('keywords')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "Here is a list of the Python keywords.  Enter any keyword to get more help.\n",
        "\n",
        "False               def                 if                  raise\n",
        "None                del                 import              return\n",
        "True                elif                in                  try\n",
        "and                 else                is                  while\n",
        "as                  except              lambda              with\n",
        "assert              finally             nonlocal            yield\n",
        "break               for                 not                 \n",
        "class               from                or                  \n",
        "continue            global              pass                \n",
        "\n"
       ]
      }
     ],
     "prompt_number": 2
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "-----\n",
      "\n",
      "A Python identifier can be used as the name of a variable, function,\n",
      "class, or module. Python identifiers are case sensitive, so `mylist` is\n",
      "different than `myList`. Writing descriptive identifiers can be\n",
      "beneficial for code readability and subsequent maintenance, thus we\n",
      "often write multi-word identifiers. When combining words, one can either\n",
      "use camel-case format, where each new word after the first is\n",
      "capitalized like `myFileList`. Alternatively, we also can separate words\n",
      "by using underscores like `my_filename_list`.  While both approaches are\n",
      "legal, it is best to be consistent as much as possible. \n",
      "\n",
      "The Python Enhancement Proposal,\n",
      "[PEP-8](http://legacy.python.org/dev/peps/pep-0008/#introduction),\n",
      "provides a complete discussion of recommend best practices when writing\n",
      "Python code. An additional perspective is available on how to be a\n",
      "[Pythonista](http://python.net/~goodger/projects/pycon/2007/idiomatic/\n",
      "handout.html).\n",
      "\n",
      "### Documentation\n",
      "\n",
      "The pirmary mechansim for docmenting Python code is to use comments. Python supports two types of comment strings. The first type is a single-line\n",
      "comment, that begins with the hash or pound character `#` and continues\n",
      "until the end of the line. The `#` character can appear anywhere on the\n",
      "line. You can create large comment blocks by placing single-line comments adjacaent to each other in a Python program. Here are a couple of examples of single line comments, the first\n",
      "comment consists of the entire line, and the second comment extends from\n",
      "the preceding command to the end of that line.\n",
      "```\n",
      "# Calculate the hypotenuse of a triangle\n",
      "\n",
      "c = math.sqrt(a**2 + b**2) # Assuming Euclidean Geometry\n",
      "```\n",
      "\n",
      "The second type of comment is a multi-line comment, that begins and ends\n",
      "with either three single quote characters,  `''' comment text '''`\n",
      ", or three double quote charactes in a row: `\"\"\" comment text \"\"\"`. This\n",
      "comment can easily extend over multiple lines, and is, therefore, used in a Python\n",
      "program to provide documentation via an implicit [docstring]() for\n",
      "functions and classes. Here is an example of a multi-line comment string:\n",
      "\n",
      "```\n",
      "'''\n",
      "This multi-line comment can provide useful information\n",
      "for a function, class or module.\n",
      "\n",
      "This also allows whitepsace to be used to help\n",
      "write more clearly.\n",
      "'''\n",
      "```\n",
      "\n",
      "The built-in `help`  function can be used to view _docstring_ comments for different functions, classes, or other Python features, as shown in the following code block. As the adjacaent comment suggsts, you should execute this function and change the argument to the `help` function to view docmentation for other Python language components like `int`, `complex`, `math`, or `list`.\n",
      "\n",
      "Another built-in function that you will frequently use is the `print` function, which, if neccesary, converts its arguments to a string and displays the resulting string to _STDOUT_, which is generally the display.\n",
      "\n",
      "-----"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "help(print) # Try changing print to something different like int, complex, math, or list."
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Help on built-in function print in module builtins:\n",
        "\n",
        "print(...)\n",
        "    print(value, ..., sep=' ', end='\\n', file=sys.stdout, flush=False)\n",
        "    \n",
        "    Prints the values to a stream, or to sys.stdout by default.\n",
        "    Optional keyword arguments:\n",
        "    file:  a file-like object (stream); defaults to the current sys.stdout.\n",
        "    sep:   string inserted between values, default a space.\n",
        "    end:   string appended after the last value, default a newline.\n",
        "    flush: whether to forcibly flush the stream.\n",
        "\n"
       ]
      }
     ],
     "prompt_number": 3
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "----\n",
      "\n",
      "### Python Operators\n",
      "\n",
      "Python supports the [basic mathematical operators][1], and by importing\n",
      "the math library, the Python interpreter can mimic a scientific\n",
      "calculator. The following list presents the basic mathematical\n",
      "operators, in order of precedence (operators in the same table cell have\n",
      "the same precedence):\n",
      "\n",
      "|Operator | Description | Example|\n",
      "|--------|--------|--------|\n",
      "|`()` | Parenthesis for grouping | `(2 + 3)`|\n",
      "| `**` | Exponential function | `2**3`|\n",
      "|`*`<br/> `/`<br/> `//` <br/> `%` | Multiplication<br/> Division<br/>Integer Division<br/> Remainder | `2*3.1` <br/> `3.2 / 1.2 ` <br/> `5//2` <br/> `5%2`|\n",
      "| `+` <br/> `-`  | Addition <br/> Subtraction| `1.45 + 3.14` <br/> `5.3 - 2.125`|\n",
      "\n",
      "\n",
      "When computing a quantity, you often will want to assign the value to a\n",
      "variable. This is done by using the assignment operator `=`. On the\n",
      "other hand, you may want to test if two values are the same, which is\n",
      "done with the equivalence operator, `==`. In addition, Python provides\n",
      "augmented assignment operators that combine a basic mathematical operator\n",
      "(`+`, `-`, `*`, `/`, `**`, `//`, or `%`) with the assignment operator:\n",
      "`+=`, `-=`, `*=`, `/=`, `**=`, `//=`, and `%=`, this can simplify and\n",
      "thus clarify some expressions.\n",
      "\n",
      "The Python language also provides a number of built-in functions, which\n",
      "generally convert a number either to a different datatype or different\n",
      "precision. These built-in functions are always available. The following\n",
      "table presents some of the more useful built-in functions for use in\n",
      "mathematical expressions.\n",
      "\n",
      "| Built-in Function | Description |\n",
      "|--|--|\n",
      "|`abs(x)`| Returns the absolute value of `x`|\n",
      "|`divmod(x, y)`| Returns both the quotient and remainder of `x/y` when using integer division |\n",
      "|`float(x)`| Returns `x` as a floating-point value |\n",
      "|`int(x)`| Returns `x` as a integer value |\n",
      "|`pow(x, y)`| Returns the exponential function `x**y` |\n",
      "|`round(x, n)` | Returns `x` as a floating-point value rounded to `n` digits (by default `n=0`) |\n",
      "\n",
      "In addition to these operators and built-in functions, there exist a\n",
      "number of mathematical operators in the Python[math library][2],\n",
      "including constants, numerical testing functions, trigonometric\n",
      "functions, logarithmic functions, and several special functions like the\n",
      "error function. The math library is part of the standard Python\n",
      "language, and is thus always accessible. To access them, the best\n",
      "approach is to simply add an `import math` statement at the top of a\n",
      "Python script or program. For example, the following example code\n",
      "demonstrates how to use functions in the math library:\n",
      "\n",
      "````\n",
      "import math\n",
      "\n",
      "x = 2.3\n",
      "y = math.sqrt(x/2.3) - math.sin(x/math.pi) + math.log(x**2)\n",
      "```\n",
      "\n",
      "In this example code, we have introduced the use of variables to hold\n",
      "the result of a calculation. Python is a dynamically-typed language,\n",
      "we do not need to first declare the variable and its type before using\n",
      "it. If the variable is reused and assigned a different value, the\n",
      "variable takes on a new type. Python has a built-in function, the `type`\n",
      "function that can always be used to ascertain the underlying data type\n",
      "of a variable, or any other legal Python construct as shown in the\n",
      "following code block.\n",
      "\n",
      "-----\n",
      "[1]: https://en.wikibooks.org/wiki/Python_Programming/Basic_Math"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x = 1\n",
      "type(x)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 4,
       "text": [
        "int"
       ]
      }
     ],
     "prompt_number": 4
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x = 3.2\n",
      "type(x)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 5,
       "text": [
        "float"
       ]
      }
     ],
     "prompt_number": 5
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "type(print) # Try changing print to something different like 'Hello World!' or math"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 6,
       "text": [
        "builtin_function_or_method"
       ]
      }
     ],
     "prompt_number": 6
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "-----\n",
      "\n",
      "\n",
      "Note that Python supports other operators that are used when working\n",
      "with [Boolean][3] data or to perform [bit-wise operations][4]. For\n",
      "conciseness, we do not discuss these operators in this notebook.\n",
      "\n",
      "In the next set of code blocks, we present several examples that\n",
      "demonstrate how to use the basic Python mathematical operators and\n",
      "functions to compute different expressions. These blocks are meant to be\n",
      "executed, modified, and re-executed. One last point is that the Python\n",
      "interpreter provides a shorthand, a single underscore character `_`, to\n",
      "include the result of the last expression that was displayed by the\n",
      "Python interpreter in a new expression. Note that this is not\n",
      "automatically the result of a previous IPython Notebook cell, but is the\n",
      "last value computed. This is especially true if multiple values are\n",
      "calculated within a code block. The IPython Notebook extends this to\n",
      "allow repeated underscore characters to refer to previously calculated\n",
      "expressions, where the number of underscores refers to how many previous\n",
      "expressions should be used in palace of the underscore characters:\n",
      "\n",
      "```\n",
      ">>> a = 123\n",
      ">>> a\n",
      "123\n",
      ">>> _ + 1\n",
      "124\n",
      "```\n",
      "\n",
      "-----\n",
      "[1]: https://en.wikibooks.org/wiki/Python_Programming/Basic_Math\n",
      "[2]: https://docs.python.org/3/library/math.html\n",
      "[3]: https://en.wikibooks.org/wiki/Python_Programming/Operators#Boolean\n",
      "[4]: https://wiki.python.org/moin/BitwiseOperators"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "5 // 2"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 7,
       "text": [
        "2"
       ]
      }
     ],
     "prompt_number": 7
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "5 % 2"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 8,
       "text": [
        "1"
       ]
      }
     ],
     "prompt_number": 8
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "2.5 * 4.3 / 1.2 *(2 + 3 + 4 + 5) - 2.1**1.01"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 9,
       "text": [
        "123.3010280397591"
       ]
      }
     ],
     "prompt_number": 9
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "2 * _  # Use the result from the previous calculation"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 10,
       "text": [
        "246.6020560795182"
       ]
      }
     ],
     "prompt_number": 10
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "_ + __ + 1 # We now refer to the previous two calculations"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 11,
       "text": [
        "370.9030841192773"
       ]
      }
     ],
     "prompt_number": 11
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "\n",
      "math.sqrt(4)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 12,
       "text": [
        "2.0"
       ]
      }
     ],
     "prompt_number": 12
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "math.exp(0) + math.cos(0) # 1 + 1 = 2"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 13,
       "text": [
        "2.0"
       ]
      }
     ],
     "prompt_number": 13
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "-----\n",
      "\n",
      "## Breakout Session: Coding in IPython Notebooks\n",
      "\n",
      "During this session, you should learn to edit and run Python code in an\n",
      "IPython notebook by using the running IPython server in your Docker\n",
      "container.\n",
      "\n",
      "First, I would stop and running docker containers, and restart the class\n",
      "Docker image as an IPython Notebook server in order to ensure a clean\n",
      "working environment (note: this step is optional). To do this, you\n",
      "should first issue a `docker ps` command at the Boot2Docker prompt to\n",
      "identify any running Docker containers. \n",
      "\n",
      "![Docker PS](images/docker-ps.png)\n",
      "\n",
      "As shown in the figure, this Docker Engine is only running one\n",
      "container, whose `id` is _compassionate\\_ptolmey_.  Given this `id`, we\n",
      "next issue a `docker stop _container\\_id_` command at a boot2docker\n",
      "prompt, replacing _container\\_id_ with the name of the running docker\n",
      "container you wish to stop.\n",
      "\n",
      "![Docker Stop](images/docker-stop.png)\n",
      "\n",
      "Once this command completes, our running Docker container should be\n",
      "stopped, which can be verified by executing another `docker ps` command.\n",
      "We can now start a new IPython Notebook server running in our Docker\n",
      "container by executing:\n",
      "\n",
      "`docker run -d -p 8888:8888 -e \"PASSWORD=temp123\" lcdm/rppds`, \n",
      "\n",
      "where you can replace the indicated password `temp123` by a\n",
      "password of your own choosing.\n",
      "\n",
      "![Docker Run](images/docker-run.png)\n",
      "\n",
      "We now have the IPython Notebook server running, and can connect to the\n",
      "server by opening a Web Browser to\n",
      "[http://192.168.59.103:8888/](http://192.168.59.103:8888/), assuming the\n",
      "default options have been kept. At this point, you will need to enter\n",
      "the password you used to run the Docker container, for example\n",
      "`temp123`, and click the `login` button.\n",
      "\n",
      "![Clean IPY server](images/ipy-cleanstart.png)\n",
      "\n",
      "-----\n",
      "\n",
      "At this point, you have a clean IPython Notebook server running.\n",
      "Alternatively, you might be simply continuing on with a previously\n",
      "running IPython Notebook server. At this point, click the `New Notebook`\n",
      "button to create a new IPython Notebook on the server. We will use our\n",
      "IPython Notebook to _clone_ the course repository into our Docker\n",
      "container. To do this, we need to know the proper URL, which can be\n",
      "easily found by visiting the [course github\n",
      "repository](https://github.com/ProfessorBrunner/rp-pds15), and looking\n",
      "at the lower right, where a text field contains the `git clone` URL for\n",
      "this particular repository. Copy the URL shown in this textfield:\n",
      "\n",
      "![Github Repository Clone URL](images/github-cloneurl.png)\n",
      "\n",
      "Now, in your new Notebook, enter `!git clone ` followed by the URL you\n",
      "copied in the previous step. Once this is done, execute the cell in\n",
      "order to clone the repository into the local Docker container.\n",
      "\n",
      "![Github Repository Clone](images/github-clone.png)\n",
      "\n",
      "Now, return to the IPython dashboard, and navigate to the Notebook you\n",
      "wish to open, for example, _intro2py.ipynb_. Click on the desired\n",
      "Notebook's name to open the Notebook in a new window.\n",
      "\n",
      "### Introductory Challenge\n",
      "\n",
      "First, try executing each cell in the Notebook, either by using the\n",
      "keyboard shortcuts: shift-return or control-return, or by using the menu\n",
      "tools.\n",
      "\n",
      "When you have a code cell, try editing the code (which are often\n",
      "suggested in comments) and seeing what changes result when the cell\n",
      "block is executed.\n",
      "\n",
      "-----"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "-----\n",
      "## Additional References\n",
      "\n",
      "1. [Think Python](http://faculty.stedwards.edu/mikek/python/thinkpython.pdf) for Python3.\n",
      "2. [Python3 Tutorial](https://docs.python.org/3.4/tutorial/index.html)\n",
      "\n",
      "For information on writing Python programs at the command line, Google for Education has developed [Pyhon Setup directions](https://developers.google.com/edu/python/set-up).\n",
      "\n",
      "For additional information on the Python 2 versus Python 3 debate:\n",
      "1. A [discussion of the differences between Python 2 and Python 3](http://python3porting.com/intro.html).\n",
      "2. A [shorter List of Changes from Python 2 to Python 3](http://inventwithpython.com/appendixa.html).\n",
      "\n",
      "Several free books, mostly written for Python 2:\n",
      "1. [Open Tech School's Introduction to Programming with Python](http://opentechschool.github.io/python-beginners/en/index.html)\n",
      "2. [Invent with Python](http://inventwithpython.com)\n",
      "3. [Building Skills in Programming](http://www.itmaybeahack.com/homepage/books/)\n",
      "4. [Learn Python The Hard Way, 3rd Edition](http://learnpythonthehardway.org/book/)\n",
      "5. [A Byte of Python](http://www.ibiblio.org/g2swap/byteofpython/read/)\n",
      " \n",
      " \n",
      "-----"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### Return to the [Week 3 Index](index.ipynb).\n",
      "\n",
      "-----"
     ]
    }
   ],
   "metadata": {}
  }
 ]
}