TOSCA_lab1.ipynb

{
 "metadata": {
  "name": "",
  "signature": "sha256:83d653b3a4d5ae3bfe023fcc1f585c8a1e73fe9cd026dc15b8f7c078d37edfb1"
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "heading",
     "level": 1,
     "metadata": {},
     "source": [
      "TOSCA computer class: Clouds and a cosmic ray link"
     ]
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Part 1: first steps in iPython"
     ]
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "by Benjamin A. Laken"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "This computer class will be delivered as an IPython notebook. The class will cover (1) a brief introduction to Python and some of its excellent features, including creating some simple plots. (2) We will then import some data, and perform an analysis of extreme (short-term) solar events.\n",
      "\n",
      "**If you are already familiar with the iPython notebook environment, then feel free to immediatley skip to part 2.**\n",
      "\n",
      "You will find Python is a very flexible and powerful tool, supported by a large, active, and multi-disciplinary community. As this class is designed to cover 90 mins, we can only scratch the surface of Python, but be assured it has much more to offer you than we cover here.\n",
      "\n",
      "If you don't have Python, you can freely get it from http://store.continuum.io\n",
      "\n",
      "You can then start an IPython notebook with the following command:\n",
      "\n",
      "    ipython notebook --pylab inline \n",
      "    \n",
      "Contact: blaken@geo.uio.no "
     ]
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "What is Python anyway?"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Python is a programming language. In its simplest form you can use it as a glorified calculator, but at the highest level you could use it to push the worlds fastest computers to their limit!\n",
      "\n",
      "We will only cover some basics which you need to get started. If you are totally unfamiliar  with programming concepts, you will need to do some extra reading! For those totally new to Python or programming, there are many resources to help you:\n",
      "\n",
      "https://wiki.python.org/moin/BeginnersGuide/NonProgrammers\n",
      "\n",
      "Essentially, the notebook environment is comprised of cells. These cells can be code, as well as text written in the Markdown language (with LaTeX commands!). The below is a cell of code. You can think of it as an individual terminal. \n",
      "\n",
      "Extra -- for later, it can also be useful to know that all Input and Output of the cells can be called by later cells."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 0
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Import a package to show images, then use it to download and display a classic XKCD comic\n",
      "from IPython.display import Image, display, display_png, HTML\n",
      "Image(url='http://imgs.xkcd.com/comics/python.png')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "html": [
        "<img src=\"http://imgs.xkcd.com/comics/python.png\"/>"
       ],
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 3,
       "text": [
        "<IPython.core.display.Image at 0x105ba6dd0>"
       ]
      }
     ],
     "prompt_number": 3
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Before we can use Python for TOSCA-related fun, we must first cover the basics of the language. The best way to learn is simply to play---something iPython, and the notebook lets you do very easily. So, to the basic syntax: create a 'Hello, world' program in the cell below!\n",
      "\n",
      "When you have finished entering your code, you may execute it by pressing the Return + `ctrl` key to run, and shift to the next cell (or Return + `shift` key to run and stay in current cell)."
     ]
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Learning by doing"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The first thing to always remember in IPython, is the every-useful help feature. Simply accessed by `?`. You can always place this after a function or object to learn more about it. Using `??` gives you the source code."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "?"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 2
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# This is a comment. See how the output autmatically is displayed for the below code.\n",
      "1 + 1"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 3,
       "text": [
        "2"
       ]
      }
     ],
     "prompt_number": 3
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# You can assign 'pointers' to a value or string (note this does not cause anything to be outputted)...\n",
      "a = 1\n",
      "b = 1                \n",
      "# ...and then perform operations, using the pointers...\n",
      "a + b"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 4,
       "text": [
        "2"
       ]
      }
     ],
     "prompt_number": 4
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The assigned pointers are maintained in your sessions memory. You can easily see what is in the memory with the `whos` command. It also shows useful information, such as the type of data, and information about it."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "whos"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Variable      Type        Data/Info\n",
        "-----------------------------------\n",
        "HTML          type        <class 'IPython.core.display.HTML'>\n",
        "Image         type        <class 'IPython.core.display.Image'>\n",
        "a             int         1\n",
        "b             int         1\n",
        "display_png   function    <function display_png at 0x10316ede8>\n"
       ]
      }
     ],
     "prompt_number": 5
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Here is how simple math operations are written in python (print is showing their output)\n",
      "print 2 + 1                                             # Addition \n",
      "print 2 - 1                                             # Subtraction\n",
      "print 2 * 1                                             # Multiplication\n",
      "print 2 / 1                                             # Division\n",
      "print 2 ** 1                                            # Exponentiation\n",
      "print 3 + (3 * 2)   "
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "3\n",
        "1\n",
        "2 also print multiple things (inc. string)\n",
        "2\n",
        "2\n",
        "9\n"
       ]
      }
     ],
     "prompt_number": 6
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# String things!\n",
      "a1 = \"I am a string\"\n",
      "b1 = 'I am also a string '\n",
      "c1 = str(3.33333)                 # <-- Even this is a string!\n",
      "print a1, b1, c1\n",
      "print a1 + b1 + c1\n",
      "\n",
      "d1 = a1+', '+b1              # Addition of strings\n",
      "print d1\n",
      "\n",
      "print d1[5:9]                # Simple subsetting of the string "
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "I am a string I am also a string  3.33333\n",
        "I am a stringI am also a string 3.33333\n",
        "I am a string, I am also a string \n",
        "a st\n"
       ]
      }
     ],
     "prompt_number": 35
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Three data types: INTEGER (int), FLOAT (float), and STRING (str). The operations (and behaviour) depends on the type of data you are using. For example, in the below cell please demonstrate Pythons behaviour when dealing with operations for :\n",
      "* Integer and Integer\n",
      "* Float and Float\n",
      "* Integer and Float\n",
      "* Float and String"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Type your operations on Floats, Ints, and Strings in here (and dont forget to make them print)\n",
      "\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 7
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Functions are built in to python. You can easily access them in IPython by using the `tabb` key autocomplete feature. For the below cell, we can use a function to show the type of data which the variable 'c' is made of. Different types of objects in python also have methods attached to them, which you can similarly access, by `c.<press tabb>`."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "c = a + b                       \n",
      "type(c)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 8,
       "text": [
        "int"
       ]
      }
     ],
     "prompt_number": 8
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "You can erase pointers (aka variables) from the memory with `del <name>`, after deleting variable `a` and `b` in the below cell."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Erase variables from the memory in here\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 9
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      " Run the `whos` command in the cell below this to see what remains after you clear the variables. "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 9
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Now something more exciting. The RANGE function. Examine and understand the below cell. What has it produced, and what operations can you rapidly do with it using the attached methods."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "thing = range(20)        # Test 'thing', and find out what it is, where it came from, \n",
      "                         # and what it can do! Dont forget to use the help function\n",
      "                         # called for example by  > ?range below\n",
      "?range                         \n",
      "    "
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 32
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "A short intro to Python Lists: Lists are not Arrays and have distinct uses"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Holding more than one value: the Python LIST\n",
      "a = [1.0,2.0,3.0,4.0,5.0,6.0]            # Creation of a list of data elements\n",
      "b = [1,2,3,4,5,6]                        # Create a second list (integers this time)\n",
      "\n",
      "print 'Type of varible:',type(a)         # Query the type of variable you created\n",
      "print 'Lenght of variable:',len(a)       # Query the number of data elements \n",
      "\n",
      "print a[:]                               # The colon means a range of elements\n",
      "print a[0:2]                             # In this case, the first[0] to second[2]\n",
      "print a[-1]                              # In this case, the last element only!  "
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Type of varible: <type 'list'>\n",
        "Lenght of variable: 6\n",
        "[1.0, 2.0, 3.0, 4.0, 5.0, 6.0]\n",
        "[1.0, 2.0]\n",
        "6.0\n"
       ]
      }
     ],
     "prompt_number": 11
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Try and use simple math operations on the lists a & b, see what happens... "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 11
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "It is particularly important to note that above, the lists joined, with list a appearing first, and list b appearing second... try changing some of the values inside lists to different types of data (even words), and see the behaviour of the lists - they are dynamic, and can mix data-types...\n",
      "\n",
      "An important thing to note: curly brackets () are used differently to square brackets []. The curlys indicate a function (some specific task will be done on objects inside them), while squares are either declaring a list, specifying elements inside a list, or doing repeating operations (looping through lists).\n",
      "\n",
      "Also, good to know, IPython has available at anytime 'Magic' functions, \n",
      "which can give you a lot of extra functionality. For examples see the notebook:\n",
      "http://nbviewer.ipython.org/github/ipython/ipython/blob/1.x/examples/notebooks/Cell%20Magics.ipynb"
     ]
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Modules: import awesome"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "On its own, Python isnt equipped to fufill our scientific needs. There arent enough functions in the basic language. Fortunatley, the enormous open-source community has come to the rescue! There are thousands of useful functions, contained in *MODULES*. We can import these Modules, and then easily start using their useful functions!"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# We need'MODULES' to extend the functionality of Python\n",
      "from numpy import array           # This is how we call installed modules.\n",
      "\n",
      "ax = array(a)                     # Remeber curly brackets mean a function...\n",
      "bx = array(b)\n",
      "\n",
      "print type(ax)                    # What are these new pointers?\n",
      "print ax + bx                     # See what happens when you sum arrays instead of lists...\n",
      "print 'Max. val. =',max(ax + bx)  # Also, see how you can use functions on arrays\n",
      "print 'Min. val. =',min(ax + bx) "
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "<type 'numpy.ndarray'>\n",
        "[  2.   4.   6.   8.  10.  12.]\n",
        "Max. val. = 12.0\n",
        "Min. val. = 2.0\n"
       ]
      }
     ],
     "prompt_number": 12
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Different types of data behave in different ways. With addition commands (+) list data tries to append, whereas arrays will try and perform element-wise arithmetic! For our needs (time-series data analysis), we will be using arrays from the NUMPY module.\n",
      "\n",
      "Before we start using arrays, we will just briefly look at loops and logic."
     ]
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Logic: 'I think, therefore I Python'"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "We will briefly look at looping, and logic in Python."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Loops are very important and easy in Python, and there are lots of possible types:\n",
      "Drinks =['Beer','Cider','Rum','Mohito','Water','Wiskey','Wine']         # A pointer to a list \n",
      "\n",
      "print 'An implicit loop'        # A very nice python feature\n",
      "for n in Drinks:                # The simplist uses elements of a list to iterate\n",
      "    print n                     # The use of : on the first line , and space on the second is needed\n",
      "\n",
      "print '\\n'                      # Newline character\n",
      "\n",
      "print 'Looping through a range' # Quite old-fashioned\n",
      "for n in xrange(len(Drinks)):   # Note the use of lenghth function > len()\n",
      "    print n,Drinks[n]           # Note the use of square brackets and n to call elements of Drinks \n",
      "    \n",
      "print '\\n'                      # Newline character\n",
      "\n",
      "print \"An enumeration loop\"     # Very useful, as the function provides an integer count,\n",
      "for i,n in enumerate(Drinks):   # and the element value. Note as with the implicit loop there is\n",
      "    print i,n                   # no specification of the lenght of the Drinks list.\n",
      "    \n",
      "print '\\n'                      # Newline character\n",
      "print 'An inline loop'          # Very cool Pythonic approach. Can be used to create one line \n",
      "print [n for n in Drinks]       # programs that are very efficent!"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "An implicit loop\n",
        "Beer\n",
        "Cider\n",
        "Rum\n",
        "Mohito\n",
        "Water\n",
        "Wiskey\n",
        "Wine\n",
        "\n",
        "\n",
        "Looping through a range\n",
        "0 Beer\n",
        "1 Cider\n",
        "2 Rum\n",
        "3 Mohito\n",
        "4 Water\n",
        "5 Wiskey\n",
        "6 Wine\n",
        "\n",
        "\n",
        "An enumeration loop\n",
        "0 Beer\n",
        "1 Cider\n",
        "2 Rum\n",
        "3 Mohito\n",
        "4 Water\n",
        "5 Wiskey\n",
        "6 Wine\n",
        "\n",
        "\n",
        "An inline loop\n",
        "['Beer', 'Cider', 'Rum', 'Mohito', 'Water', 'Wiskey', 'Wine']\n"
       ]
      }
     ],
     "prompt_number": 39
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Loops and IF statements\n",
      "want = raw_input(\"Type the name of any drink you would like.\")\n",
      "check = 0\n",
      "for i in Drinks:                                 # Start a nice simple loop\n",
      "    if i == want:                                # Use an if statement\n",
      "        print 'We have '+i\n",
      "        check = 1\n",
      "    elif i != want:                              # Also use an else if statement\n",
      "        print 'You didnt ask for ' + i\n",
      "\n",
      "\n",
      "if check == 0:                                   # If statement outside of a loop...\n",
      "    print 'Sorry we dont have ' + want\n",
      "else:                                            # Here is a final of if logic, an else.\n",
      "    print 'Enjoy your drink!'\n",
      "\n",
      "    \n",
      "# This is very 'clunky' and ineffective code... see if you can improve it (for instance\n",
      "# by not printing out every drink. Try to improve it with differnt kind of loops \n",
      "#(or even no loops at all). You could use while loops, or try truth functions..."
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "name": "stdout",
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Type the name of any drink you would like.t\n"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "You didnt ask for Beer\n",
        "You didnt ask for Cider\n",
        "You didnt ask for Rum\n",
        "You didnt ask for Mohito\n",
        "You didnt ask for Water\n",
        "You didnt ask for Wiskey\n",
        "You didnt ask for Wine\n",
        "Sorry we dont have t\n"
       ]
      }
     ],
     "prompt_number": 14
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Importing NUMPY, SCIPY and MATPLOTLIB: let's get useful!"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Python itself is a basic framework, we tailor it to our needs with libraries and extensions (this notebook, and IPython is just one such extension. In scientific computing, we will always require the NUMPY and SCIPY modules. We will now import them, with an alias, and see how to run functions from them.\n",
      "\n",
      "For the below, function (np.random.random), work out what it does (use the `?`). Then follow the built in functions (type, len, min etc...) to understand what they are showing (again try using the `?`)."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import numpy as np      \n",
      "import scipy as sci\n",
      "\n",
      "\n",
      "a =np.random.random(100)     \n",
      "    \n",
      "\n",
      "print 'Type ',type(a)\n",
      "print 'Shape ',a.shape              # The shape command is very useful...\n",
      "print 'Lenght ',len(a)\n",
      "print 'Range ',min(a),'--',max(a)\n",
      "\n",
      "\n",
      "#plt.plot(a)    # When you understand the idea of np.random.random uncomment these two lines\n",
      "#plt.show()\n",
      "\n",
      "# Try and customise your output: learn from the best at http://matplotlib.org"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Type  <type 'numpy.ndarray'>\n",
        "Shape  (100,)\n",
        "Lenght  100\n",
        "Range  0.00507446759559 -- 0.967536367544\n"
       ]
      }
     ],
     "prompt_number": 15
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Python has excellent graphing features, mainly though the MATPLOTLIB library. We will import this library, and then see how to make some simple line plots. \n",
      "\n",
      "We are going to use the MATPLOTLIB module now to create some simple line plots"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import matplotlib.pyplot as plt"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 16
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "test = (linspace(0, 10))         # Create some values to plot"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 17
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "plt.plot(test,'r--')\n",
      "plt.title('My first Python plot')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 18,
       "text": [
        "<matplotlib.text.Text at 0x10620bf90>"
       ]
      },
      {
       "metadata": {},
       "output_type": "display_data",
       "png": "iVBORw0KGgoAAAANSUhEUgAAAXEAAAEKCAYAAADkYmWmAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
       "text": [
        "<matplotlib.figure.Figure at 0x105c54350>"
       ]
      }
     ],
     "prompt_number": 18
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "**TASK: In the below cell, create a line plot of a sine wave. Plot it with a blue solid line.**\n",
      "\n",
      "*Advanced: If you find the above easy, also plot the above with a cosine wave (two lines on one plot). Using a green line with markers for the cosine line, and blue line for the sine line.*  "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "?sin    #Something to help you get started..."
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 42
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Finally, we can plot in a slightly more complex way, where we can have much more control over the elements of the plot:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "myfig = plt.figure()\n",
      "myfig.set_size_inches(5.0,3.0)     # Specify the output size exactly\n",
      "ax1 = myfig.add_subplot(111)        # Add an axis frame object to the plot (i.e. a pannel)\n",
      "\n",
      "ax1.plot(linspace(0, 10),linspace(0, 10),'ro',alpha=0.5)\n",
      "ax1.set_title('Title')\n",
      "ax1.set_xlabel('x-axis')\n",
      "ax1.set_ylabel('y-axis')\n",
      "ax1.grid(True)\n",
      "myfig.set_facecolor('yellow')\n",
      "myfig.text(0.4, 0.7, r\"My plot label\",fontsize=8,color='b')\n",
      "\n",
      "#myfig.set_tight_layout(True)\n",
      "plt.show(myfig)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "display_data",
       "png": "iVBORw0KGgoAAAANSUhEUgAAAUgAAADhCAYAAACqcCyhAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nksD/A+gME1WHvvNWAAAAAElFTkSuQmCC\n",
       "text": [
        "<matplotlib.figure.Figure at 0x10634d6d0>"
       ]
      }
     ],
     "prompt_number": 20
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Look through the gallery of http://matplotlib.org to get an idea of the things which MATPLOTLIB can do."
     ]
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "End of part 1"
     ]
    }
   ],
   "metadata": {}
  }
 ]
}