cs107-lecture-examples

python_2.ipynb (65004B)

---

 {
  "cells": [
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "# Basic Python\n",
     "\n",
     "* Booleans and Control Flow\n",
     "* Functions\n",
     "* Exceptions\n",
     "* Plotting"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "We'll be embedding some HTML into our notebook.  To do so, we need to import a\n",
     "library:"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 1,
    "metadata": {
     "collapsed": true
    },
    "outputs": [],
    "source": [
     "from IPython.display import HTML"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "We'll also probably use `numpy` so we might as well import it too:"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 2,
    "metadata": {
     "collapsed": true
    },
    "outputs": [],
    "source": [
     "import numpy as np"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Booleans and Control Flow\n",
     "\n",
     "These are pretty standard things in any language.  I'll just show you a little\n",
     "bit of syntax here. However, I will put a slight emphasis on the exception\n",
     "testing.  It's important."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "#### Testing for membership"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 3,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "False\n",
       "True\n"
      ]
     }
    ],
    "source": [
     "some_primes = [2, 3, 5, 7, 13]\n",
     "print(4 in some_primes)\n",
     "print(13 in some_primes)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "#### Some basic if/elif/else statements"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 4,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "x is definitely not prime.\n"
      ]
     }
    ],
    "source": [
     "x = 9\n",
     "if x in some_primes:\n",
     "    print('x is prime!')\n",
     "elif x > 13:\n",
     "    print('x may or may not be prime.')\n",
     "else:\n",
     "    print('x is definitely not prime.')"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Breaking out of a loop:"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 5,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "Only even prime.\n"
      ]
     }
    ],
    "source": [
     "for x in some_primes:\n",
     "    if x == 2:\n",
     "        print('Only even prime.')\n",
     "        break\n",
     "        "
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Continuing a loop.  Notice that everything after the continue statement is\n",
     "ignored."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 6,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "1\n",
       "2\n",
       "3\n",
       "4\n",
       "5\n",
       "Done with this.\n"
      ]
     }
    ],
    "source": [
     "i = 0\n",
     "while i < 10:\n",
     "    i += 1\n",
     "    if i <= 5:\n",
     "        print(i)\n",
     "        continue\n",
     "        print(i-1)\n",
     "    else:\n",
     "        print('Done with this.')\n",
     "        break\n",
     "    "
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "#### Some basic exception handling\n",
     "\n",
     "Python has a number of built-in exceptions ([Built-in\n",
     "exceptions](https://docs.python.org/3/library/exceptions.html), [Python Standard\n",
     "Exceptions](https://www.tutorialspoint.com/python/standard_exceptions.htm)).  It\n",
     "is usually a good idea to let Python raise exceptions for you since it's really\n",
     "good at it.  However, there are times when you may want to write your own\n",
     "exception (we won't talk about that now) or when you want to press ahead even in\n",
     "the face of an error.\n",
     "\n",
     "I can make that last statement clearer.  You have two options:  catch and\n",
     "respond to errors when they're raised or ignore them.  If you ignore them, then\n",
     "Python's default exception-handling behavior takes over which will ultimately\n",
     "print out the error message and terminate the program.  If you respond to the\n",
     "errors, then you need to tell your program what to do.  In essence, you will\n",
     "shift the control flow of your program if you choose this second option.\n",
     "\n",
     "Let's look at an example or two."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 7,
    "metadata": {},
    "outputs": [
     {
      "ename": "ZeroDivisionError",
      "evalue": "float division by zero",
      "output_type": "error",
      "traceback": [
       "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
       "\u001b[0;31mZeroDivisionError\u001b[0m                         Traceback (most recent call last)",
       "\u001b[0;32m<ipython-input-7-3b7789856ab2>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m1.0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0.0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mz\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m/\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m \u001b[0mz\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0;36m2.0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
       "\u001b[0;31mZeroDivisionError\u001b[0m: float division by zero"
      ]
     }
    ],
    "source": [
     "x, y = 1.0, 0.0\n",
     "z = x / y\n",
     "z**2.0"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Python took care of error for us and terminated the program at the second line.\n",
     "\n",
     "But perhaps a division by zero isn't the end of the world.  What if we have a\n",
     "piece-wise function?"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 8,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "z = 0.0\n"
      ]
     }
    ],
    "source": [
     "x, y = 1.0, 0.0\n",
     "try:\n",
     "    z = x / y\n",
     "except ZeroDivisionError:\n",
     "    z = 0.0\n",
     "print('z = {}'.format(z))"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "This could, of course, have been handled with an `if-else` block.\n",
     "\n",
     "One old motivation for using exception handling is to check the input arguments\n",
     "of a function for validity.  You can still do this, but the latest advice is to\n",
     "just let Python's exception handler deal with it and terminate the program if\n",
     "need be."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Functions\n",
     "\n",
     "#### Python functions are first class:\n",
     "\n",
     "* You can assign variables to them\n",
     "* You can pass them into functions\n",
     "* You can return them from functions"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "### Example: "
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 9,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "Original maximum gives 13 and new maximum gives 13.\n"
      ]
     }
    ],
    "source": [
     "alist = [1,13,5,7]\n",
     "newmax = max # Assign newmax to the function max\n",
     "mymax1 = max(alist) # Get the maximum of the list using the max built-in\n",
     "mymax2 = newmax(alist) # Get the maximum of the list using the new max function\n",
     "print('Original maximum gives {0} and new maximum gives {1}.'.format(mymax1, mymax2))"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "The syntax for defining functions is pretty straightforward."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 10,
    "metadata": {
     "collapsed": true
    },
    "outputs": [],
    "source": [
     "def rect(w,h):\n",
     "    return w * h\n",
     "def circle(r):\n",
     "    return np.pi * r * r\n",
     "def parabola(x, a, b, c):\n",
     "    return a * x * x + b * x + c"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Notice that the function name is preceded by the keyword `def`.  The end of the\n",
     "line **must** have a colon!  The function body is indented.  The quantity to be\n",
     "returned is returned using the `return` statement.\n",
     "\n",
     "Because functions are first class, we can pass functions to other functions."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 11,
    "metadata": {
     "collapsed": true
    },
    "outputs": [],
    "source": [
     "def parab_extrema(a, b, c, parab):\n",
     "    x_extreme = - b / 2.0 / a # Location of max or min\n",
     "    x_left = x_extreme - 1.0  # Point to the left of max or min\n",
     "    x_right = x_extreme + 1.0 # Point to the right of max or min\n",
     "    p_left = parab(x_left, a, b, c) # Value at left point\n",
     "    p_right = parab(x_right, a, b, c) # Value at right point\n",
     "    p_extreme = parab(x_extreme, a, b, c) # Value at max or min\n",
     "    # Check if extremum is maximum or minimum and print out result\n",
     "    if (p_left > p_extreme) & (p_right > p_extreme):\n",
     "        print('The extremum for this parabola has coordinates ({x:4.3f}, {y:4.3f}) and is a minimum.'.format(x=x_extreme, y=p_extreme))\n",
     "    elif (p_left < p_extreme) & (p_right < p_extreme):\n",
     "        print('The extremum for this parabola has coordinates ({x:4.3f}, {y:4.3f}) and is a maximum.'.format(x=x_extreme, y=p_extreme))\n",
     "    else:\n",
     "        print('Something went wrong.')"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 12,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "The extremum for this parabola has coordinates (-2.500, -4.250) and is a minimum.\n",
       "The extremum for this parabola has coordinates (-0.500, 6.250) and is a maximum.\n"
      ]
     }
    ],
    "source": [
     "a, b, c = 0.2, 1.0, -3.0\n",
     "parab_extrema(a, b, c, parabola)\n",
     "a, b, c = -5.0, -5.0, 5.0\n",
     "parab_extrema(a, b, c, parabola)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "There are some other convenient ways to interact with function arguments.\n",
     "\n",
     "One thing you may wish to do is provide a default argument to the function.  If\n",
     "that argument is not specified when the function is called, then the default\n",
     "value is assumed.  This is a type of keyword argument.\n",
     "\n",
     "Let's return to our nice parabola example.  We'll make $b=0$ the default."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 13,
    "metadata": {
     "collapsed": true
    },
    "outputs": [],
    "source": [
     "def parabola(x, a, c, b=0.0):\n",
     "    return a * x * x + b * x + c"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Notice that we had to move our default argument to a position _after_ the\n",
     "mandatory arguments.  That hurts the readability a little bit in this example,\n",
     "but we'll press forward regardless.\n",
     "\n",
     "Now call the `parab_extreme() function` again."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 14,
    "metadata": {
     "collapsed": true
    },
    "outputs": [],
    "source": [
     "def parab_extrema(a, b, c, parab):\n",
     "    x_extreme = - b / 2.0 / a # Location of max or min\n",
     "    x_left = x_extreme - 1.0  # Point to the left of max or min\n",
     "    x_right = x_extreme + 1.0 # Point to the right of max or min\n",
     "    p_left = parab(x_left, a, c) # Value at left point\n",
     "    p_right = parab(x_right, a, c) # Value at right point\n",
     "    p_extreme = parab(x_extreme, a, c) # Value at max or min\n",
     "    # Check if extremum is maximum or minimum and print out result\n",
     "    if (p_left > p_extreme) & (p_right > p_extreme):\n",
     "        print('The extremum for this parabola has coordinates ({x:4.3f}, {y:4.3f}) and is a minimum.'.format(x=x_extreme, y=p_extreme))\n",
     "    elif (p_left < p_extreme) & (p_right < p_extreme):\n",
     "        print('The extremum for this parabola has coordinates ({x:4.3f}, {y:4.3f}) and is a maximum.'.format(x=x_extreme, y=p_extreme))\n",
     "    else:\n",
     "        print('Something went wrong.')"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "We changed the\n",
     "[API](https://en.wikipedia.org/wiki/Application_programming_interface) a little\n",
     "bit and so we had to update the calls to `parab()`.  However, everything works\n",
     "just fine if we're careful."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "It's probably better to give all the parameter arguments default values.  Let's\n",
     "re-write the API again."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 15,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "The extremum for this parabola has coordinates (0.500, -1.250) and is a minimum.\n"
      ]
     }
    ],
    "source": [
     "def parabola(x, a=1.0, b=-1.0, c=-1.0):\n",
     "    return a * x * x + b * x + c\n",
     "\n",
     "def parab_extrema(parab, a=1.0, b=-1.0, c=-1.0):\n",
     "    x_extreme = - b / 2.0 / a # Location of max or min\n",
     "    x_left = x_extreme - 1.0  # Point to the left of max or min\n",
     "    x_right = x_extreme + 1.0 # Point to the right of max or min\n",
     "    p_left = parab(x_left, a, b, c) # Value at left point\n",
     "    p_right = parab(x_right, a, b, c) # Value at right point\n",
     "    p_extreme = parab(x_extreme, a, b, c) # Value at max or min\n",
     "    # Check if extremum is maximum or minimum and print out result\n",
     "    if (p_left > p_extreme) & (p_right > p_extreme):\n",
     "        print('The extremum for this parabola has coordinates ({x:4.3f}, {y:4.3f}) and is a minimum.'.format(x=x_extreme, y=p_extreme))\n",
     "    elif (p_left < p_extreme) & (p_right < p_extreme):\n",
     "        print('The extremum for this parabola has coordinates ({x:4.3f}, {y:4.3f}) and is a maximum.'.format(x=x_extreme, y=p_extreme))\n",
     "    else:\n",
     "        print('Something went wrong.')\n",
     "\n",
     "parab_extrema(parabola)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Great!  Looks pretty nice.\n",
     "\n",
     "But there's more!  We can also provide _positional_ and _keyword_ arguments to a\n",
     "function.  This allows permits a variable number of arguments to be passed to a\n",
     "function.\n",
     "\n",
     "* positional arguments:  `def func(*args):`\n",
     "  + Python collects all the remaining positional arguments into a tuple.  You\n",
     "    can then access the tuple with the usual indexing.\n",
     "* keyword arguments:  `def func(**kwargs):`\n",
     "  + Python collects all the remaining keyword arguments into a dictionary.  You\n",
     "    can then access the dictionary with the usual indexing."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "### Variable Positional Arguments\n",
     "\n",
     "We will once again work with the quadratic equation example.  This time, we'll\n",
     "just work with the `parabola` function to save some space.  Let's change the\n",
     "`parabola` function to permit a variable number of arguments."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 16,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
        "-1.0"
       ]
      },
      "execution_count": 16,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
     "def parabola(x, *args):\n",
     "    return args[0] * x * x + args[1] * x + args[2]\n",
     "parabola(1.0, 1.0, -1.0, -1.0)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Seems to work okay.  But this is not a very robust code.  Everything breaks if\n",
     "we don't provide the exact number of necessary arguments."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 17,
    "metadata": {},
    "outputs": [
     {
      "ename": "IndexError",
      "evalue": "tuple index out of range",
      "output_type": "error",
      "traceback": [
       "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
       "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
       "\u001b[0;32m<ipython-input-17-4a52e1254eed>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mparabola\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1.0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
       "\u001b[0;32m<ipython-input-16-f85ec532a54e>\u001b[0m in \u001b[0;36mparabola\u001b[0;34m(x, *args)\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mparabola\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m \u001b[0mparabola\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1.0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1.0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m-\u001b[0m\u001b[0;36m1.0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m-\u001b[0m\u001b[0;36m1.0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
       "\u001b[0;31mIndexError\u001b[0m: tuple index out of range"
      ]
     }
    ],
    "source": [
     "parabola(1.0)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "### Variable keyword arguments\n",
     "\n",
     "We can make our API more flexible.  Let's give more descriptive names to the\n",
     "coefficients $a$, $b$, and $c$.  We'll call $a$ the `width` since it controls\n",
     "the width of the parabola, $b$ `trans` since it controls the horizontal\n",
     "translation of the parabola, and we'll call $c$ `shift` since it controls the\n",
     "vertical shift of the parabola.  Our `parabola` function might now look like:"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 18,
    "metadata": {
     "collapsed": true
    },
    "outputs": [],
    "source": [
     "def parabola(x, **kwargs):\n",
     "    print(kwargs)\n",
     "    return kwargs['width'] * x * x + kwargs['trans'] * x + kwargs['shift']"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Calling it gives:"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 19,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "{'width': 1.0, 'trans': -1.0, 'shift': -1.0}\n"
      ]
     },
     {
      "data": {
       "text/plain": [
        "-1.0"
       ]
      },
      "execution_count": 19,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
     "parabola(1.0, width=1.0, trans=-1.0, shift=-1.0)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "**Note:** Using variable positional and keyword arguments provides exceptional\n",
     "flexibility in how you design your programs."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "One final note about variable arguments:  You can perform the reverse operation\n",
     "by passing in the `*` or `**` operators to the function.  This will _unpack_ the\n",
     "arguments whereas the previous pattern _packed_ the arguments.  Let's take a\n",
     "quick look."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 20,
    "metadata": {
     "collapsed": true
    },
    "outputs": [],
    "source": [
     "def parabola(x, a, b, c):\n",
     "    return a * x * x + b * x + c"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 21,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
        "-1.0"
       ]
      },
      "execution_count": 21,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
     "# Store coefficients in a list\n",
     "coeffs = [1.0, -1.0, -1.0]\n",
     "parabola(1.0, *coeffs)\n",
     "\n",
     "# Store coefficients in a dictionary\n",
     "coeffs = {'a':1.0, 'b':-1.0, 'c':-1.0}\n",
     "parabola(1.0, **coeffs)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {
     "collapsed": true
    },
    "source": [
     "---\n",
     "\n",
     "## Plotting\n",
     "\n",
     "There are many, many ways to make plots in Python.  The most common way is to\n",
     "use [`matplotlib`](https://matplotlib.org/).\n",
     "\n",
     "Another package, which is gaining popularity, is called\n",
     "[`seaborn`](https://seaborn.pydata.org/).\n",
     "\n",
     "I don't care which package you use, as long as your plots are readable and\n",
     "reproducible."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "To make plots in the Jupyter notebook, you need to include the line `%matplotlib\n",
     "inline` before you make any plots.  This line ensures that the plots will be\n",
     "displayed in your notebook and not in a separate window."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 22,
    "metadata": {
     "collapsed": true
    },
    "outputs": [],
    "source": [
     "%matplotlib inline"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Next, you should `import matplotlib`:"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 23,
    "metadata": {
     "collapsed": true
    },
    "outputs": [],
    "source": [
     "import matplotlib               # Import all of matplotlib\n",
     "import matplotlib.pyplot as plt # Only import pyplot (which includes the plot function) and give it the alias `plt`"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Now you're basically ready to do some plots.\n",
     "\n",
     "**WARNING!** When making plots in an actual Python script, you must **always**\n",
     "include the command `plt.show()` at the **end** of your program.  **Always.** If\n",
     "you don't do so, then your plots will not display and you will be wondering\n",
     "where they are.  However, when plotting in the Jupyter notebook, there is no\n",
     "need to use `plt.show()`."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "We can generate some toy data using `numpy`."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 24,
    "metadata": {},
    "outputs": [],
    "source": [
     "x = np.linspace(-2.0*np.pi, 2.0*np.pi, 500) # x-grid\n",
     "ys = np.sin(x) # sin function\n",
     "yc = np.cos(x) # cos function"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Now plot!"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 25,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
        "<matplotlib.text.Text at 0x10fb8c080>"
       ]
      },
      "execution_count": 25,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
       "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaIAAAEtCAYAAABK7WRiAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
       "text/plain": [
        "<matplotlib.figure.Figure at 0x10c7c0dd8>"
       ]
      },
      "metadata": {},
      "output_type": "display_data"
     }
    ],
    "source": [
     "plt.plot(x, ys, lw=4, ls='-', label=r'$\\sin(x)$')  # linewidth = 4, linestyle = solid, raw string label\n",
     "plt.plot(x, yc, lw=4, ls='--', label=r'$\\cos(x)$')\n",
     "plt.legend() # show legend\n",
     "plt.xlabel(r'$x$', fontsize=24) # label x axis\n",
     "plt.ylabel(r'$y$', fontsize=24) # label y axis\n",
     "plt.title('Sine and Cosine', fontsize=24)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Notice that we used a few things:\n",
     "1. We changed the line widths\n",
     "2. We changed the line style\n",
     "3. We labeled the plots\n",
     "4. We changed the font size of the labels\n",
     "\n",
     "We also use a `raw string` because we're including Latex commands to render\n",
     "mathematics.  A `raw string` is preceded by the letter `r`."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "There is **much** more to plotting than this example, but this should get you\n",
     "started.  Some things you may want to look up are how to change the size of the\n",
     "tick marks and tick labels and how to use a `config` file: [Customizing a\n",
     "Plot](https://matplotlib.org/users/customizing.html).  You may also want to\n",
     "understand _contour_ plots as well as _scatter_ plots and other statistical\n",
     "plots such as `pdfs` and `histograms`.  Note that `seaborn` has fantastic\n",
     "support for statistical plots."
    ]
   }
  ],
  "metadata": {
   "jupytext": {
    "formats": "ipynb,md"
   },
   "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.6.7"
   }
  },
  "nbformat": 4,
  "nbformat_minor": 2
 }