Chapter 1 - Variables.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Chapter 1: Variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Data Processing with Python, a course for Communication and Information Sciences*\n",
    "\n",
    "<a href=mailto:s.wubben@tilburguniversity.edu>s.wubben@tilburguniversity.edu</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-------------------------------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## First steps"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Welcome to the Data Processing course! In this course we will learn how to load, process and save data using a versatile programming language: Python.\n",
    "The best way to learn Python is by jumping right in! \n",
    "\n",
    "In this course we are going to practise Python using notebooks. These notebooks contain instructions and so called 'code blocks'. The instructions are paragraphs of text that explain the concepts we are going to use. The 'code blocks' contain Python code. \n",
    "\n",
    "You can let the computer run the Python code, such as the code in the grey block immediately below. To do this, 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",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print(\"Hello world!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If everything went as planned, you saw something happen. Can you describe what this block of code did? The nice thing of these notebooks is that you can write your own code in the code blocks.\n",
    "Go ahead and click on the code block directly above. You can now edit the code block. \n",
    "\n",
    "**Exercise**: Can you edit the block in such a way that it will print out your own name?\n",
    "\n",
    "\n",
    "###Calculations\n",
    "Apart from printing words to your screen, you can also use Python to do calculations. Again, run the three code blocks below and see what they produce. Try to figure out what the code is doing!\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#summing\n",
    "print(5+2)\n",
    "\n",
    "#subtracting\n",
    "print(5-2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#multiplication\n",
    "print(5*2)\n",
    "\n",
    "#division\n",
    "print(5/2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#power\n",
    "print(5**2)\n",
    "\n",
    "#combining stuff\n",
    "print(5*2-3+4/2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Now it's time to write your first program! In the code block below, write a program that displays the number of seconds in a week. To do this, first think of the number of seconds in a minute, then multiply this with the number of minutes in an hour, etc.\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#display the number of seconds in a week\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Did your program produce output? Excellent! You have just written and executed your very first program! \n",
    "\n",
    "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"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 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",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x = 5\n",
    "print(x)"
   ]
  },
  {
   "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 `5`. this is what we call *assignment*. The 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"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "**Exercise:** Now copy the outcome of your code calculating the number of seconds in a week in the box below. Assign this to `x`. Run the code.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x=#insert your code here\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "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 seconds in a week. 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.\n",
    "\n",
    "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",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x = 2\n",
    "print(x)\n",
    "print(x * x)\n",
    "print(x + x)\n",
    "print(x - 6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###Variable names\n",
    "\n",
    "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 variable names are valid, which means that they:\n",
    "* must start with a letter or underscore (_)\n",
    "* may only contain letters, numbers and underscores\n",
    "* are case sensitive\n",
    "\n",
    "Run the following two blocks to discover what happens when you use a bad variable name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#good variable names\n",
    "spam = 3\n",
    "spam2 = 5\n",
    "_eggs = 20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#bad variable names: this block will generate an error!\n",
    "2spam = 5\n",
    "#tag = 2\n",
    "var.2 = 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "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",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "seconds_in_seven_weeks = 70560\n",
    "print(seconds_in_seven_weeks)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###Multiple variables\n",
    "\n",
    "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",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "first_number = 5\n",
    "second_number = first_number\n",
    "first_number = 3\n",
    "print(first_number)\n",
    "print(second_number)"
   ]
  },
  {
   "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",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# not recommended...\n",
    "months = 70560\n",
    "print(months)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Variables are also case sensitive, accessing *months* is not the same as *Months*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print(months)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print(Months)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###Variable types\n",
    "For each variable you use, Python knows what kind of variable it is. In other words: it knows something about the stuff you have stored in each box. Python distinguishes between the following types of variables:\n",
    "\n",
    "- Integers: whole numbers (e.g. 3, 42, 600)\n",
    "- Floats: numbers with digits behind the dot (3.14, 15.6, 301.2)\n",
    "- Strings: sequences of characters ('three', 'car', 'hello')\n",
    "\n",
    "\n",
    "\n",
    "Depending on the type, Python interprets these variables in a different way. Have a look at the following two examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "var1 = 1 + 4\n",
    "print(var1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "var2 = 'hello ' + 'there'\n",
    "print(var2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we can see, “+” means “addition” if we use it with integers and “concatenate” (put together) if we use it with strings. When we combine a string with an integer things go horribly wrong:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "var3 = 'hello ' + 4\n",
    "print(var3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python throws a TypeError. It can't combine strings and integers."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "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 contain any 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",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "some_float = 23.987\n",
    "print(some_float)\n",
    "some_float = -4.56\n",
    "print(some_float)"
   ]
  },
  {
   "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": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x = 5/2\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Text strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So far, we have mainly 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. For a lot of research areas it is important to be able to work with  text (for example: analysing tweets). 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",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "book = \"American Psycho\"\n",
    "print(book)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Such a piece of text (\"American Psycho\") 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",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "name = \"Patrick Bateman\"\n",
    "print(\"name\")\n",
    "print (name)"
   ]
  },
  {
   "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",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "original_string = \"bla\"\n",
    "new_string = 2*original_string\n",
    "print(new_string)\n",
    "new_string = new_string+\"h\"\n",
    "print(new_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Adding strings together is called 'string concatenation' or simply 'concatenation' in programming. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "string1 = \"the magic number is\"\n",
    "string2 = \"42\"\n",
    "print(string1, string2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example we see that we can even put numbers in strings. If a number is in a string, its value is ignored by python. It's treated just the same as a letter or any other character.\n",
    "\n",
    "Also note that we used one print statement with multiple arguments, separated by comma's."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###Operators\n",
    "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",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "nr1 = 10-2/4\n",
    "nr2 = (10-2)/4\n",
    "nr3 = 10-(2/4)\n",
    "print(nr1)\n",
    "print(nr2)\n",
    "print(nr3)"
   ]
  },
  {
   "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",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "number_of_books = 100"
   ]
  },
  {
   "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",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "number_of_books = number_of_books + 1\n",
    "print(number_of_books)"
   ]
  },
  {
   "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",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "number_of_books += 5\n",
    "print(number_of_books)"
   ]
  },
  {
   "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",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "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)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###Getting user input\n",
    "Up until now we have defined the values stores in the variables ourselves. But if you work with data, the values will be read from these data (for example: tweets, email messages, etc.). We can also ask directly for input. This is done with the *input* command:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x = input()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the example above, we let the user type in something and store it in the variable called x. We can also give the user a prompt:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "name = input(\"Hello! What is your name? \")\n",
    "print(\"Hello\",name)"
   ]
  },
  {
   "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",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x = \"5\"\n",
    "y = 2\n",
    "print(x + y)"
   ]
  },
  {
   "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",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x = \"5\"\n",
    "y = 2\n",
    "z= int(x) + y\n",
    "print(z)"
   ]
  },
  {
   "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": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x=5\n",
    "y=5.0\n",
    "z=\"5\"\n",
    "print(type(x))\n",
    "print(type(y))\n",
    "print(type(z))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Ask the user for their year of birth and print how old the user will be by the end of this year. Make sure you use type() when necessary!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#your code goes here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##Adding comments to code"
   ]
  },
  {
   "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",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# 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.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----------"
   ]
  },
  {
   "cell_type": "markdown",
   "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 vs strings\n",
    "-  operators for multiplication (`*`), subtraction (`-`), addition (`+`), division (`/`)\n",
    "-  the shortcut operators: `+=`, `-=`, `*=`, `/=`\n",
    "-  `print()`\n",
    "-  `input()`\n",
    "-  code commenting\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Extra: Python string formatting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "thing = \"mathematics\"\n",
    "s1 = \"Young man, in {} you don't understand things. You just get used to them.\".format(thing)\n",
    "print(s1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "number = 3\n",
    "s1 = \"Exams... I haven't slept for {} days\".format(number)\n",
    "print(s1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "s2 = \"glazed with {} water beside the {} chickens\".format(\"rain\", \"white\")\n",
    "s3 = \"glazed with {} water beside the {} chickens\".format(\"sea\", \"angry\")\n",
    "print(s2)\n",
    "print(s3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##Final Exercises Chapter 1"
   ]
  },
  {
   "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",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#Book store code"
   ]
  },
  {
   "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",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print(\"A message\").\n",
    "print(\"A message')\n",
    "print('A messagef\"')"
   ]
  },
  {
   "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",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# ZeroDivisionError"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-  Ex. 4: 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."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# average"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-  Ex. 5: 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",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# circle code\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Ex. 6: 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",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# try out the modulus operator!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Ex. 7: 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",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# cashier code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-----------------------\n",
    "\n",
    "You've reached the end of Chapter 1! "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.4.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}