Chapter 1 - Variables.ipynb

{
 "metadata": {
  "name": ""
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "heading",
     "level": 1,
     "metadata": {},
     "source": [
      "Chapter 1: Variables"
     ]
    },
    {
     "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": [
      "First steps"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Everyone can learn how to program and the best way to learn it is by doing it. This tutorial on the Python programming language for people from the Humanities is extremely hands-on: you will have to write a lot of programming code yourself from the very beginning onwards. For writing the Python code in this tutorial, you can use the many 'code blocks' you will encounter, such as the grey block immediately below. Place your cursor inside this block and press `ctrl+enter` to \"run\" or execute the code. Let's begin right away: run your first little program!"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print(\"Ready, set, GO!\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "* Can you describe what this code did?\n",
      "* Can you adapt the code in this box yourself and make it print your own name?\n",
      "\n",
      "Apart from printing words to your screen, you can also use Python to do calculations. \n",
      "\n",
      "* Use the code block below to calculate how many minutes there are in seven weeks? (Hint: multiplication is done using the `*` symbol in Python.)"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# insert your own code here!"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Excellent! You have just written and executed your very first program! Please make sure to run *every single one* of the following code blocks in the same manner - otherwise a lot of the examples won't properly work.\n",
      "\n",
      "So far, we used only Python as a pretty minimalistic calculator, but there is more to discover. \n",
      "\n",
      "## Variables and values\n",
      "Imagine that we want to store the number we just calculated so we can use it later. To do this we need to 'assign' a name to a value using the = symbol. "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x = 2\n",
      "print(x)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "If you vaguely remember your math-classes in school, this should look familiar. It is basically the same notation with the name of the variable on the left, the value on the right, and the = sign in the middle. \n",
      "\n",
      "In the code block above, two things happen. First, we fill `x` with a value, in our case `2`.This variable x behaves pretty much like a box on which we write an `x` with a thick, black marker to find it back later. We then print the contents of this box, using the `print()` command. \n",
      "\n",
      "* Now copy the outcome of your code calculating the number of minutes in seven weeks and assign this number to `x`. Run the code again.\n",
      "\n",
      "The box metaphor for a variable goes a long way: in such a box you can put whatever value you want, e.g. the number of minutes in seven weeks. When you re-assign a variable, you remove the content of the box and  put something new in it. In Python, the term 'variable' refers to such a box, whereas the term 'value' refers to what is inside this box."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "When we have stored values inside variables, we can do interesting things with these variables. You can, for instance, run the calculations in the block below to see the effect of the following five lines of code. Symbols like `=`, `+`, `-` and `*` are called 'operators' in programming: they all provide a very basic functionality such as assigning values to variables or doing multiplication and subtraction.  "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": true,
     "input": [
      "x = 2\n",
      "print(x)\n",
      "print(x * x)\n",
      "print(x + x)\n",
      "print(x - 6)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "So far, we have only used a variable called `x`. Nevertheless, we are entirely free to change the names of our variables, as long as these names do not contain strange characters, such as spaces, numbers or punctuation marks. (Underscores, however, are allowed inside names!) In the following block, we assign the outcome of our calculation to a variable that has a more meaningful name than the abstract name `x`."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "seconds_in_seven_weeks = 70560\n",
      "print(seconds_in_seven_weeks)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "In Python we can also copy the contents of a variable *into another variable*, which is what happens in the block below. You should of course watch out in such cases: make sure that you keep track of the value of each individual variable in your code. Each variable will always contain the value that you *last* assigned to it:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "first_number = 5\n",
      "second_number = first_number\n",
      "first_number = 3\n",
      "print(first_number)\n",
      "print(second_number)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Remember: as with boxes in real life, it is always a good idea to give the box a clear, yet short name, with your black marker - the name should accurately reflect what is inside the box. Just like you don't write `cookies` on a box that in reality contains bananas, it is important to always give your Python variables a sensible name. In the code block below, for instance, we make the stupid mistake of calling a variable `months`, while it actually contains `seconds`..."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# not recommended...\n",
      "months = 70560\n",
      "print(months)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Variables are also case sensitive, accessing *months* is not the same as *Months*"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print(months)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print(Months)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "So far we have only assigned numbers such as `2` or `70560` to our variables. Such whole numbers are called 'integers' in programming, because they don't have anymore digits 'after the dot'.  Numbers that *do* have digits after the dot (e.g. `67.278` or `191.200`), are called 'floating-point numbers' in programming or simply 'floats'. Note that Python uses dots in floats, whereas some European languages use a comma here. Both integers and floats can be positive numbers (e.g. `70` or `4.36`) as well as negative numbers (e.g. `-70` or `4.36`). You can just as easily assign floats to variables:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "some_float = 23.987\n",
      "print(some_float)\n",
      "some_float = -4.56\n",
      "print(some_float)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "On the whole, the difference between integers and floats is of course important for divisions where you often end up with floats:"
     ]
    },
    {
     "cell_type": "raw",
     "metadata": {},
     "source": [
      "x = 5/2\n",
      "print(x)"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "You will undoubtedly remember from your math classes in high school that there is something called 'operator precedence', meaning that multiplication, for instance, will always be executed before subtraction. In Python you can explicitly set the order in which arithmetic operations are executed, using round brackets. Compare the following lines of code:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "nr1 = 10-2/4\n",
      "nr2 = (10-2)/4\n",
      "nr3 = 10-(2/4)\n",
      "print(nr1)\n",
      "print(nr2)\n",
      "print(nr3)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Using the operators we have learned about above, we can change the variables in our code as many times as we want. We can assign new values to old variables, just like we can put new or more things in the boxes which we already had. Say, for instance, that yesterday we counted how many books we have in our office and that we stored this count in our code as follows:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "number_of_books = 100"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Suppose that we buy a new book for the office today: we can now update our book count accordingly, by adding one to our previous count:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "number_of_books = number_of_books + 1\n",
      "print(number_of_books)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Updates like these happen a lot. Python therefore provides a shortcut and you can write the same thing using `+=`."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "number_of_books += 5\n",
      "print(number_of_books)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "This special shortcut (`+=`) is called an operator too. Apart from multiplication (`+=`), the operator has variants for subtraction (`-=`), multiplication (`*=`) and division (`/=`) too:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "number_of_books -= 5\n",
      "print(number_of_books)\n",
      "number_of_books *= 2\n",
      "print(number_of_books)\n",
      "number_of_books /= 2\n",
      "print(number_of_books)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "----------"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "##DIY"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "This task will a bit more mathematical, but don't worry, we'll explain it step by step.\n",
      "The *wheat and chessboard* problem is a classic in computer science, maybe you have heard about it before:\n",
      "\n",
      "> If a chessboard were to have wheat placed upon each square, such that one grain were placed on the first square, two on the second, four on the third, and so on (doubling the number of grains on each subsequent square), how many grains of wheat would be on the chessboard at the finish?\n",
      "\n",
      "It is a time of crisis so we couldn't aford a full virtual chessboard but rather one with ten fields. Can you calculate the number of grains that will be present in the 10th square? And how many grains would there be on the entire chessboard in the end? (Hint: use the shortcut operator for multiplication!)"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#insert your code here\n",
      "\n",
      "#square 1\n",
      "grains_on_the_square=1\n",
      "\n",
      "#square 2\n",
      "\n",
      "#square 3\n",
      "\n",
      "#square 4\n",
      "\n",
      "#square 5\n",
      "\n",
      "#square 6\n",
      "\n",
      "#square 7\n",
      "\n",
      "#square 8\n",
      "\n",
      "#square 9\n",
      "\n",
      "#square 10\n",
      "\n",
      "\n",
      "print(grains_on_the_square)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "--------------"
     ]
    },
    {
     "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 concepts you have learnt. Go through the list and make sure you understand all the concepts.\n",
      "\n",
      "-  variable\n",
      "-  value\n",
      "-  assignment operator (`=`)\n",
      "-  difference between variables and values\n",
      "-  integers vs. floats\n",
      "-  operators for multiplication (`*`), subtraction (`-`), addition (`+`), division (`/`)\n",
      "-  the shortcut operators: `+=`, `-=`, `*=`, `/=`\n",
      "-  `print()`\n"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "------"
     ]
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Text strings"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "So far, we have only worked with variables that contain numbers (integers like `-5` or `72` or floats like `45.89` or `-5.609`). Note, however, that variables can also contain other things than numbers. Many disciplines within the humanities work on texts. Quite naturally, programming skills for the humanities will have to focus a lot on manipulating texts. Have a look at the code block below, for instance. Here we put *text*, namely the title of a book, as a value inside the variable `book`. Then, we print what is inside the `book` variable."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "book = \"The Lord of the Flies\"\n",
      "print(book)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Such a piece of text (\"The Lord of the Flies\") is called a 'string' in Python (cf. a *string* of characters). Strings in Python must always be enclosed with 'quotes' (either single or double quotes). Without those quotes, Python will think it's dealing with the name of some variable that has been defined earlier, because variable names never take quotes. The following distinction is confusing, but extremely important: variable names (*without* quotes) and string values (*with* quotes) look similar, but they serve a completely different purpose. Compare:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "name = \"Bonny\"\n",
      "Bonny = \"name\"\n",
      "Clyde = \"Clyde\"\n",
      "print(name)\n",
      "print (Bonny)\n",
      "print(Clyde)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Some of the arithmetic operators we saw earlier can also be used to do useful things with strings. Both the multiplication operator (`*`) and the addition operator (`+`) provide interesting functionality for dealing with strings, as the block below illustrates.\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "original_string = \"bla\"\n",
      "new_string = 2*original_string\n",
      "print(new_string)\n",
      "new_string = new_string+\"h\"\n",
      "print(new_string)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Adding strings together is called 'string concatenation' or simply 'concatenation' in programming. Use the block below to find out whether you could can also use the shortcut `+=` operator for adding an 'h' to the variable `original_string`. Don't forget to check the result by printing it!"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "original_string = \"blabla\"\n",
      "# add an 'h'..."
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "We now would like you to write some code that defines a variable, `name`, and assign to it a string that is your name. If your first name is shorter than 5 characters, use your last name. If your last name is also shorter than 5 characters, use the combination of your first and last name. Now print the variable containing your name to the screen."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# your name code goes here..."
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Strings are called strings because they consist of a series (or 'string') of individual characters. We can access these individual characters in Python with the help of 'indexing', because each character in a string has a unique 'index'. To print the first letter of your name, you can type:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "first_letter = name[0]\n",
      "print(first_letter)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "![Indexes of the string Mr White starting with 0](https://dl.dropboxusercontent.com/u/259394/string_index.png \"Python strings and indexes\")\n",
      "\n",
      "Take a look at the string \"Mr White\". We use the index `0` to access the first character in the string. This might seem odd, but  remember that all indexes in Python start at zero. Whenever you count in Python, you start at `0` instead of `1`. Note that the space character gets an index too, namely 2. This is something you will have to get used to!\n",
      "\n",
      "\n",
      "\n",
      "Because you know the length of your name you can ask for the last letter of your name: "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "last_letter = name[# fill in the last index of your name (tip indexes start at 0)]\n",
      "print(last_letter)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "It is rather inconvenient having to know how long our strings are if we want to find out what its last letter is. Python provides a simple way of accessing a string 'from the rear':"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "last_letter = name[-1]\n",
      "print(last_letter)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "To access the last character in a string you have to use the index [-1]. Alternatively, there is the `len()` command which returns the length of a string:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print(len(name))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Do you understand the following code block? Can you explain what is happening?"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print(name[len(name)-1])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Now can you write some code that defines a variable `but_last_letter` and assigns to this variable the *one but last* letter of your name?"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "but_last_letter = name[# insert your code here]\n",
      "print(but_last_letter)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "You're starting to become a real expert in indexing strings. Now what if we would like to find out what the last two or three letters of our name are? In Python we can use so-called 'slice-indexes' or 'slices' for short. To find the first two letters of our name we type in:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "first_two_letters = name[0:2]\n",
      "print(first_two_letters)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The `0` index is optional, so we could just as well type in `name[:2]`. This says: take all characters of name until you reach index 2 (i.e. up to the third letter, but not including the third letter). We can also start at index 2 and leave the end index unspecified:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "without_first_two_letters = name[2:]\n",
      "print(without_first_two_letters)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Because we did not specify the end index, Python continues until it reaches the end of our string. If we would like to find out what the last two letters of our name are, we can type in:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "last_two_letters = name[-2:]\n",
      "print(last_two_letters)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "-------"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "##DIY"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "- Can you define a variable `middle_letters` and assign to it all letters of your name except for the first two and the last two?"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# insert your middle_letters code here"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "- Given the following two words, can you write code that prints out the word *humanities* using only slicing and concatenation? (So, no quotes are allowed in your code.) Can you print out how many characters the word *humanities* counts?"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "word1 = \"human\"\n",
      "word2 = \"opportunities\""
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "---------\n",
      "\n",
      "##\"Casting\" variables"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Above, we have already learned that each variable as a data type: variables can be strings, floats, integers, etc. Sometimes it is necessary to convert one type into the other. Consider this:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x = \"5\"\n",
      "y = 2\n",
      "print(x + y)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "This should raise an error on your machine: does the error message gives you a hint as to why this doesn't work? *x* is a string, and *y* is an integer. Because of this, you cannot sum them. Luckily there exist ways to 'cast' variables from one type of variable into another type of variable.\n",
      "\n",
      "- Do you understand the outcome of the following code?\n",
      "- Can you comment in your own words on the effect of applying `int()` and `str()` to variables?"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x = \"5\"\n",
      "y = 2\n",
      "print(x + str(y))\n",
      "print(int(x) + y)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Other types of conversions are possible as well, and we will see a couple of them in the next chapters. Because variables can change data type anytime they want, we say that Python uses 'dynamic typing', as opposed to other more 'strict' languages that use 'strong typing'. You can check a variable's type using the `type()`command."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "##DIY"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "When you exchange code with fellow programmers (as you will often have to do in the real world), it is really helpful if you include some useful information about your scripts. Have a look at the code block below and read about `commenting` on Python code in the comments:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# comment: insert your code here.\n",
      "# BTW: Have you noticed that everything behind the hashtag \n",
      "print(\"Something...\") # on a line is ignored by your python interpreter?\n",
      "print(\"and something else..\") # this is really helpful to comment on your code!\n",
      "\"\"\"Another way\n",
      "of commenting on your code is via \n",
      "triple quotes -- these can be distributed over multiple \"\"\" # lines\n",
      "print(\"Done.\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "So, how many ways are there to comment on your code in Python? "
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "----------"
     ]
    },
    {
     "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 what we have learnt. Go through the list and make sure you understand all the concepts.\n",
      "\n",
      "-  concatenation\n",
      "-  index\n",
      "-  slicing\n",
      "- `zero-indexed` numbering\n",
      "-  `len()`\n",
      "-  type casting: `int()` and `str()`\n",
      "-  `type()`\n",
      "-  code commenting via hashtags and triple double quotes\n"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "-------"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "##Final Exercises Chapter 1"
     ]
    },
    {
     "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: Suppose the cover price of a book is 24.95 EUR, but bookstores get a 40 percent discount. Shipping costs 3 EUR for the first copy and 75 cents for each additional copy. What is the total wholesale cost for 60 copies? Print the result in a pretty fashion, using casting where necessary!"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# your code goes here"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "-  Ex. 2: Can you identify and explain the errors in the following lines of code? Correct them please!"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print(\"A message\")\n",
      "#print(\"A message'\")\n",
      "print(\"A messagef\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "-  Ex. 3: When something is wrong with your code, Python will raise errors. Often these will be 'syntax errors' that signal that something is wrong with the form of your code (i.e. a `SyntaxError` like the one thrown in the previous exercice). There are also 'runtime errors' that signal that your code was in itself formally correct, but that something went wrong during the code's execution. A good example is the `ZeroDivisionError`. Try to make Python throw such a ZeroDivisionError!"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# ZeroDivisionError"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "- Ex. 4: Can you make Python print the following graphic?\n",
      "![Fun with Python](https://dl.dropboxusercontent.com/u/28211242/fun.png \"Fun pattern with Python\")\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# fun pattern"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "- Ex. 5: Write a program that assigns the result of `9.5 * 4.5 - 2.5 * 345.5 - 3.5` to a variable. Print this variable. Use round brackets to indicate 'operator precedence' and make sure that subtractions are performed before multiplications. When you convert the outcome to a string, how many characters does it count?"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# formula"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "- Ex. 6: Define the variables `a=2`, b=`20007` and c=`5`. Using only the operations you learned about above, can you now print the following numbers: `2005`, `252525252`, `2510`, `-60025` and `2002507`? (Hint: use type casting and string slicing to access parts of the original numbers!) "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# numbers"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "-  Ex. 7: Define three variables `var1`, `var2` and `var3`. Calculate the average of these variables and assign it to `average`. Print the result in a fancy manner. Add three comments to this piece of code using three different ways."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# average code"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "-  Ex. 8: Write a little program that can compute the surface of circle, using the variables `radius` and `pi=3.14159`. The formula is of course radius, multiplied by radius, multiplied by `pi`. Print the outcome of your program as follows: 'The surface area of a circle with radius ... is: ...'."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# circle code"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "- Ex. 9: There is one operator (like the ones for multiplication and subtraction) that we did not mention yet, namely the modulus operator `%`. Could you figure by yourself what it does when you place it between two numbers (e.g. 113 % 9)? (PS: It's OK to get help online...) You don't need this operator all that often, but when you do, it comes in really handy!"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# try out the modulus operator!"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "- Ex. 10: Can you use the modulus operator you just learned about to solve the following task? Write a code block that classifies a given amount of money into smaller monetary units. Set the `amount` variable to 11.56. You code should outputs a report listing the monetary equivalent in dollars, quarters, dimes, nickels, and pennies. Your program should report the maximum number of dollars, then the number of quarters, dimes, nickels, and pennies, in this order, to result in the minimum number of coins. Here are the steps in developing the program:\n",
      ">   Convert the amount (11.56) into cents (1156).\n",
      ">   Divide the cents by 100 to find the number of dollars, but first subtract the rest using the modulus operator!\n",
      ">   Divide the remaining cents by 25 to find the number of quarters, but, again, first subtract the rest using the modulus operator!\n",
      ">   Divide the remaining cents by 10 to find the number of dimes, etc.\n",
      ">   Divide the remaining cents by 5 to find the number of nickels, etc.\n",
      ">   The remaining cents are the pennies. Now display the result for your cashier!"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# cashier code"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "-----------------------\n",
      "\n",
      "You've reached the end of Chapter 1! You can safely 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 0x5029930>"
       ]
      }
     ],
     "prompt_number": 1
    }
   ],
   "metadata": {}
  }
 ]
}