Chapter 4 - Loops.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Chapter 4: Loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In programming, it is often very useful do carry out a the same action for a series of different items. You might, for instance, want to go through a list of words and count and print the number of characters in each word. Now, you *could* do this for each word individually and access every word, one item at a time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "my_fruits = [\"apple\", \"pear\", \"peach\", \"banana\", \"peach\", \"cherry\", \"orange\", \"kiwi\"]\n",
    "print(len(my_fruits[0]))\n",
    "print(len(my_fruits[1]))\n",
    "print(len(my_fruits[2]))\n",
    "# and so on...\n",
    "print(len(my_fruits[-2]))\n",
    "print(len(my_fruits[-1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Needless to say, this is rather cumbersome. Luckily, Python provides the so-called `for`-statements for this. The `for` loop allows us to iterate through any iteratable object, such as a list, and do the same thing with each of its elements. The basic format of a `for`-statement is: \n",
    "\n",
    "    for a_single_item in an_iterable_something:\n",
    "        do_something_with(a_single_item)\n",
    "\n",
    "That almost reads like English. We can print all letters of the word *banana* as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "for letter in \"banana\":\n",
    "    print(letter)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The code in the loop is executed as many times as their are letters, with a different value for the variable `letter` at each iteration. (Read the previous sentence again, until you fully understand it.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Likewise, we can print all the items that are contained in a list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "colors = [\"yellow\", \"red\", \"green\", \"blue\", \"purple\"]\n",
    "for color in colors:\n",
    "    print(color)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since dictionaries are iterable objects as well, we can iterate through our good reads collection as well. This will iterate over the *keys* of a dictionary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "for book in good_reads:\n",
    "    print(book)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## DIY"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function `len()` returns the length of an iterable item:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "len(\"banana\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- We can use this function to print the length of each word in the color list. Write your code in the box below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "colors = [\"yellow\", \"red\", \"green\", \"blue\", \"purple\"]\n",
    "# insert your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Now write a small program that iterates through the list `colors` and `appends` all colors that contain the letter *r* to the list `colors_with_r`. (Tip: use the `append()` function!)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "colors = [\"yellow\", \"red\", \"green\", \"blue\", \"purple\"]\n",
    "colors_with_r = []\n",
    "# insert you code here\n",
    "\n",
    "for color in colors:\n",
    "    l = len(color)\n",
    "    colors_with_r.append(l)\n",
    "    print(colors_with_r)    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "--------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## DIY"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have already covered a lot of ground. Now it is time to put some of the things that we have learned together. The following quiz might be quite hard and we would be very impressed if you get it right! \n",
    "\n",
    "What we want you to do is write code that counts how often the letter *a* occurs in a text. You cannot do this, however, on the basis of the text itself. Instead, you need to do this on the basis of a frequency dictionary of the test. In this dictionary `frequency_dictionary`, keys are words and values are the frequencies. Assign your value to the variable `number_of_words_as`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "frequency_dictionary = {\"Beg\": 1, \"Goddard's\": 1, \"I\": 3, \"them\": 2, \"absent\": 1, \"already\": 1,\n",
    "                          \"alteration\": 1, \"amazement\": 2, \"appeared\": 1, \"apprehensively\": 1, \n",
    "                          \"associations\": 1, 'clever': 1, 'clock': 1, 'composedly': 1, \n",
    "                          'deeply': 7, 'do': 7, 'encouragement': 1, 'entrapped': 1,\n",
    "                          'expressed': 1, 'flatterers': 1, 'following': 12, 'gone': 9, \n",
    "                          'happening': 4, 'hero': 2, 'housekeeper': 1, 'ingratitude': 1, \n",
    "                          'like': 1, 'marriage': 15, 'not': 25, 'opportunities': 1,\n",
    "                          'outgrown': 1, 'playfully': 2, 'remain': 1, 'required': 2, \n",
    "                          'ripening': 1, 'slippery': 1, 'touch': 1, 'twenty-five': 1,\n",
    "                          'ungracious': 2, 'unwell': 1, 'verses': 1, 'yards': 5}\n",
    "number_of_as = 0\n",
    "print(number_of_as != 0)\n",
    "\n",
    "\n",
    "# insert your code here\n",
    "\n",
    "for word in frequency_dictionary:\n",
    "    if 'a' in word:\n",
    "        cnt = 0\n",
    "        for character in word:\n",
    "            if character == 'a':\n",
    "                cnt += 1\n",
    "        freq = frequency_dictionary[word]\n",
    "        number_of_as += freq*cnt\n",
    "        \n",
    "\n",
    "print(number_of_as)\n",
    "\n",
    "# if your code is correct, the following line should print True!\n",
    "#print(number_of_as == 42)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### while loop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is also another form of looping in Python: the `while` loop. This is a loop that is tied to a logical expression. A `while` loop will run as long the specified expression is evaluated to be `True`. Check out the following example to see how this works:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "number = 5\n",
    "while number < 21:\n",
    "    number += 3\n",
    "    print(number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### What we have learned"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is an overview of the new concepts, statements and functions we have learned in this section. Again, go through the list and make sure you understand them all.\n",
    "\n",
    "-  loop\n",
    "-  `for` statement\n",
    "-  `while` statement\n",
    "-  iterable objects\n",
    "-  variable assignment in a `for` loop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iterables, Iteration & Loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuples & Sets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists and dictionaries are hugely important data structures and you will see a lot of them. They are almost always combined with the power of iteration using either **for** loops or other methods.\n",
    "\n",
    "In addition to these data structures, there are two others which should be mentioned, these are *tuples* and *sets*. Lists, sets, tuples, dictionaries and even strings are often called *iterables*, as they are all collections over which can be iterated. \n",
    "\n",
    "Tuples are ordered collections like lists, but they are *immutable*. Once created, nothing can be added, inserted, deleted or substituted. The main advantage is that they can be faster than lists, which is interesting if you have to process a lot of data. The syntax for creating a tuple involves round brackets `()`. For example:\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "fruittuple = ('banana','apple','pear')\n",
    "print(fruittuple)\n",
    "print(fruittuple[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Does notice a difference between the way Python prints lists, and the way it prints tuples to your screen? The following would have worked for lists, but does not for tuples (nor strings as we have seen before):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#fruittuple[0] = 'orange' # will raise an error, tuples are immutable!\n",
    "for fruit in fruittuple:\n",
    "    print(fruit)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A set is an **unordered** data collection in which an each element can only occur once, elements can be appended or deleted. It is unordered so this implies that you never really know in what order you get the elements when you iterate over the set. The syntax for creating a set is `{}`. This is not to be confused with dictionaries, those take `key: value`  pairs where sets just take single elements.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "fruitset = {'banana', 'apple', 'pear'}\n",
    "fruitset.add('banana') # will have no effect, banana already exists\n",
    "print(fruitset)\n",
    "fruitset.add('orange')\n",
    "print(fruitset)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the order of the elements maybe different from the order you initialised the `fruitset`. This is because order has no meaning in the context of sets and neither in that of dictionaries.\n",
    "\n",
    "In the previous chapter you learnt how to convert strings that contains numbers to integers, and how to turn integers and floats to strings. Such a kind of type casting can also be done for iterables, allowing you to turn almost any iterable into any other. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "fruitlist = ['banana', 'apple', 'pear', 'banana', 'pear', 'kiwi']\n",
    "fruitset = set(fruitlist)\n",
    "print(fruitset)\n",
    "\n",
    "for fruit in fruitset:\n",
    "    print(fruit)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### sorted() and reverse()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Often you want to iterate over your data in a sorted manner. The `sorted()` function will take any iterable and return the elements in sorted order. For strings this is alphabetical order, for numbers this is numerical order.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "fruits = ['banana', 'apple', 'pear']\n",
    "for fruit in sorted(fruits):\n",
    "    print(fruit)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Reverse order is also possible by using `reversed()`, which simply returns the elements in any iterable in reverse order:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "for fruit in reversed(fruits):\n",
    "    print(fruit)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### DIY"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Given a list of words, output only the ones that are palindromes. As you know, a palindrome is a word that does not change when read backwards. If you need an extra challenge, try to print the palindromes in alphabetic order!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "words = ['bicycle', 'radar', 'origin', 'tie', 'level', 'poop', 'solar', 'nun']\n",
    "# insert your code here\n",
    "\n",
    "palindromes = []\n",
    "\n",
    "for original_word in words:\n",
    "    reversed_word = ''\n",
    "    for character in reversed(original_word):\n",
    "        reversed_word += character\n",
    "    if original_word == reversed_word:\n",
    "        palindromes.append(original_word)\n",
    "\n",
    "print(palindromes)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Extra Brownie points!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- There are also words which are not palindromes, but when reversed another existing word emerges. Consider the words *stressed* and *desserts*. We give you a text that contains a few of them, output all pairs that occur in the text (regardless of case), but exclude words with a length of one.\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "text = \"I just live for desserts , I really love them . My dog does too . I saw he ate mine . I was very stressed because of that . If dogs steal desserts God can't be real , for it is pure evil .\" \n",
    "# insert your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### min(), max() and sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When dealing with lists of numbers, there are three functions which come in handy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "numbers = [1, 2, 3, 4, 5]\n",
    "print(min(numbers))\n",
    "print(max(numbers))\n",
    "print(sum(numbers))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### DIY"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Compute the average of `numbers`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# insert your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##Final Exercises Chapter 4"
   ]
  },
  {
   "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": [
    "-  Define a sentence and split it into words along whitespace. Now fill a dictionary that holds the frequencies (value) for each word (key) in the sentence. You should first check whether a word is already present in your dictionary. If it is, augment its frequency. Else, you should first initialize its frequency. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# fill dictionary code\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-  By now, you already know that Python has the `len()` function built-in, but can you write yourself a code block that prints the length of the string `lengthy_word` that you will define? First use a `for` loop; then try to achieve the same results with a `while` loop, but watch out that you don't get stuck an infinite loop!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# lengthy word (1) code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Have another look at the string variable `lenghty_word` that you defined in the previous exercices. Can you write a code block that fills a dictionary `char_freqs` containing the frequency of the different individual characters in `length_word`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# lengty_word (2) code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Let's have yet another at `lengthy_word`. Can you write code that creates the dictionary `next_char`, holding for each first occurence of a character (key) the *next* character in the word as value. If the character is already in the dictionary, do nothing and if you're dealing with the last character in the word, add \"Last word!\" as value to the dictionary for this character."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# lengthy_word (3) code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Write a code block that defines a list of integers and prints them as a histogram to the screen. For example, for `histogram = [4, 9, 7, 2, 16, 8, 3]`, the code should print the following:\n",
    "\n",
    "++++\n",
    "\n",
    "+++++++++\n",
    "\n",
    "+++++++\n",
    "\n",
    "++\n",
    "\n",
    "++++++++++++++++\n",
    "\n",
    "++++++++\n",
    "\n",
    "+++\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# histogram"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- \"99 Bottles of Beer\" is a traditional song in the United States and Canada. It is popular to sing on long trips, as it has a very repetitive format which is easy to memorize, and can take a long time to sing. The song's simple lyrics are as follows: \"99 bottles of beer on the wall, 99 bottles of beer. Take one down, pass it around, 98 bottles of beer on the wall.\" The same verse is repeated, each time with one fewer bottle. The song is completed when the singer or singers reach zero. Your task here is write a Python code block capable of generating all the verses of the song. Use a `counter` integer variable and a `while` loop. Make sure that your loop will come to an end and that the inflection of the word bottle is adapted to the counter!\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# bottles of beer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- The third person singular verb form in English is distinguished by the suffix -s, which is added to the stem of the infinitive form: run -> runs. A simple set of rules can be given as follows: \"If the verb ends in y, remove it and add ies. If the verb ends in o, ch, s, sh, x or z, add es. By default just add s.\" Your task in this exercise is to write a code block which given a verb in infinitive form, prints its third person singular form. Test your function with words like \"try\", \"brush\", \"run\" and \"fix\". Can you think of verbs for which your code doesn't work? Check out the string method `.endswith()` online!\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# verbs code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- ROT13 is a way to encode secret messages in cryptography. The name comes from Julius Caesar, who used it to communicate with his generals. ROT13 (\"rotate by 13 places\") is a widely used example of a Caesar cipher. The idea is to rotate or augment the position of each character in the alphabet with thirteen places. Your task in this exercise is to implement an encoder/decoder of ROT-13. For this, you will need to create a list containing each letter in the (lowercase) roman alphabet as well as the whitespace character. Next, you will have to create an encode_dict and a decode_dict. Once you're done, you will be able to read the following secret message: \"Pnrfne pvcure? V zhpu cersre Pnrfne fnynq!\" (Hint: you can use .index() to retrieve the position of an item in a list!)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Caesar code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Congrats: you've reached the end of Chapter 4! Ignore the code block below; it's only here to make the page prettier."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/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>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "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()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}