Chapter 3 - Conditions.ipynb

{
 "metadata": {
  "name": ""
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "heading",
     "level": 1,
     "metadata": {},
     "source": [
      "Chapter 3: Conditions"
     ]
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Simple conditions"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "A lot of programming has to do with executing code *if* a particular condition holds.  Here we give a brief overview of how you can express certain conditions in Python. Can you figure our what all of the conditions do?"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print(2 < 5)\n",
      "print(2 <= 5)\n",
      "print(3 > 7)\n",
      "print(3 >= 7)\n",
      "print(3 == 3)\n",
      "print(\"school\" == \"school\")\n",
      "print(\"Python\" != \"perl\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The relevant 'logical operators' that we used here are: `<`, `<=`, `>`,`>=`,`==`,`!=`. In Python-speak, we say that such logical expression gets 'evaluated' when you run the code. The outcome of such an evaluation is a 'binary value' or a so-called 'boolean' that can take only two possible values: `True` or `False`. You can assign such a boolean to a variable:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "greater = 5 > 2\n",
      "print(greater)\n",
      "greater = 5 < 2\n",
      "print(greater)\n",
      "print(type(greater))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "if, elif and else"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "At the end of the previous chapter, we have talked about dictionaries, which are a kind of data structure which you will need a lot when writing Python. Recall our collection of good_reads from the previous chapter. Recall that we could use the key of an entry to retrieve the score of a book in our collection:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "good_reads = {\"Emma\":8, \"Pride and Prejudice\":10, \"Sense and Sensibility\":7, \"Northanger Abbey\":3}\n",
      "score = good_reads[\"Sense and Sensibility\"]\n",
      "print(score)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "At some point, however, we might forget which books we have already added to our collection. What happens if we try to get the score of a book that is not in our collection?"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "score = good_reads[\"Moby Dick\"]\n",
      "print(score)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "We get an error, and more specifically a `KeyError`, which basically means: \"the key you asked me to look up is not in the dictionary...\". We will learn a lot more about error handling later, but for now we would like to prevent our program from giving it in the first place. Let's write a little program that prints \"X is in the collection\" if a particular book is in the collection and \"X is NOT in the collection\" if it is not."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "book = \"Moby Dick\"\n",
      "if book in good_reads:\n",
      "    print(book + \" is in the collection\")\n",
      "else:\n",
      "    print(book + \" is NOT in the collection\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "A lot of new syntax here. Let's go through it step by step. First we check whether the value we assigned to `book` is in our collection. The part after `if` is a logical expression which will be `True` or `False`:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print(book in good_reads)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Because our book is not in the collection, Python returns `False`. Let's do the same thing for a book that we know is in the collection:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print(\"Emma\" in good_reads)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Indeed, it is in the collection! Back to our `if` statement. If the expression after `if` evaluates to `True`, our program will go on to the next line and print `book + \" is in the collection\"`. Let's try that as well:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "if \"Emma\" in good_reads:\n",
      "    print(\"Found it!\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "if book in good_reads:\n",
      "    print(\"Found it!\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Notice that the last print statement is not executed. That is because the value we assigned to `book` is not in our collection and thus the part after `if` did not evaluate to `True`. In our little program above we used another statement besides `if`, namely `else`. It shouldn't be too hard to figure out what's going on here. The part after `else` will be evaluated if the `if` statement evaluated to `False`. In English: if the book is not in the collection, print that is is not."
     ]
    },
    {
     "cell_type": "heading",
     "level": 5,
     "metadata": {},
     "source": [
      "Indentation!"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Unlike other languages, Python does not make use of curly braces to mark the start and end of pieces of code, like `if`-statements. The only delimiter is a colon (`:`) and the indentation of the code (i.e. the use of whitespace). This indentation must be used consistently throughout your code. The convention is to use 4 spaces as indentation. This means that after you have used a colon (such as in our `if` statement) the next line should be indented by four spaces. (The shortcut for typing these 4 spaces in many editors is inserting a *TAB*.)"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Sometimes we have various conditions that should all evaluate to something different. For that Python provides the `elif` statement. We use it similar to `if` and `else`. Note however that you can only use `elif` after an `if` statement! Above we asked whether a book was in the collection. We can do the same thing for parts of strings or for items in a list. For example we could test whether the letter *a* is in the word *banana*:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print(\"a\" in \"banana\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Likewise the following evaluates to `False`:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print(\"z\" in \"banana\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Let's use this in an `if-elif-else` combination, a very common way to implement 'decision trees' in Python:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "word = \"rocket science\"\n",
      "if \"a\" in word:\n",
      "    print(word + \" contains the letter a\")\n",
      "elif \"s\" in word:\n",
      "    print(word + \" contains the letter s\")\n",
      "elif \"d\" in word:\n",
      "    print(word + \" contains the letter s\")\n",
      "elif \"c\" in word:\n",
      "    print(word + \" contains the letter c\")\n",
      "else:\n",
      "    print(\"What a weird word!\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "First the `if` statement will be evaluated. Only *if* that statement turns out to be `False` the computer will proceed to evaluate the `elif` statement. If the elif statement in turn would prove to be `False`, the machine will proceed and execute the lines of code associated with the `else` statement. You can think of this coding structure as a decision tree! Remember: if somewhere along the tree, your machine comes across a logical expression which is true, it won't bother anymore to evaluate the remaining options!"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "--------"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "##DIY"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Let's practice our new condition skills a little. Write a small program that defines a variable `weight`. If the weight is > 50 pounds, print \"There is a $25 charge for luggage that heavy.\" If it is not, print: \"Thank you for your business.\" If the weight is exactly 50, print: \"Pfiew! The weight is just right!\". Change the value of weight a couple of times to check whether your code works. (Tip: make use of the logical operators and `if-elif-else` tree! Make sure you use the correct indentation.)"
     ]
    },
    {
     "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": [
      "and, or, not"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Until now, our conditions consisted of *single* logical expresssions. However, quite often we would like to test for multiple conditions: for instance, you would like to tell your computer to do something if this and this were but this and that were not true. Python provides a number of ways to do that. The first is with the `and` statement which allows us to combine two expressions that need both to be true in order for the combination to be true. Let's see how that works:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "word = \"banana\"\n",
      "if (\"a\" in word) or (\"b\" in word):\n",
      "    print(\"Both a and b are in \" + word)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Note how we can use round brackets to make the code more readable (but you can just as easily leave them out):"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "word = \"banana\"\n",
      "if (\"a\" in word) and (\"b\" in word):\n",
      "    print(\"Both a and b are in \" + word)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "If one of the expressions evaluates to False, nothing will be printed:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "if (\"a\" in word) and (\"z\" in word):\n",
      "    print(\"Both a and z are in \" + word)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Now you know that the `and` operator exists in Python, you won't be too surprised to learn that there is also an `or` operator in Python that you can use. Replace `and` with `or` in the `if` statement below. Can you deduce what happens? "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "word = \"banana\"\n",
      "if (\"a\" in word) or (\"z\" in word):\n",
      "    print(\"Both a and b are in \" + word)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "In the code block below, can you add an `else` statement that prints that none of the letters were found?"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "if (\"a\" in word) and (\"z\" in word):\n",
      "    print(\"a or z are in \" + word)\n",
      "# insert your code here"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Finally we can use `not` to test for conditions that are not true. "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "if (\"z\" not in word):\n",
      "    print(\"z is not in \" + word)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Objects, such as strings or integers of lists are `True`, simply because they exist. Empty strings, lists, dictionaries etc on the other hand are `False` because in a way they do *not* exist -- an empty list is not really a list, right? This principle is often by programmers to, for example, only execute a piece of code if a certain list contains anything at all:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "numbers = [1, 2, 3, 4]\n",
      "if numbers:\n",
      "    print(\"I found some numbers!\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Now if our list were empty, Python wouldn't print anything:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "numbers = []\n",
      "if numbers:\n",
      "    print(\"I found some numbers!\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "--------"
     ]
    },
    {
     "cell_type": "heading",
     "level": 4,
     "metadata": {},
     "source": [
      "\n",
      "DIY\n"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "- Can you write code that prints \"This is an empty list\" if the provided list does not contain any values?"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "numbers = []\n",
      "# insert your code here"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "- Can you do the same thing, but this time using the function `len()`?"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# insert your code here"
     ],
     "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 new functions, statements and concepts we have learnt. Go through them and make sure you understand what their purpose is and how they are used.\n",
      "\n",
      "-  conditions\n",
      "-  indentation\n",
      "-  `if`\n",
      "-  `elif`\n",
      "-  `else`\n",
      "-  `True`\n",
      "-  `False`\n",
      "-  empty objects are false\n",
      "-  `not`\n",
      "-  `in`\n",
      "-  `and`\n",
      "-  `or`\n",
      "-  multiple conditions\n",
      "-  `==`\n",
      "-  `<`\n",
      "-  `>`\n",
      "-  `!=`\n",
      "-  `KeyError`"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "---------"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "##Final Exercises Chapter 3"
     ]
    },
    {
     "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": [
      "- Can you implement the following grading scheme in Python?\n",
      "![Grades with Python](https://dl.dropboxusercontent.com/u/28211242/grade.png \"Grading system in Python\")"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# grading system"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "-  Can you spot the reasoning error in the following code?"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "score = 98.0\n",
      "if score >= 60.0:\n",
      "    grade = 'D'\n",
      "elif score >= 70.0:\n",
      "    grade = 'C'\n",
      "elif score >= 80.0:\n",
      "    grade = 'B'\n",
      "elif score >= 90.0:\n",
      "    grade = 'A'\n",
      "else:\n",
      "    grade = 'F'\n",
      "print(grade)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "-  (Advanced excercise: you need a for-loop for this excercise, which is only discussed in the next chapter.) In 1939 Ernest Vincent Wright published a 50,000 word novel called *Gadsby* that does not contain the letter 'e'. Since 'e' is the most common letter in English, that's not easy to do.\n",
      "Define a variable `sentence` and write some Python code that will print to screen whether `sentence` contains an 'e'. If it contains at least 3 instances of 'e', make it print *only* the words that have no 'e' and compute the percentage of the words in the sentence that do contain an 'e'."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# code"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "-  Write Python code that defines a list and selects the unique elements from the original and puts these in a new variable. Print the unique elements. (Hint: they don\u2019t have to be in the same order.)"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# code"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "- Write Python code that defines two numbers and prints the largest one of them. Use an if-then-else tree."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# code"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "- Let's get some cryptography done!\n",
      "\n",
      "> (Advanced excercise: you really need a for-loop for this excercise, which is only discussed in the next chapter.) ROT13 is a weak form of encryption that involves \"rotating\" each letter in a word by 13 places. To rotate a letter means to shift it through the alphabet, wrapping around to the beginning if necessary, so `a` shifted by 3 is `d` and `a` shifted by 1 is `z`. Define a string called `rotate_word` and an integer variable called `amount`. Now write a Python script that contains the letters from the `rotate_word`, but \"rotated\" by the given `amount`. Check your code using the following examples: 'cheer' rotated by 7 is 'jolly' and 'melon' rotated by -10 is 'cubed'. Use a list of alphabetical characters (['a', 'b', ..., 'z']). Hint: you can retrieve the index of an item in a list using the `index()` function."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# ROT13 code"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "---"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Congrats: you've reached the end of Chapter 3! 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>"
       ],
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 1,
       "text": [
        "<IPython.core.display.HTML at 0x58ad8d0>"
       ]
      }
     ],
     "prompt_number": 1
    }
   ],
   "metadata": {}
  }
 ]
}