Chapter 2 - Collections.ipynb

{
 "metadata": {
  "name": ""
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "heading",
     "level": 1,
     "metadata": {},
     "source": [
      "Chapter 2: Collections"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "-- *A Python Course for the Humanities by Folgert Karsdorp and Maarten van Gompel, with modifications by Mike Kestemont and Lars Wieneke*"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "-------------------------------"
     ]
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Lists"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Consider the sentence below:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "sentence = \"Python's name is derived from the television series Monty Python's Flying Circus.\""
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Words are made up of characters, and so are strings in Python, like the string stored in the variable `sentence` in the block above. For the sentence above, it might seem more natural for humans to describe it as a series of words, rather than as a series of characters. Say we want to access the first word in our sentence. If we type in:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "first_word = sentence[0]\n",
      "print(first_word)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Python only prints the first *character* of our sentence. (Think about this if you do not understand why.) We can transform our sentence into a `list` of words (represented by strings) using the `split()` function as follows: "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "words = sentence.split()\n",
      "print(words)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Make sure that you understand the syntax of this code! We call things like `split()` 'functions': functions provide small pieces of helpful, ready-made functionality that we can use in our own code. Here, we apply the `split()` function to the variable `sentence` and we assign the result of the function (we call this the 'return value' of the function) to the new variable `words`.\n",
      "\n",
      "By default, the split() function in Python will split strings on the spaces between consecutive words and it will returns a list of words. However, we can pass an argument to `split()` that specifies explicitly the string we would like to split on. In the code block below, we will split a string on commas, instead of spaces. Do you get the syntax?"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "fruitstring = \"banana,pear,apple\"\n",
      "fruitlist = fruitstring.split(\",\")\n",
      "print(fruitlist)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The reverse of the `split()` function can be accomplished with `join()`, it turns a list into a string, with a specific 'delimiter' or the string you want to use to join the items."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "fruitlist = ['banana', 'pear', 'apple']\n",
      "delimiter = \",\"\n",
      "fruitstring = delimiter.join(fruitlist)\n",
      "print(fruitstring)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The above four lines can be accomplished in a single line if code, can you figure out how? (Tip: replace all variables by their values)"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# insert your oneliner here!"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "---"
     ]
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "replace()"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The `replace()` function is another function which can be called on a string. It will replace all occurrences of a specified substring with another string. Consider the lines in the code block below - and mind the order in which you pass the arguments to the function!\n",
      "\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "text = \"You can not compare apples and pears\"\n",
      "text = text.replace(\"pears\", \"apples\")\n",
      "text = text.replace(\"not \", \"\")\n",
      "print(text)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "##DIY"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "text = \"Research has shown that it is often still possible to understand text even if all vowels are removed\"\n",
      "# insert your code here.. I suppose it's obvious what we want you to do ;-)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Python has two functions for changing the case of a string. `lower()` converts a string to lowercase characters and `upper()` returns an uppercased version:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "my_string = \"AllCaps\"\n",
      "my_string_upper = my_string.upper()\n",
      "print(my_string_upper)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "---"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "##DIY"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "-  Can you come up with your own sentence `my_sentence` and split it into words along spaces? Print the new list of words.\n",
      "-  You can recognize functions because they are always followed by (round brackets). Apart from the `split()` function, we already encountered other functions, also in the previous chapter. Which ones? Can you describe their functionality? Are there any differences in terms of syntax when you compare these to `split()`?\n",
      "-  Is there a difference in length between the variables `sentence` and `words`? (Use functions to find this out!)"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# your DIY code goes here..."
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "In many ways, list variables are very similar to strings. We can for example access its components using indexes and we can use slice indexes to access parts of the list. Let's try this out.\n",
      "\n",
      "Write a small program that defines a variable `first_word` and assign to it the first word of our word list `words` from above. Do the same for the fifth word, the last word and the last but one word. Also, try to extract a slice from `words` and isolate the string of words between `derived` and `Flying` (the slice should not include `derived` and `Flying`). Also, make a slice of words that is identical to the title of the television series in `words`.   "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# insert your code here"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "A `list` acts like some kind of container where we can store all kinds of information. We can access a list using indexes and slices. We can also add new items to a list. For that you use the function `append()`. Let's see how that works. Say we want to keep a list of all our good reads. We first declare an empty list using square brackets ([]). Next, we add some good books to the list:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# start with an empty list\n",
      "good_reads = []\n",
      "good_reads.append(\"The Hunger games\")\n",
      "print(good_reads)\n",
      "good_reads.append(\"A Clockwork Orange\")\n",
      "print(good_reads)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Do you get the syntax that goes with the `append()` function? The list we wish to append the item to goes first and we join the append() function to this list using a dot (`.`). In between the round brackets that go with the function name, we place the actual string that we wish to add to the list. We call such a input value an 'argument' or a 'parameter' that we 'pass' to a function. Next, the function will return a 'return value'. Make sure that you are familiar with this terminology because you will often come across such terms when you look for help online!\n",
      "\n",
      "Now, if for some reason we don't like a particular book anymore, we can change it as follows using the old item's index:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "good_reads[0] = \"Pride and Prejudice\"\n",
      "print(good_reads)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "As you see, it is no problem to reset or update an individual item in a list. This is different, however, for strings. Run the following code in which we try to change a single character in a string. This will raise an error: this is your computer signalling that something is wrong. This is because `strings` (and some other types) are *immutable*. That means that they cannot be changed using the index, as opposed to `list`s which *are* mutable."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "name = \"Bonny\"\n",
      "print(name)\n",
      "list_chars = list(name)\n",
      "print(list_chars)\n",
      "list_chars[3] = \"t\"\n",
      "print(list_chars)\n",
      "delimiter = \"\"\n",
      "print(delimiter.join(list_chars))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "##DYI"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Here's another small DIY! Add two new titles to the list of `good_reads`. Then, try to change the title of the second book in our good reads collection:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# insert your code here\n",
      "print(good_reads)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Lists are a really powerful way of dealing with your data in Python. Let's explore some other ways in which we can manipulate lists."
     ]
    },
    {
     "cell_type": "heading",
     "level": 4,
     "metadata": {},
     "source": [
      "remove()"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Let's assume our good read collection has grown a lot and we would like to remove some of the books from the list. Python provides the function `remove()` that you can call on a list and which takes as argument the item we would like to remove. "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "good_reads = [\"The Hunger games\", \"A Clockwork Orange\", \n",
      "             \"Pride and Prejudice\", \"Water for Elephants\", \"Illias\"]\n",
      "print(good_reads)\n",
      "good_reads.remove(\"Water for Elephants\")\n",
      "print(good_reads)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "If we try to remove a book that is not in our collection, Python raises an error to signal that something is wrong."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "good_reads.remove(\"White Oleander\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Note, however, that `remove()` will only delete the *first* item in the list that is identical to the argument which you passed to the function. Execute the code in the block below and you will see that only the first instance of \"Pride and Prejudice\" gets deleted."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "good_reads = [\"The Hunger games\", \"A Clockwork Orange\", \n",
      "             \"Pride and Prejudice\", \"Water for Elephants\", \"Pride and Prejudice\"]\n",
      "good_reads.remove(\"Pride and Prejudice\")\n",
      "print(good_reads)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Just as with strings, we can concatenate two lists using the `+` operator. Here is an example:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# first we specify two lists of strings:\n",
      "good_reads = [\"The Hunger games\", \"A Clockwork Orange\", \n",
      "              \"Pride and Prejudice\", \"Water for Elephants\",\n",
      "              \"The Shadow of the Wind\", \"Bel Canto\"]\n",
      "bad_reads = [\"Fifty Shades of Grey\", \"Twilight\"]\n",
      "\n",
      "# then we combine them\n",
      "all_reads = good_reads + bad_reads\n",
      "print(all_reads)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 4,
     "metadata": {},
     "source": [
      "sort()"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "It is always nice to organise your bookshelf. We can sort our collection alphabetically with the following expression:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "good_reads.sort()\n",
      "print(good_reads)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 4,
     "metadata": {},
     "source": [
      "nested lists"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Until now our lists only consisted of strings. However, a list can contain all kinds of data types, such as integers and even lists! Do you understand what is happening in the following example? Have a close look at the square brackets used."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "nested_list = [[1, 2, 3, 4], [5, 6, 7, 8]]\n",
      "print(nested_list[0])\n",
      "print(nested_list[0][0])\n",
      "print(nested_list[1][2])\n",
      "print(nested_list[0][:-2])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "We can put this to use to enhance our good read collection with a score for every book we have. An entry in our collection will consist of a score within the range of `1` and `10` and the title of our book. The first element is the title; the second the score `[title, score]`. We initialize an empty list:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "good_reads = []"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "And add two books to it:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "good_reads.append([\"Pride and Prejudice\", 8])\n",
      "good_reads.append([\"A Clockwork Orange\", 9])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "##DIY"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Update the `good_reads` collection with some of your own books and give them all a score and a publication year. Can you print out the score you gave to the first book in the list? And the publication year of the third item in your list? (Hint: you can pile up indexes using square brackets!)"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# insert your code here"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 5,
     "metadata": {},
     "source": [
      "What we have learnt"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "To finish this section, here is an overview of the new concepts you have learnt. Go through them and make sure you understand them all.\n",
      "\n",
      "-  lists\n",
      "-  nested lists\n",
      "-  *mutable* versus *immutable*\n",
      "-  `.split()` vs. `.join()`\n",
      "-  `.append()`\n",
      "-  `.remove()`\n",
      "-  `.sort()`\n",
      "-  `.upper()` vs. `.lower()`"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "-------------"
     ]
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Dictionaries"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Our little good reads collection is starting to look quite impressive and we can perform all kinds of manipulations on it. Now, imagine that our list is large and we would like to look up the score we gave to a particular book. How are we going to find that book? For this purpose Python provides another more appropriate data structure, named `dictionary`. A `dictionary` is similar to the dictionaries you have at home. It consists of entries, or keys, that hold a value. Let's define one:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "my_dict = {\"book\": \"physical objects consisting of a number of pages bound together\",\n",
      "           \"sword\": \"a cutting or thrusting weapon that has a long metal blade\",\n",
      "           \"pie\": \"dish baked in pastry-lined pan often with a pastry top\"}"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Take a close look at the new syntax. Notice the curly brackets and the colons. To look up the value of a given key, we `index' the dictionary using that key (again, between square brackets):"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "description = my_dict[\"sword\"]\n",
      "print(description)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Like lists, dictionaries are mutable which means we can add and remove entries from it. Let's define an empty dictionary and add some books to it. The titles will be our keys and the scores their values. Watch the syntax to add a new entry:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "good_reads = {}\n",
      "good_reads[\"Pride and Prejudice\"] = 8\n",
      "good_reads[\"A Clockwork Orange\"] = 9\n",
      "print(good_reads[\"Pride and Prejudice\"])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "In a way, this is similar to what we have seen before when we altered our book `list`. There we indexed the list using a integer to access a particular book. Here we directly use the title of the book. Note that the keys in a dictionary must be unique: why would that be?"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "##DIY"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Update the new good reads datastructure with your own books. Try to print out the score your gave for one of the books which you added."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# put your code here"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 4,
     "metadata": {},
     "source": [
      "keys(), values()"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "To retrieve a list of all the books we have in our collection, we can ask the dictionary to return its keys as a list:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print(my_books.keys())"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Similarly we can ask for the values:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print(my_books.values())"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 5,
     "metadata": {},
     "source": [
      "What we have learnt"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "To finish this section, here is an overview of the new concepts and functions you have learnt. Make sure you understand them all.\n",
      "\n",
      "-  dictionary\n",
      "-  indexing dictionaries and accessing values through their keys\n",
      "-  adding items to a dictionary\n",
      "-  `.keys()`\n",
      "-  `.values()`"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "##Final Exercises Chapter 2"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Inspired by *Think Python* by Allen B. Downey (http://thinkpython.com), *Introduction to Programming Using Python* by Y. Liang (Pearson, 2013). Some exercises below have been taken from: http://www.ling.gu.se/~lager/python_exercises.html."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "- Ex. 1: Consider the following strings `sentence1 = \"Mike and Lars kick the bucket\"` and `sentence2 = \"Bonny and Clyde are really famous\"`. Split these strings into words and create the following strings via list manipulation: `sentence3 = \"Mike and Lars are really famous\"` and `sentence4=\"Bonny+and+Clyde+kick+the+bucket\"` (mind the plus signs!). Can you print the middle letter of the fourth sentence?"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# sentences"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "-  Ex. 2: Consider the `lookup` dictionary below. The following letters are still missing from it: 'k':'kilo', 'l':'lima', 'm':'mike'. Add them to `lookup`! Could you spell the word \"marvellous\" in code language now? Collect these codes into the list object `msg`. Next, join the items in this list together with a comma and print the spelled out version!\n",
      "\n",
      "> lookup = {'a':'alfa', 'b':'bravo', 'c':'charlie', 'd':'delta', 'e':'echo', 'f':'foxtrot', 'g':'golf', 'h':'hotel', 'i':'india', 'j':'juliett', 'n':'november', 'o':'oscar', 'p':'papa', 'q':'quebec', 'r':'romeo', 's':'sierra', 't':'tango', 'u':'uniform', 'v':'victor', 'w':'whiskey', 'x':'x-ray', 'y':'yankee', 'z':'zulu'}\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# lookup code"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "-  Ex. 3: Collect the code terms in the lookup dict (`alpha`, `bravo`, ...) from the previous exercise into a list called `code_words`. Is this list alphabetically sorted? No? Then make sure that this list is sorted alphabetically. Now remove the items `victor`, `india` and `papa`. Append the words `pigeon` and `potato` at the end of this list. Combine this new list of items into a single string, using a semicolon as a delimiter and print this string. "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# follow-up lookup code"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "-----------------------------------------------------------------\n",
      "\n",
      "You've reached the end of Chapter 2! Ignore the code block below -- it's only there to make the page prettier."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from IPython.core.display import HTML\n",
      "def css_styling():\n",
      "    styles = open(\"styles/custom.css\", \"r\").read()\n",
      "    return HTML(styles)\n",
      "css_styling()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "html": [
        "<style>\n",
        "    @font-face {\n",
        "        font-family: \"Computer Modern\";\n",
        "        src: url('http://mirrors.ctan.org/fonts/cm-unicode/fonts/otf/cmunss.otf');\n",
        "    }\n",
        "    div.cell {\n",
        "        width:800px;\n",
        "        margin-left:auto;\n",
        "        margin-right:auto;\n",
        "    }\n",
        "    div.cell, .input.hbox {\n",
        "    display:block;\n",
        "}\n",
        "    h1 {\n",
        "        font-family: \"Charis SIL\", Palatino, serif;\n",
        "    }\n",
        "    h4{\n",
        "        margin-top:12px;\n",
        "        margin-bottom: 3px;\n",
        "       }\n",
        "    div.text_cell_render{\n",
        "        font-family: Computer Modern, \"Helvetica Neue\", Arial, Helvetica, Geneva, sans-serif;\n",
        "        line-height: 145%;\n",
        "        font-size: 120%;\n",
        "        width:800px;\n",
        "        margin-left:auto;\n",
        "        margin-right:auto;\n",
        "    }\n",
        "    .CodeMirror{\n",
        "            font-family: \"Source Code Pro\", source-code-pro,Consolas, monospace;\n",
        "    }\n",
        "    .prompt{\n",
        "        display: None;\n",
        "    }\n",
        "    .text_cell_render h5 {\n",
        "        font-weight: 300;\n",
        "        font-size: 16pt;\n",
        "        color: #4057A1;\n",
        "        font-style: italic;\n",
        "        margin-bottom: .5em;\n",
        "        margin-top: 0.5em;\n",
        "        display: block;\n",
        "    }\n",
        "    \n",
        "    .warning{\n",
        "        color: rgb( 240, 20, 20 )\n",
        "        }\n",
        "\n",
        "    blockquote {\n",
        "    border-left: 4px solid #DDDDDD;\n",
        "    color: #777777;\n",
        "        padding: 0 15px;\n",
        "        }\n",
        "\n",
        "</style>\n",
        "<script>\n",
        "    MathJax.Hub.Config({\n",
        "                        TeX: {\n",
        "                           extensions: [\"AMSmath.js\"]\n",
        "                           },\n",
        "                tex2jax: {\n",
        "                    inlineMath: [ ['$','$'], [\"\\\\(\",\"\\\\)\"] ],\n",
        "                    displayMath: [ ['$$','$$'], [\"\\\\[\",\"\\\\]\"] ]\n",
        "                },\n",
        "                displayAlign: 'center', // Change this to 'center' to center equations.\n",
        "                \"HTML-CSS\": {\n",
        "                    styles: {'.MathJax_Display': {\"margin\": 4}}\n",
        "                }\n",
        "        });\n",
        "</script>"
       ],
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 1,
       "text": [
        "<IPython.core.display.HTML at 0x5852930>"
       ]
      }
     ],
     "prompt_number": 1
    }
   ],
   "metadata": {}
  }
 ]
}