2_Introduction_to_Python.ipynb

{
 "metadata": {
  "name": "",
  "signature": "sha256:f0e33e633fbd2e3b3d29dde845a849df8c35dc07bb5a1fccf05a8d88d0aa1c20"
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "# A brief introduction to the language Python"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "\n",
      "[Python](http://www.python.org/) is a modern, general-purpose, object-oriented, high-level programming language. It is a **scripting** language in the sense that python code runs (i.e. each *expression* is *interpreted* in turn) into the python **interpreter**, there is no linking, no compilation: \n",
      "\n",
      "* Similar to ```ruby, perl, php, matlab, R,``` ...\n",
      "* Unlike ```C, C++, Java, Fortran```\n",
      "\n",
      "It is widely used in science and engineering, and has gain considerable traction in the domain of scientific computing over the past few years, some examples: \n",
      "\n",
      "+ The Bureau of Meteorology uses it to drive its hydrology prediction\n",
      "+ Python used at NASA for the Mars rover Curiosity mission \n",
      "+ Astronomy: \n",
      "\n",
      "> * The [Space Telescope Science Institute](http://www.stsci.edu/institute/software_hardware/pyraf/stsci_python) manages the operation of the Hubble Space Telescope with Python\n",
      "> * [yt](http://yt-project.org/): cosmological simulations:\n",
      "\n",
      "<div align=\"center\">\n",
      "![](http://yt-project.org/img/gallery/alma_natcov.jpg)\n",
      "</div>  \n",
      "<hr size=0>\n",
      "\n",
      "Some positive attributes of Python that are often cited: \n",
      "\n",
      "* **Simplicity**: It is easy to read and easy to learn, almost reads like pseudo-code in many instances\n",
      "* **Expressive**: Fewer lines of code, fewer bugs and easy to maintain.\n",
      "* **Powerful**: Python is not a language you grow out of. It can also be used for large projects, Big Data, High Performance Computing applications, etc.\n",
      "* **Batteries included**: The [**standard library**](http://docs.python.org/2/library/) is huge and includes some really cool libraries "
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "**the *philosophy* of Python **"
     ]
    },
    {
     "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": [
      "## Some elements of syntax"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### The basics"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "python scripts suffix ```.py``` \n",
      "\n",
      "Shebang line: \n",
      "\n",
      "    #!/usr/bin/env/python \n",
      "    \n",
      "or path to your python binary\n",
      "\n",
      "commented lines are marked by ```#```"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "In the following IPython notebook cell I'm writing the content of the cell to a file "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%%writefile print_upper.py \n",
      "#!/usr/bin/env python \n",
      "# This is a python script \n",
      "\n",
      "import sys # I import the sys module, part of the Python standard library\n",
      "\n",
      "X = sys.argv[1:] # reading the command line arguments, X is list\n",
      "\n",
      "X = \" \".join(map(str,X)) # transform everything into a string\n",
      "\n",
      "print(X.upper()) # printing the content, uppercase if applicable"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Overwriting print_upper.py\n"
       ]
      }
     ],
     "prompt_number": 3
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "!ls *.py "
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "load_style.py  print_upper.py some_module.py talktools.py\r\n"
       ]
      }
     ],
     "prompt_number": 4
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "!chmod +x print_upper.py # we make the file executable"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 5
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "!./print_upper.py something another thing 1 2 3"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "SOMETHING ANOTHER THING 1 2 3\r\n"
       ]
      }
     ],
     "prompt_number": 6
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "!python print_upper.py something another thing 1 2 3"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "SOMETHING ANOTHER THING 1 2 3\r\n"
       ]
      }
     ],
     "prompt_number": 7
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%run print_upper.py something another thing 1 2 3"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "SOMETHING ANOTHER THING 1 2 3\n"
       ]
      }
     ],
     "prompt_number": 8
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### Variable names "
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "a good idea is to use **meaningful** variable names in your scripts / notebooks "
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Can contain only letters, numbers and _ and must NOT begin by a number, also avoid Python reserved names"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "for = 1"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "ename": "SyntaxError",
       "evalue": "invalid syntax (<ipython-input-6-c8a8281ee30d>, line 1)",
       "output_type": "pyerr",
       "traceback": [
        "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-6-c8a8281ee30d>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    for = 1\u001b[0m\n\u001b[0m        ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
       ]
      }
     ],
     "prompt_number": 6
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### Operators \n",
      "\n",
      "Assignement operator is ```=```"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a = 5 "
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 7
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a * 2"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 8,
       "text": [
        "10"
       ]
      }
     ],
     "prompt_number": 8
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a += 2 # same as a = a + 2"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 9
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 10,
       "text": [
        "7"
       ]
      }
     ],
     "prompt_number": 10
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a -=2"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 11
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 12,
       "text": [
        "5"
       ]
      }
     ],
     "prompt_number": 12
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "** is used for exponentiation "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x = 2"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 13
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x**2"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 14,
       "text": [
        "4"
       ]
      }
     ],
     "prompt_number": 14
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "pow(x,2)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 15,
       "text": [
        "4"
       ]
      }
     ],
     "prompt_number": 15
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "**CAVEAT**: The case of integer division \n",
      "\n",
      "In python 2.7 the ratio of two integers is always an integer, the results are truncated towards 0 if the result \n",
      "is not an integer. "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "9 / 5"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 16,
       "text": [
        "1"
       ]
      }
     ],
     "prompt_number": 16
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "From Python 3 this behavior changes to what you would expect. To use the Python 3 behavior you need to include \n",
      "\n",
      "    from __future__ import division\n",
      "    \n",
      "at the top of your script / notebook before doing any calculations "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from __future__ import division "
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 17
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "9 / 5"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 18,
       "text": [
        "1.8"
       ]
      }
     ],
     "prompt_number": 18
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Types and Data structures"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### Floats"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x = 2.0 # can use 2. if you are lazy "
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 19
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "type(x)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 20,
       "text": [
        "float"
       ]
      }
     ],
     "prompt_number": 20
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x = float(2)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 21
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "type(x)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 22,
       "text": [
        "float"
       ]
      }
     ],
     "prompt_number": 22
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### Complex numbers "
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "can be created using the ```J``` notation or the ```complex``` function"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x = 2 + 3J"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 23
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print(type(x)); print(x)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "<type 'complex'>\n",
        "(2+3j)\n"
       ]
      }
     ],
     "prompt_number": 24
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x = complex(2, 3)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 25
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print(type(x)); print(x)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "<type 'complex'>\n",
        "(2+3j)\n"
       ]
      }
     ],
     "prompt_number": 26
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### Integers and ```Long``` integers"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x = 1"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 28
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "type(x)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 29,
       "text": [
        "int"
       ]
      }
     ],
     "prompt_number": 29
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x = int(1.2) ### will take the integer part "
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 31
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 32,
       "text": [
        "1"
       ]
      }
     ],
     "prompt_number": 32
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Normal integers can range from $-2^{31}$ to $2^{31}$, ```Long``` integers have NO range limitation. Note that Python converts ```ints``` to ```Long``` automatically if needed"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x = 1L"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 33
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "type(x)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 34,
       "text": [
        "long"
       ]
      }
     ],
     "prompt_number": 34
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x = 2**64"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 35
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "type(x)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 36,
       "text": [
        "long"
       ]
      }
     ],
     "prompt_number": 36
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 37,
       "text": [
        "18446744073709551616L"
       ]
      }
     ],
     "prompt_number": 37
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### Booleans "
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Used to represent ```True``` and ```False```. Usually they arise as the result of a logical operation"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x = True"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 38
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "type(x)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 39,
       "text": [
        "bool"
       ]
      }
     ],
     "prompt_number": 39
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x = 1"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 40
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x == 0"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 41,
       "text": [
        "False"
       ]
      }
     ],
     "prompt_number": 41
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "y = (x == 0); y"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 42,
       "text": [
        "False"
       ]
      }
     ],
     "prompt_number": 42
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x = [True, True, False, True]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 43
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "sum(x)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 44,
       "text": [
        "3"
       ]
      }
     ],
     "prompt_number": 44
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### Strings"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "You can define a string as any valid characters surrounded by single quotes"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "sentence = 'The Guide is definitive. Reality is frequently inaccurate.'; print(sentence)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "The Guide is definitive. Reality is frequently inaccurate.\n"
       ]
      }
     ],
     "prompt_number": 45
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Or double quotes "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "sentence = \"I'd take the awe of understanding over the awe of ignorance any day.\"; print(sentence)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "I'd take the awe of understanding over the awe of ignorance any day.\n"
       ]
      }
     ],
     "prompt_number": 46
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Or triple quotes "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "sentence = \"\"\"Time is an illusion.\n",
      "\n",
      "Lunchtime doubly so.\"\"\"; print(sentence)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Time is an illusion.\n",
        "\n",
        "Lunchtime doubly so.\n"
       ]
      }
     ],
     "prompt_number": 47
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "len(sentence) #!"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 48,
       "text": [
        "42"
       ]
      }
     ],
     "prompt_number": 48
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "And you can convert the types above (floats, complex, ints, Longs) to a string with the ```str``` function"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "str(complex(2,3))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 49,
       "text": [
        "'(2+3j)'"
       ]
      }
     ],
     "prompt_number": 49
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "####  A string is a python *iterable* \n",
      "\n",
      "You can INDEX a string variable, indexing in Python starts at 0 (not 1): the subscript refers to an **offset** from the starting position of an iterable, so the first element has an offset of zero\n",
      "\n",
      "If you want to know more follow [why python uses 0-based indexing](http://python-history.blogspot.co.nz/2013/10/why-python-uses-0-based-indexing.html)"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "sentence[0:4]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 50,
       "text": [
        "'Time'"
       ]
      }
     ],
     "prompt_number": 50
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "sentence[::-1]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 51,
       "text": [
        "'.os ylbuod emithcnuL\\n\\n.noisulli na si emiT'"
       ]
      }
     ],
     "prompt_number": 51
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "But it is **immutable**: You cannot change string elements in place"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "sentence[2] = \"blabla\""
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "ename": "TypeError",
       "evalue": "'str' object does not support item assignment",
       "output_type": "pyerr",
       "traceback": [
        "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m\n\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
        "\u001b[0;32m<ipython-input-52-50728921cb5d>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0msentence\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"blabla\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
        "\u001b[0;31mTypeError\u001b[0m: 'str' object does not support item assignment"
       ]
      }
     ],
     "prompt_number": 52
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "A lot of handy methods are available to manipulate strings"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print(sentence.upper())"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "TIME IS AN ILLUSION.\n",
        "\n",
        "LUNCHTIME DOUBLY SO.\n"
       ]
      }
     ],
     "prompt_number": 53
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "sentence.endswith('.')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 54,
       "text": [
        "True"
       ]
      }
     ],
     "prompt_number": 54
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "sentence.split() # by default split on whitespaces, returns a list (see below)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 55,
       "text": [
        "['Time', 'is', 'an', 'illusion.', 'Lunchtime', 'doubly', 'so.']"
       ]
      }
     ],
     "prompt_number": 55
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "#### String contenation and formatting"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "\"The answer is \" + \"42\""
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 56,
       "text": [
        "'The answer is 42'"
       ]
      }
     ],
     "prompt_number": 56
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "\";\".join([\"The answer is \",\"42\"]) # [\"The answer is \",\"42\"] is a list with two elements (separated by a ,)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 58,
       "text": [
        "'The answer is ;42'"
       ]
      }
     ],
     "prompt_number": 58
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a = 42"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 59
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "\"The answer is %s\" % ( a )"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 61,
       "text": [
        "'The answer is 42'"
       ]
      }
     ],
     "prompt_number": 61
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "\"The answer is %4.2f\" % ( a )"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 62,
       "text": [
        "'The answer is 42.00'"
       ]
      }
     ],
     "prompt_number": 62
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "\"The answer is {0:<6.4f}, {0:<6.4f} and not {1:<6.4f} \".format(a,42.0001)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 63,
       "text": [
        "'The answer is 42.0000, 42.0000 and not 42.0001 '"
       ]
      }
     ],
     "prompt_number": 63
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### Lists"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "int_list = [1,2,3,4,5,6]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 64
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "int_list"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 65,
       "text": [
        "[1, 2, 3, 4, 5, 6]"
       ]
      }
     ],
     "prompt_number": 65
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "str_list = ['thing', 'stuff', 'truc']"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 66
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "str_list"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 67,
       "text": [
        "['thing', 'stuff', 'truc']"
       ]
      }
     ],
     "prompt_number": 67
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "lists can contain anything"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "mixed_list = [1, 1., 2+3J, 'sentence', \"\"\"\n",
      "long sentence\n",
      "\"\"\"]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 68
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "mixed_list"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 69,
       "text": [
        "[1, 1.0, (2+3j), 'sentence', '\\nlong sentence\\n']"
       ]
      }
     ],
     "prompt_number": 69
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "type(mixed_list[0])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 70,
       "text": [
        "int"
       ]
      }
     ],
     "prompt_number": 70
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "#### Accessing elements and slicing lists "
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "```lists``` are iterable, their items (elements) can be accessed in a similar way as we saw for strings "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "int_list[0]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 72,
       "text": [
        "1"
       ]
      }
     ],
     "prompt_number": 72
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "int_list[1]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 73,
       "text": [
        "2"
       ]
      }
     ],
     "prompt_number": 73
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "int_list[::-1] ## same as int_list.reverse() but it is NOT operating in place"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 74,
       "text": [
        "[6, 5, 4, 3, 2, 1]"
       ]
      }
     ],
     "prompt_number": 74
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "int_list"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 75,
       "text": [
        "[1, 2, 3, 4, 5, 6]"
       ]
      }
     ],
     "prompt_number": 75
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "lists can be nested (list of lists)"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x = [[1,2,3],[4,5,6]]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 76
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x[0]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 77,
       "text": [
        "[1, 2, 3]"
       ]
      }
     ],
     "prompt_number": 77
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x[1]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 78,
       "text": [
        "[4, 5, 6]"
       ]
      }
     ],
     "prompt_number": 78
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x[0][1]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 80,
       "text": [
        "2"
       ]
      }
     ],
     "prompt_number": 80
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "```append``` is one of the most useful list methods"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "int_list.append(7); print(int_list)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[1, 2, 3, 4, 5, 6, 7]\n"
       ]
      }
     ],
     "prompt_number": 81
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "lists are mutable: you can change their elements in place "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "int_list[0] = 2; print(int_list)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[2, 2, 3, 4, 5, 6, 7]\n"
       ]
      }
     ],
     "prompt_number": 82
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "int_list.reverse() "
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 83
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "int_list ### ! list object methods are applied 'in place'"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 84,
       "text": [
        "[7, 6, 5, 4, 3, 2, 2]"
       ]
      }
     ],
     "prompt_number": 84
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "int_list.count(2)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 85,
       "text": [
        "2"
       ]
      }
     ],
     "prompt_number": 85
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### Tuples"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Tuples are also iterables, and they can be indexed and sliced like lists"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "int_tup = (1,2,3,5,6,7)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 86
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "int_tup[1:3]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 87,
       "text": [
        "(2, 3)"
       ]
      }
     ],
     "prompt_number": 87
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "int_tup.index(2)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 88,
       "text": [
        "1"
       ]
      }
     ],
     "prompt_number": 88
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "This construction is also possible"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "tup = 1,2,3"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 89
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "tup"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Tuples ARE NOT mutable, contrary to lists"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "int_tup[0] = 1"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "ename": "TypeError",
       "evalue": "'tuple' object does not support item assignment",
       "output_type": "pyerr",
       "traceback": [
        "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m\n\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
        "\u001b[0;32m<ipython-input-90-e1b3b1603cc4>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mint_tup\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
        "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
       ]
      }
     ],
     "prompt_number": 90
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "**Useful trick: ```zipping``` lists**"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a = range(5); print a"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[0, 1, 2, 3, 4]\n"
       ]
      }
     ],
     "prompt_number": 91
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "b = range(5,10); print b "
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[5, 6, 7, 8, 9]\n"
       ]
      }
     ],
     "prompt_number": 92
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a + b"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 93,
       "text": [
        "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
       ]
      }
     ],
     "prompt_number": 93
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "zip(a,b) # returns a list of tuples"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 94,
       "text": [
        "[(0, 5), (1, 6), (2, 7), (3, 8), (4, 9)]"
       ]
      }
     ],
     "prompt_number": 94
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### List comprehension ! \n",
      "\n",
      "List comprehensions are one of the most useful and compacts Python expressions, I'm introducing that here but we'll see more about control flow structures later. "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "str_list"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 95,
       "text": [
        "['thing', 'stuff', 'truc']"
       ]
      }
     ],
     "prompt_number": 95
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "['my ' + x for x in str_list]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 96,
       "text": [
        "['my thing', 'my stuff', 'my truc']"
       ]
      }
     ],
     "prompt_number": 96
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "[x.upper() for x in str_list]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 97,
       "text": [
        "['THING', 'STUFF', 'TRUC']"
       ]
      }
     ],
     "prompt_number": 97
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "[x+y for x,y in zip(a,b)] # using zip (above)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 98,
       "text": [
        "[5, 7, 9, 11, 13]"
       ]
      }
     ],
     "prompt_number": 98
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 99,
       "text": [
        "[0, 1, 2, 3, 4]"
       ]
      }
     ],
     "prompt_number": 99
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "[x + 6 if (x < 3) else x for x in a]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 100,
       "text": [
        "[6, 7, 8, 3, 4]"
       ]
      }
     ],
     "prompt_number": 100
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "#### Dictionnaries "
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "One of the more flexible built-in data structures is the dictionary. A dictionary maps a collection of values to a set of associated keys. These mappings are mutable, and unlike lists or tuples, are unordered. Hence, rather than using the sequence index to return elements of the collection, the corresponding key must be used. Dictionaries are specified by a comma-separated sequence of keys and values, which are separated in turn by colons. The dictionary is enclosed by curly braces. For example:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "my_dict = {'a':16, 'b':(4,5), 'foo':'''(noun) a term used as a universal substitute \n",
      "           for something real, especially when discussing technological ideas and \n",
      "           problems'''}\n",
      "my_dict"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 1,
       "text": [
        "{'a': 16,\n",
        " 'b': (4, 5),\n",
        " 'foo': '(noun) a term used as a universal substitute \\n           for something real, especially when discussing technological ideas and \\n           problems'}"
       ]
      }
     ],
     "prompt_number": 1
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "my_dict['b']\n",
      "(4, 5)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 2,
       "text": [
        "(4, 5)"
       ]
      }
     ],
     "prompt_number": 2
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "'a' in my_dict\t# Checks to see if \u2018a\u2019 is in my_dict"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "my_dict.has_key('bar')\t# Checks to see if a key exists"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 3,
       "text": [
        "False"
       ]
      }
     ],
     "prompt_number": 3
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "my_dict.items()\t\t# Returns key/value pairs as list of tuples"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 4,
       "text": [
        "[('a', 16),\n",
        " ('b', (4, 5)),\n",
        " ('foo',\n",
        "  '(noun) a term used as a universal substitute \\n           for something real, especially when discussing technological ideas and \\n           problems')]"
       ]
      }
     ],
     "prompt_number": 4
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "my_dict.keys()\t\t# Returns list of keys"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 5,
       "text": [
        "['a', 'b', 'foo']"
       ]
      }
     ],
     "prompt_number": 5
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "my_dict.values()\t# Returns list of values"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 6,
       "text": [
        "[16,\n",
        " (4, 5),\n",
        " '(noun) a term used as a universal substitute \\n           for something real, especially when discussing technological ideas and \\n           problems']"
       ]
      }
     ],
     "prompt_number": 6
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "my_dict['c']"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "ename": "KeyError",
       "evalue": "'c'",
       "output_type": "pyerr",
       "traceback": [
        "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m\n\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
        "\u001b[0;32m<ipython-input-7-0783a8759759>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmy_dict\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'c'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
        "\u001b[0;31mKeyError\u001b[0m: 'c'"
       ]
      }
     ],
     "prompt_number": 7
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "If we would rather not get the error, we can use the `get` method, which returns `None` if the value is not present, or a value of your choice"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "my_dict.get('c')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 8
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "my_dict.get('c', -1)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 10,
       "text": [
        "-1"
       ]
      }
     ],
     "prompt_number": 10
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Logical operators "
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Logical operators will **test** for some condition and return a boolean (True, False)"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "#### Comparison operators\n",
      "\n",
      "+ `>` : Greater than\n",
      "+ `>=` : Greater than or equal to\n",
      "+ `<` : Less than\n",
      "+ `<=` : Less than or equal to\n",
      "+ `==` : Equal to\n",
      "+ `!=` : Not equal to"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "**is / is not**\n",
      "\n",
      "Use **==** (**!=**) when comparing values and **is** (**is not**) when comparing **identities**."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x = 5."
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 12
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "type(x)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 13,
       "text": [
        "float"
       ]
      }
     ],
     "prompt_number": 13
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "y = 5"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 14
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "type(y)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 15,
       "text": [
        "int"
       ]
      }
     ],
     "prompt_number": 15
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x == y"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 16,
       "text": [
        "True"
       ]
      }
     ],
     "prompt_number": 16
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x is y # x is a float, y is a int, they point to different addresses in memory"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 17,
       "text": [
        "False"
       ]
      }
     ],
     "prompt_number": 17
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "#### Some examples of common comparisons"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a = 5\n",
      "b = 6"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 18
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a == b"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 19,
       "text": [
        "False"
       ]
      }
     ],
     "prompt_number": 19
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a != b"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 20,
       "text": [
        "True"
       ]
      }
     ],
     "prompt_number": 20
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "(a > 4) and (b < 7)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 21,
       "text": [
        "True"
       ]
      }
     ],
     "prompt_number": 21
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "(a > 4) and (b > 7)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 22,
       "text": [
        "False"
       ]
      }
     ],
     "prompt_number": 22
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "(a > 4) or (b > 7)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 23,
       "text": [
        "True"
       ]
      }
     ],
     "prompt_number": 23
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "**All** and **Any** can be used for a *collection* of booleans"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x = [5,6,2,3,3]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 24
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "cond = [item > 2 for item in x]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 25
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "cond"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 26,
       "text": [
        "[True, True, False, True, True]"
       ]
      }
     ],
     "prompt_number": 26
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "all(cond)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 27,
       "text": [
        "False"
       ]
      }
     ],
     "prompt_number": 27
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "any(cond)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 28,
       "text": [
        "True"
       ]
      }
     ],
     "prompt_number": 28
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Control flow structures"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "#### Indentation is meaningfull \n",
      "\n",
      "In Python, there are no annoying curly braces (I'm looking at you ```R```), parenthesis, brackets etc as in other languages  to delimitate flow control blocks, instead, the INDENTATION plays this role, which  **forces you** to write clear(er) code ..."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "for x in xrange(10): \n",
      "    if x < 5:\n",
      "        print x**2\n",
      "    else:\n",
      "        print x "
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "0\n",
        "1\n",
        "4\n",
        "9\n",
        "16\n",
        "5\n",
        "6\n",
        "7\n",
        "8\n",
        "9\n"
       ]
      }
     ],
     "prompt_number": 29
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "**Note**: The standard is to use 4 spaces (**NOT** tabs) for the indentation, set your favorite editor accordingly, for example in vi / vim: \n",
      "\n",
      "    set tabstop=4\n",
      "    set expandtab\n",
      "    set shiftwidth=4\n",
      "    set softtabstop=4\n"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "When editing a code cell in IPython, the indentation is handled intelligently, try typing in a new blank cell: \n",
      "\n",
      "    for x in xrange(10): \n",
      "        if x < 5:\n",
      "            print x**2\n",
      "        else:\n",
      "            print x \n",
      "            "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "for x in xrange(10):\n",
      "    if x < 5: \n",
      "        "
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "#### if ... elif ... else"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x = 10\n",
      "\n",
      "if x < 10: # not met\n",
      "    x = x + 1\n",
      "elif x > 10: \n",
      "    x = x - 1 # not met either \n",
      "else: \n",
      "    x = x * 2\n",
      "    \n",
      "print(x)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "20\n"
       ]
      }
     ],
     "prompt_number": 30
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x = 10\n",
      "\n",
      "if (x > 5 and x < 8): \n",
      "    x = x+1\n",
      "elif (x > 5 and x < 12): \n",
      "    x = x * 3\n",
      "else:\n",
      "    x = x-1\n",
      "    \n",
      "print(x)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "30\n"
       ]
      }
     ],
     "prompt_number": 31
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "#### The For loop "
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "\ufffcThe basic structure of FOR loops is \ufffc\n",
      "\n",
      "    for item in iterable: \n",
      "        expression(s)\n",
      "        "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "count = 0\n",
      "# x = range(1,10) # range creates a list ... \n",
      "# xrange is a convenience function, it creates an iterator rather than a list\n",
      "# which has a smaller memory footprint\n",
      "x = range(1,10) \n",
      "for i in x:\n",
      "    count += i\n",
      "    print(count)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1\n",
        "3\n",
        "6\n",
        "10\n",
        "15\n",
        "21\n",
        "28\n",
        "36\n",
        "45\n"
       ]
      }
     ],
     "prompt_number": 32
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "#### try ... except\n",
      "\n",
      "You can see it as a generalization of the ```if ... else``` construction, allowing more flexibility in handling failures in code"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "text = ('a','1','54.1','43.a')\n",
      "for t in text:\n",
      "    try:\n",
      "        temp = float(t)\n",
      "        print(temp)\n",
      "    except ValueError:\n",
      "        print(str(t) + ' is Not convertible to a float')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "A list of built-in exceptions is available here \n",
      "\n",
      "[http://docs.python.org/3.1/library/exceptions.html](http://docs.python.org/3.1/library/exceptions.html)"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Recycling code in Python\n",
      "\n",
      "As with Matlab and R, it's a good idea to write **functions** for bits of code that you use often. \n",
      "\n",
      "The syntax for defining a function in Python is: \n",
      "\n",
      "    def name_of_function(arguments): \n",
      "        \"Some code here that works on arguments and produces outputs\"\n",
      "        ...\n",
      "        return outputs\n",
      "\n",
      "Note that the execution block **must be indented** ... \n",
      "\n",
      "Unlike Matlab, you can create a file (a **module**: extension .py required) which contains **several** functions, and can also define variables, and import some other functions from other modules"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%%file some_module.py \n",
      "\n",
      "PI = 3.14159 # defining a variable\n",
      "\n",
      "from numpy import arccos # importing a function from another module\n",
      "\n",
      "def f(x): \n",
      "    \"\"\"\n",
      "    This is a function which adds 5 to its argument\n",
      "     \n",
      "    \"\"\"\n",
      "    return x + 5\n",
      "\n",
      "def g(x, y): \n",
      "    \"\"\"\n",
      "    This is a function which sums its 2 arguments\n",
      "    \"\"\"\n",
      "    return x + y"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Writing some_module.py\n"
       ]
      }
     ],
     "prompt_number": 33
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import some_module"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 34
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%whos"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Variable      Type      Data/Info\n",
        "---------------------------------\n",
        "a             int       5\n",
        "b             int       6\n",
        "cond          list      n=5\n",
        "count         int       45\n",
        "i             int       9\n",
        "item          int       3\n",
        "my_dict       dict      n=3\n",
        "some_module   module    <module 'some_module' from 'some_module.py'>\n",
        "x             list      n=9\n",
        "y             int       5\n"
       ]
      }
     ],
     "prompt_number": 35
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "dir(some_module)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 36,
       "text": [
        "['PI',\n",
        " '__builtins__',\n",
        " '__doc__',\n",
        " '__file__',\n",
        " '__name__',\n",
        " '__package__',\n",
        " 'arccos',\n",
        " 'f',\n",
        " 'g']"
       ]
      }
     ],
     "prompt_number": 36
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "help(some_module)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Help on module some_module:\n",
        "\n",
        "NAME\n",
        "    some_module\n",
        "\n",
        "FILE\n",
        "    /Users/nicolasfauchereau/NIWA_python_seminars/NIWA_Python_seminars/some_module.py\n",
        "\n",
        "FUNCTIONS\n",
        "    f(x)\n",
        "        This is a function which adds 5 to its argument\n",
        "    \n",
        "    g(x, y)\n",
        "        This is a function which sums its 2 arguments\n",
        "\n",
        "DATA\n",
        "    PI = 3.14159\n",
        "    arccos = <ufunc 'arccos'>\n",
        "\n",
        "\n"
       ]
      }
     ],
     "prompt_number": 37
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "some_module.PI"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 38,
       "text": [
        "3.14159"
       ]
      }
     ],
     "prompt_number": 38
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "some_module.arccos?"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 39
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "some_module.f(7)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 40,
       "text": [
        "12"
       ]
      }
     ],
     "prompt_number": 40
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "help(some_module.f)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Help on function f in module some_module:\n",
        "\n",
        "f(x)\n",
        "    This is a function which adds 5 to its argument\n",
        "\n"
       ]
      }
     ],
     "prompt_number": 41
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from some_module import f"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 42
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "f(5)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 43,
       "text": [
        "10"
       ]
      }
     ],
     "prompt_number": 43
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import some_module as sm"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 44
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "sm.f(10)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 45,
       "text": [
        "15"
       ]
      }
     ],
     "prompt_number": 45
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The Zen of python says: \n",
      "    \n",
      "```Namespaces are one honking great idea -- let's do more of those!```\n",
      "    \n",
      "so **don't** do: \n",
      "\n",
      "    from some_module import *\n",
      "    \n",
      "As to avoid names conflicts ..."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "#### a bit more on functions: \n",
      "\n",
      "Functions can have **positional** as well as **keyword** arguments (with defaults, can be `None` if that's allowed / tested)\n",
      "\n",
      "positional arguments must always come before keyword arguments"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def some_function(a,b,c=5,d=1e3): \n",
      "    res = (a + b) * c * d\n",
      "    return res"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 46
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "some_function(2,3)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 47,
       "text": [
        "25000.0"
       ]
      }
     ],
     "prompt_number": 47
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "some_function(2, 3, c=5, d=0.01)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 48,
       "text": [
        "0.25"
       ]
      }
     ],
     "prompt_number": 48
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "you can return more than one output, by default will be a tuple"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def some_function(a, b): \n",
      "    return a+1, b+1, a*b"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 49
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a,b,c = some_function(2,3)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 53
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "c"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 56,
       "text": [
        "6"
       ]
      }
     ],
     "prompt_number": 56
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "type(res)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 52,
       "text": [
        "tuple"
       ]
      }
     ],
     "prompt_number": 52
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "<hr size=5>\n",
      "styling"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%load_ext load_style"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 1
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%load_style talk.css"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "html": [
        "<style>\n",
        "\n",
        ".rendered_html {\n",
        "    font-family: \"proxima-nova\", helvetica;\n",
        "    font-size: 130%;\n",
        "    line-height: 1.5;\n",
        "}\n",
        "\n",
        ".rendered_html h1 {\n",
        "    margin: 0.25em 0em 0.5em;\n",
        "    color: #015C9C;\n",
        "    text-align: center;\n",
        "    line-height: 1.2; \n",
        "    page-break-before: always;\n",
        "}\n",
        "\n",
        ".rendered_html h2 {\n",
        "    margin: 1.1em 0em 0.5em;\n",
        "    color: #26465D;\n",
        "    line-height: 1.2;\n",
        "}\n",
        "\n",
        ".rendered_html h3 {\n",
        "    margin: 1.1em 0em 0.5em;\n",
        "    color: #002845;\n",
        "    line-height: 1.2;\n",
        "}\n",
        "\n",
        ".rendered_html li {\n",
        "    line-height: 1.5; \n",
        "}\n",
        "\n",
        "/*.prompt {\n",
        "    font-size: 120%; \n",
        "}*/\n",
        "\n",
        ".CodeMirror-lines {\n",
        "    font-size: 110%; \n",
        "}\n",
        "\n",
        "/*.output_area {\n",
        "    font-size: 120%; \n",
        "}*/\n",
        "\n",
        "/*#notebook {\n",
        "    background-image: url('files/images/witewall_3.png');\n",
        "}*/\n",
        "\n",
        "h1.bigtitle {\n",
        "    margin: 4cm 1cm 4cm 1cm;\n",
        "    font-size: 300%;\n",
        "}\n",
        "\n",
        "h3.point {\n",
        "    font-size: 200%;\n",
        "    text-align: center;\n",
        "    margin: 2em 0em 2em 0em;\n",
        "    #26465D\n",
        "}\n",
        "\n",
        ".logo {\n",
        "    margin: 20px 0 20px 0;\n",
        "}\n",
        "\n",
        "a.anchor-link {\n",
        "    display: none;\n",
        "}\n",
        "\n",
        "h1.title { \n",
        "    font-size: 250%;\n",
        "}\n",
        "\n",
        "</style>"
       ],
       "metadata": {},
       "output_type": "display_data",
       "text": [
        "<IPython.core.display.HTML at 0x104d0af50>"
       ]
      }
     ],
     "prompt_number": 3
    }
   ],
   "metadata": {}
  }
 ]
}