Chapter 4 - Loops.ipynb

{
 "metadata": {
  "name": "Chapter 4 - Loops"
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "heading",
     "level": 1,
     "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",
     "collapsed": false,
     "input": [
      "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]))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "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",
     "collapsed": false,
     "input": [
      "for letter in \"banana\":\n",
      "    print(letter)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "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."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Likewise, we can print all the items that are contained in a list:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "colors = [\"yellow\", \"red\", \"green\", \"blue\", \"purple\"]\n",
      "for color in colors:\n",
      "    print(color)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "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",
     "collapsed": false,
     "input": [
      "for book in good_reads:\n",
      "    print(book)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "We can also iterate over both the keys and the values of a dictionary. This is done using the following special syntax:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "for book, score in good_reads.items():\n",
      "    print(book + \"has score\" + score)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Using `items()` will at each iteration return a nice pair of the key and the value. In the example above the variable `book` will loop over the keys of the dictionary, and the variable `score` loops over the respective values.\n",
      "\n",
      "The above way is the simplest way of looping over dictionaries, but try to see if you understand the following alternative as well:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "for book in good_reads:\n",
      "    print(book + \"has score\" + good_reads[book])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "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",
     "collapsed": false,
     "input": [
      "len(\"banana\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "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",
     "collapsed": false,
     "input": [
      "colors = [\"yellow\", \"red\", \"green\", \"blue\", \"purple\"]\n",
      "# insert your code here"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "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",
     "collapsed": false,
     "input": [
      "colors = [\"yellow\", \"red\", \"green\", \"blue\", \"purple\"]\n",
      "colors_with_r = []\n",
      "# insert you code here"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "-----------"
     ]
    },
    {
     "cell_type": "heading",
     "level": 5,
     "metadata": {},
     "source": [
      "while loop"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "There is also another form of loop in Python (and many other programming languages): 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",
     "collapsed": false,
     "input": [
      "number = 5\n",
      "while number < 21:\n",
      "    number += 3\n",
      "    print(number)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 5,
     "metadata": {},
     "source": [
      "What we have learnt"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Here is an overview of the new concepts, statements and functions we have learnt 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": [
      "## 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",
     "collapsed": false,
     "input": [
      "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",
      "# insert your code here\n",
      "\n",
      "# if your code is correct, the following line should print True!\n",
      "print(number_of_as == 42)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "-------"
     ]
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Iterables, Iteration & Loops"
     ]
    },
    {
     "cell_type": "heading",
     "level": 3,
     "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 syntax for creating a tuple is `()`. Example:\n",
      "\n",
      "\n",
      "\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "fruittuple = ('banana','apple','pear')\n",
      "print(fruittuple)\n",
      "print(fruittuple[0])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "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",
     "collapsed": false,
     "input": [
      "fruittuple[0] = 'orange' # will raise an error, tuples are immutable!"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "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",
     "collapsed": false,
     "input": [
      "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)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "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",
     "collapsed": false,
     "input": [
      "fruitlist = ['banana', 'apple', 'pear', 'banana', 'pear', 'kiwi']\n",
      "fruitset = set(fruitlist)\n",
      "fruittuple = tuple(fruitlist)\n",
      "fruitlist = list(fruitset)\n",
      "print(fruitset)\n",
      "print(fruittuple)\n",
      "print(fruitlist)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "---\n"
     ]
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "enumerate()"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Various functions exist that can help you in iterating over iterables. One such function is `enumerate()`. For each item in an iterable, it returns the item itself, but also the item's index number, which can be really helpful. Here too, don't forget that the first element always receives index `0`. Check out the code block below to find out how you can use `enumerate()` in a `for` loop:\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "for i, fruit in enumerate(fruittuple):\n",
      "    print(\"Fruit #\" + str(i+1) + \" is a \" + fruit)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "- Did you see that output? \"A apple?\" That's not proper English! Correct the previous code in order to make it \"an\" when the word starts with a vowel.\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# insert your code here"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "---"
     ]
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "zip()"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "This has nothing to do with file archives (zip-files). The `zip()` function is used to join together two elements from separate lists of the same length. Just visualise a zipper and the way the two sides magically come together whenever you close your jacket: each item in the zipper forms a nice pair with its counterpart.\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "fruits = ['banana', 'apple', 'pear']\n",
      "prices = [0.89, 0.34, 0.44]\n",
      "for fruit, price in zip(fruits, prices):\n",
      "    print(fruit + \"s, now only \" + str(price) + \" each!\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "- Here we use two lists, but we can also rewrite this whole code to use one single data structure, very suited for such a task. Try!"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# insert your code here"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "---"
     ]
    },
    {
     "cell_type": "heading",
     "level": 3,
     "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",
     "collapsed": false,
     "input": [
      "fruits = ['banana', 'apple', 'pear']\n",
      "for fruit in sorted(fruits):\n",
      "    print(fruit)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "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",
     "collapsed": false,
     "input": [
      "for fruit in reversed(fruits):\n",
      "    print(fruit)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 4,
     "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",
     "collapsed": false,
     "input": [
      "words = ['bicycle', 'radar', 'origin', 'tie', 'level', 'poop', 'solar', 'nun']\n",
      "# insert your code here"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 5,
     "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 of length one.\n",
      "\n",
      "\n",
      "\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "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"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 3,
     "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",
     "collapsed": false,
     "input": [
      "numbers = [1, 2, 3, 4, 5]\n",
      "print(min(numbers))\n",
      "print(max(numbers))\n",
      "print(sum(numbers))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 4,
     "metadata": {},
     "source": [
      "DIY"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "- Compute the average of `numbers`:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# insert your code here"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "---"
     ]
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "List comprehensions"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "List comprehensions are a powerful tool in Python to quickly manipulate lists. A list comprehension can replace a more explicit **for** loop on a single line. Consider the following example: "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "numbers = [1, 2, 3, 4, 5]\n",
      "doublenumbers = [number*2 for number in numbers]\n",
      "print(doublenumbers)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "This is not the same as the normal **for** loop you are hopefully accustomed to by now, but similar. The entire expression always takes place within square brackets `[]` , indicating it is a list we want. Anything you can do with list comprehensions you can also do without, but they add a certain elegance and are a quick way of working."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "numbers = [1, 2, 3, 4, 5]\n",
      "# insert your code here, it must be on one line and must be \n",
      "# a list comprehension using numbers. If you did well, the following\n",
      "# will output True. Study this outcome to find out what's asked of you here!\n",
      "print(numbers == [3, 4, 5, 6, 7])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "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",
     "collapsed": false,
     "input": [
      "# fill dictionary code"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "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",
     "collapsed": false,
     "input": [
      "# lengthy word (1) code"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "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",
     "collapsed": false,
     "input": [
      "# lengty_word (2) code"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "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. Provide two solutions: one using `pass` (you can look up its use online) and another one that uses the keywords `try` and `except` to handle exceptions (hint: KeyError is the error you want to raise!)."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# lengthy_word (3) code"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "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",
     "collapsed": false,
     "input": [
      "# histogram"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "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",
     "collapsed": false,
     "input": [
      "# bottles of beer"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "- Remember the exercise in cryptography and ROT13 from the previous chapter? This alternative 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 shift here is +13. Can you write a code block that creates a dictionary which for each letter in the (lowercase) roman alphabet contain the encrypted version according to ROT13? Next, use this dictionary to decode the following sentence\n",
      "Your task in this exercise is to implement an encoder/decoder of ROT-13. Once you're done, you will be able to read the following secret message: \"Pnrfne pvcure? V zhpu cersre Pnrfne fnynq!\" Use the `pass` statement which you learned about in a previous excercise to make that you don't try to decode punctuation marks. Add a key in your encoding/decoding dictionary to deal with the whitespace character.\n",
      "\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Caesar code"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "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",
     "collapsed": false,
     "input": [
      "# verbs code"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "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",
     "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>"
       ],
       "output_type": "pyout",
       "prompt_number": 1,
       "text": [
        "<IPython.core.display.HTML at 0x1024fb890>"
       ]
      }
     ],
     "prompt_number": 1
    }
   ],
   "metadata": {}
  }
 ]
}