notebook-4 Truth & Conditions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Notebook-4 Truth & Conditions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lesson Content \n",
    "\n",
    "- Comparisons\n",
    "    - Booleans\n",
    "    - \"Not equal\" operator\n",
    "    - \"< > <= >=\" operators\n",
    "- Conditions pt.1\n",
    "    - IF       \n",
    "    - ELSE \n",
    "    - ELIF\n",
    "- Boolean Logic\n",
    "    - AND\n",
    "    - OR\n",
    "    - NOT\n",
    "\n",
    "Welcome to the fourth Code Camp notebook! In this lesson we'll learn how to compare stuff (like numerical quantities but also words and strings) via *Comparison Operators*. \n",
    "\n",
    "We'll also see how to express logical concepts like: \" `if` this condition is `True`, then do something...\". These concepts will serve you to model in your code different possibilities and let it run to accordingly. They will also serve to perform assertions and to test if certain conditions have been met or not."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Comparisons\n",
    "----\n",
    "\n",
    "\n",
    "## Booleans\n",
    "\n",
    "The most basic form of comparison is to test if something is `True` of `False`. To do so we'll have to quickly introduce another *data type*, the **boolean**. \n",
    "\n",
    "Booleans are different from the numerical (*floats* and *integers*) or textual (*strings*) types we have seen so far because they have only two possible values once they are set: `True` or `False`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "myBoolean = True\n",
    "print (myBoolean)\n",
    "print (\"This statement is: '\" + str(myBoolean) + \"'\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_Note_: did you see the `str()` around the `myBoolean` variable on the second `print` line? That's so that we can print out its value as part of a string."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comparison Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How do we use booleans? Well, what is the 'answer' if I ask you \"Is it true or false than an elephant is bigger than a mouse?\" And remember too that in [Notebook 1](notebook-1.ipynb) we looked at how a computer 'thinks' -- it's all in terms of things being `True` or `False`. \n",
    "\n",
    "_Note_: just so that you know, sometimes people will use 1 and 0 in place of True and False because that's what's actually happening behind the scenes. It's the same thing _logically_, but Python views sees `True` and `False` differently from `1` and `0` because the latter are numbers, while the former are _boolean_ data type.\n",
    "\n",
    "You will need these set of operators:\n",
    "\n",
    "| Operator Name | Symbol             | Description                                     |\n",
    "|---------------|--------------------|-------------------------------------------------|\n",
    "| A > B         | Greater Than       | Returns True if A is bigger than B              |\n",
    "| A < B         | Less Than          | Returns True if A is smaller than B             |\n",
    "| A >= B        | Greater Equal Than | Returns True if A is bigger  than or equal to B |\n",
    "| A >= B        | Less Equal Than    | Returns True if A is bigger than or equal to B  |\n",
    "\n",
    "Here are some examples..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print (25 >  7)\n",
    "print (7  >= 7)\n",
    "print (7  >  7)\n",
    "print (25 <= 7)\n",
    "print (25 <= 25.0)\n",
    "print (25 <  25.0)\n",
    "print (25 <  25.1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numerical comparisons are fairly straightforward, and you'll see that Python automatically does fairly sensible things:\n",
    "- Because it converts automatically between integers and floats, 25 and 25.0 are evaluated properly\n",
    "- As are 25 and 25.1 because the 'casting' of integers to floats turns 25 into 25.0 automatically\n",
    "\n",
    "But here are some slightly more complicated examples involving _string_ comparisons:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Nice, simple comparison\n",
    "print (\"A\" > \"B\")\n",
    "print (\"B\" > \"A\")\n",
    "\n",
    "# Something slightly trickier...\n",
    "print (\"A\" >  \"a\")\n",
    "print (\"A\" >= \"a\")\n",
    "print (\"A\" <  \"a\")\n",
    "\n",
    "# Trickier again...\n",
    "print (\"ab\" < \"abc\")\n",
    "\n",
    "# Hmmmmmm\n",
    "print (\"Aardvark\" < \"Ant\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Can you think why 'A' is less than 'a', and 'Aardvark' is less than 'Ant'?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### A challenge for you!\n",
    "\n",
    "Here we've deliberately left out or broken some code that _you_ need to fix!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Fix this code so that it returns True\n",
    "first_variable = 89.0\n",
    "second_variable = 9\n",
    "\n",
    "prit (first_variable % 80 ??? second_var)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Do the same here and then print \n",
    "# the output by casting the result\n",
    "# using the str() function.\n",
    "print (\"This is going to be: \" + ???( 90 ??? first_variable ))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Testing for Equality\n",
    "\n",
    "So we've seen the comparison operators that you probably still remember from high-school maths. But sometimes we don't want to test for _difference_, we want to test if two things are _the same_. In your maths class you probably just wrote $$x = y$$ and moved on to the next problem, but remember: one equals sign is already being used to assign values to variables! As in:\n",
    "\n",
    "```python\n",
    "my_var = 1\n",
    "```\n",
    "\n",
    "To test if something is exactly equal we can use the *equality comparison operator*, which is two equals signs together (*==*). This equality comparison returns `True` if the contents of two variables/results of two calculations are equal. That's a bit of a mouthful, but all we're saying is that we compare the left-hand side (LHS) of the equality operator (`==`) with the right-hand side (RHS) to see if they evaluate to the same answer.\n",
    "\n",
    "A _lot_ of new programmers make the mistake of writing `=` in their code when they wanted `==`, and it can be hard to track this one down. So always ask yourself: am I comparing two things, or assigning one to the other?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# This (=) assigns a value to a variable\n",
    "british_capital = \"London\"\n",
    "french_capital  = \"Paris\"\n",
    "\n",
    "# This (==) compares two variables\n",
    "print (british_capital == french_capital)\n",
    "\n",
    "# This is probably a mistake\n",
    "british_capital = french_capital\n",
    "print (british_capital)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### A challenge for you!\n",
    "\n",
    "Before you run the code in the next block, try to think through what _you_ expect each one to print out!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Is this True?\n",
    "print (2 == 34)\n",
    "\n",
    "# How about this?\n",
    "print (7 == 7)\n",
    "\n",
    "# How about this?\n",
    "print (\"Foo\" == \"Foo\")\n",
    "\n",
    "# And this?\n",
    "print (\"Foo\" == \"Bar\")\n",
    "\n",
    "# And this?\n",
    "print (10 % 3 == 3 / 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Testing for Inequality\n",
    "\n",
    "What if you want to check if two things are *different* rather than equal? Well then you'll need to use the *Not Equal (!=)* operator, which returns `True` when there's no equality between the conditions you are comparing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Reset the variables to their 'defaults'\n",
    "british_capital = \"London\"\n",
    "french_capital  = \"Paris\"\n",
    "\n",
    "# This time python is going to print True,\n",
    "# since we are comparing different things\n",
    "# using the Not Equal operator!\n",
    "print (british_capital != french_capital)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----\n",
    "# Conditions\n",
    "\n",
    "OK, so now we've seen comparisons and booleans, but why? Where are we going with this? Think back to the first notebook and the example of what is happening inside a computer: _if_ the user has clicked on the mouse _then_ we need to do something (e.g. change the colour of the button, open the web link, etc.). Everything that we've done up until now basically happened on a single line: _set_ this variable, _set_ that variable, print out the result of the _comparison_. \n",
    "\n",
    "Now we're going to step it up a level.\n",
    "\n",
    "To check a condition you will need to use a *statement* (i.e. [everything that makes up one or more lines of code line](https://stackoverflow.com/questions/4728073/what-is-the-difference-between-an-expression-and-a-statement-in-python) ) to see `if` that condition is True/False, in which case do one thing, or `else` do something else...\n",
    "\n",
    "Let's see that in action!\n",
    "\n",
    "## IF condition\n",
    "\n",
    "Let's start with a basic `if` statement. In Python you write it:\n",
    "\n",
    "```python\n",
    "if condition-to-check:\n",
    "   statement\n",
    "```\n",
    "\n",
    "So an `if` condition starts with the word `if` and ends with a colon (`:`).\n",
    "\n",
    "The statement is the code that we want the computer to run _if_ the `condition-to-check` comes out `True`. **However**, notice that the next line – the `statement` line – is indented. This is Python's way to define a *block of code*. \n",
    "\n",
    "A **block of code** means that we can run several lines of code _if_ the condition is True. As long as the code is indented then Python will treat it as code to run _only_ if the condition is True.\n",
    "\n",
    "Let's see a few examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Condition 1\n",
    "if 2 > 1:\n",
    "    print (\"> Condition #1\")\n",
    "\n",
    "# Condition 2\n",
    "if 1 > 2: \n",
    "    print (\"> Condition #2\")\n",
    "\n",
    "# Condition 3\n",
    "if \"Foo\" == \"Foo\":\n",
    "    print (\"> Condition #3\")\n",
    "    myVar = 1 + 5\n",
    "    print (\"     My var: \" + str(myVar))\n",
    "\n",
    "# Condition 4\n",
    "if \"Foo\" != \"Foo\":\n",
    "    print (\"> Condition #4\")\n",
    "    myVar = 1 + 5\n",
    "    print (\"     My var: \" + str(myVar))\n",
    "    \n",
    "print (\"Done.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "See how that works? Only conditions \\#1 and \\#3 were printed out, \\#2 and \\#4 were skipped over entirely!\n",
    "\n",
    "Let's take these in order:\n",
    "1. 2 _is_ greater than 1, so the `condition-to-check` returns True and Python then looks at the next line to see what it should do next.\n",
    "2. 1 _is not_ greater than 2, so the `condition-to-check` returns False. Python then skips the next _two_ indented lines which form part of the _code block_. It's the indentation that tells Python they're still part of the same code block. That _entire code block_ would only be executed _if_ the `condition-to-check` had been True.\n",
    "3. \"Foo\" is the same as \"Foo\", so this condition is True. Python then runs the next three lines because the indentation tells Python that they are all part of the same code block. Notice that we can even do things like set new variables in a code block.\n",
    "4. \"Foo\" is _still_ the same as \"Foo\", but we were testing if they were _not equal_ (`!=`) and so this condition is False. This time Python skips over the three lines and moves straight to the last print statement.\n",
    "5. Notice that the last print (`\"Done.\"`) always runs, no matter what the previous conditions were, because it is _not indented_ and so is not part of a _code block_.\n",
    "\n",
    "_Note_: Other languages such as C/C++ use curly braces `{...}` around a block, just in case you find other languages in examples when Googling for help.\n",
    "\n",
    "_Sidenote_: How much should you indent? Although the [official specification](https://www.python.org/dev/peps/pep-0008/#tabs-or-spaces) specifies *4 spaces*, quite a few people indent using *one tab* instead. Technically, there is no difference _as long as you are consistent_ (See [this discussion](http://stackoverflow.com/questions/1125653/python-4-whitespaces-indention-why)). This apparently trivial issue is the sort of thing that leads to all kinds of heated argument (like whether you prefer Mac OSX or Windows; OSX is better, obviously). It's such a famous aspect of the programming world that it even featured in an episode of the sit-com [Silicon Valley](https://en.wikipedia.org/wiki/Silicon_Valley_(TV_series)): \n",
    "\n",
    "<a href=\"http://www.youtube.com/watch?feature=player_embedded&v=cowtgmZuai0\" target=\"_blank\"><img src=\"http://img.youtube.com/vi/cowtgmZuai0/0.jpg\" \n",
    "alt=\"Silicon Valley\" width=\"480\" height=\"360\" border=\"10\" /></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Let's work with another example\n",
    "london_population = 8600000\n",
    "paris_population  = 2400000 \n",
    "\n",
    "if london_population > paris_population:\n",
    "    print (\"London is larger than Paris\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### A challenge for you!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# What would this code print?\n",
    "if london_population > 2000000:\n",
    "    print (str(london_population) + \" is more than 2 million people\")\n",
    "\n",
    "if london_population < 10000000:\n",
    "    print (str(london_population) + \" is less than 10 million people\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Complete the missing code, while\n",
    "# also fixing the broken bits!\n",
    "\n",
    "if (london_population % 8000000) != 600000 ???\n",
    "print (\"Good job\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ELSE condition\n",
    "\n",
    "Of course, only being able to use _if_ would be pretty limiting. Wouldn't it be handy to be able to say \"_if_ x is True: do one thing; otherwise do something else\". Well you can! When you want to run a different block of code depending on whether something is True or not, then you can use the `else` statement (_only_ following a first `if`).\n",
    "\n",
    "Here's an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "newyork_population = 8400000 \n",
    "\n",
    "if london_population < newyork_population:\n",
    "    largest_city = \"New York\" \n",
    "else:\n",
    "    largest_city = \"London\"\n",
    "    \n",
    "print (\"The largest city is \" + largest_city)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see from the example above, the `if: else:` statement allows us to account for multiple outcomes when checking the _logic_ of a condition.\n",
    "\n",
    "Notice how the `else` syntax is similar to the `if` statement: use the colon, and indent.\n",
    "\n",
    "Also pay attention to the fact that not *all* of our code has run. Only the block after the `else` was run. So:\n",
    "- _if_ returned False (London's population is not less than that of New York)\n",
    "- So the _else_ block ran instead.\n",
    "\n",
    "This is why the `largestCity` variable was set to \"London\" and not \"New York\". After the `if: else:` sequence the code goes back to its normal flow, and all the remaining lines will be executed.\n",
    "\n",
    "The `if: else:` statement is like a fork in the road: you can take one road, or the other, but not both at the same time."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### A challenge for you!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Fix the code below so that it prints out\n",
    "# \"London's population is above my threshold\".\n",
    "mythreshold = 1000000\n",
    "if london_population <= mythreshold ???\n",
    "    print (\"London's population is below my threshold\")\n",
    "???:\n",
    "    print (\"London's population is above my threshold\")\n",
    "    \n",
    "print (\"And now back to normal code execution.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ELIF condition\n",
    "\n",
    "Once again: so far, so good. But what if you need to have multiple forks? Well, then you can use a sequence of *statements* that sounds like \"IF this happens do this, ELSE IF this second condition holds do that, ELSE IF a third condition is true perform this other ELSE do finally this...\"\n",
    "\n",
    "The operator we are going to use is `elif`, the lazy version of `ELSE IF`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Like so:\n",
    "myUpperBoundary = 12000000\n",
    "myLowerBoundary = 2000000\n",
    "\n",
    "if london_population < myUpperBoundary:\n",
    "    print (largest_city + \" is below my upper threshold.\")\n",
    "\n",
    "elif london_population > myLowerBoundary:\n",
    "    print (largest_city + \" is above my lower threshold.\")\n",
    "\n",
    "elif london_population != 340000: \n",
    "    print (largest_city + \" population is not equal to 340,000.\")\n",
    "    \n",
    "else:\n",
    "    print (\"How did I get here?\")\n",
    "    \n",
    "print (\"And now back to normal code execution.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Why didn't the output look like this:\n",
    "<pre>\n",
    "London is below my upper threshold.\n",
    "London population is not equal to 340,000.\n",
    "How did I get here?\n",
    "And now back to normal code execution.\n",
    "</pre>\n",
    "\n",
    "This a tricky one: the _first_ thing that evaluates to `True` (that London is below the upper threshold) is the one that 'wins'. Computers are also lazy in their own way: since it found that the answer to the first `elif` was True it didn't bother to look at the second `elif` and the `else`, it _only_ ran the _one_ code block.\n",
    "\n",
    "#### A challenge for you!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# What will be the output of the code?\n",
    "# Complete the missing bits and then run the code!\n",
    "london_population = 10\n",
    "??? london_population <= 9:\n",
    "    print (\"First case\")\n",
    "??? london_population > 99: \n",
    "    print (\"Second case\")\n",
    "??? london_population == 4:\n",
    "    print (\"Third case\")\n",
    "??? london_population != 8.6???\n",
    "    print (\"Fourth case - you can go on adding more cases if you want!\")\n",
    "\n",
    "print (\"Well, looks like none of the above statements were true!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Boolean Logic\n",
    "----\n",
    "\n",
    "The very logical Prof. George Boole, circa 1860:\n",
    "\n",
    "![Photo of Boole](https://upload.wikimedia.org/wikipedia/commons/c/ce/George_Boole_color.jpg \"Boole\")\n",
    "\n",
    "Boolean logic and [Boolean algebra](https://en.wikipedia.org/wiki/Boolean_algebra) have to do with _set theory_ but also lie at the heart of the modern computer! Remember that in notebook 1 we saw that a computer works by combining `AND`, `OR`, `XOR` and `NAND` circuits to produce ever more complex calculations? Well, we also use this a lot in programming!\n",
    "\n",
    "In Python there are [three boolean logic operators](https://docs.python.org/2/library/stdtypes.html#boolean-operations-and-or-not), these are (in ascending order of priority): `or`, `and`, and `not`.\n",
    "\n",
    "We'll look at these in more detail in a second, but here's the 'cheat sheet':\n",
    "- OR: _if either A OR B are True_ then run the following code block...\n",
    "- AND: _if A AND B are True_ then run the following code block...\n",
    "- NOT: _if NOT(A) is True_ (where A is _False_) then run the following code block...\n",
    "\n",
    "It might help you to take a look at these Venn diagrams (source: [Wikimedia Commons](https://en.wikipedia.org/wiki/File:Vennandornot.svg)) that express the same three operations in graphical form. Imagine that _x_ and _y_ are both `conditions-to-test`... The left one is _AND_ because it is only the combination of _x AND y_ that is red; the centre one is _OR_ because it represents any combination of _x OR y_ being red; the rightmost is _NOT_ because it is the opposite of _x_ that is red.\n",
    "\n",
    "![Venn](https://upload.wikimedia.org/wikipedia/commons/thumb/a/ae/Vennandornot.svg/640px-Vennandornot.svg.png \"Venn Diagram\")\n",
    "\n",
    "OK, let's look at it in Python.\n",
    "\n",
    "## AND \n",
    "\n",
    "The `and` operator (just like in plain English!) is used when two conditions must both be True at the same time. So it has _two_ arguments and returns `True` if, and only if (_iff_), both of them are `True`. Otherwise it returns `False`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "condition1 = 2 < 4 # True\n",
    "condition2 = (6/3) == 2 # Also True\n",
    "\n",
    "if (condition1) and (condition2): # Both are true\n",
    "    print (\"1. Both conditions are true!\")\n",
    "else:\n",
    "    print (\"1. Mmm... something's wrong!\")\n",
    "    \n",
    "if condition1 and 6.0/5 == 1:\n",
    "    print (\"2. Both conditions are true!\")\n",
    "else:\n",
    "    print (\"2. Mmm... something's wrong!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## OR \n",
    "\n",
    "The `or` operator is used when we don't care which condition is True, as long as one of them is! So if *either* (or *both*!) conditions are `True`, then the operator returns `True`. Only if _both_ are `False` does it evaluate to  `False`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "condition1 = 2 < 4 # True\n",
    "condition2 = (6/3) != 2 # False\n",
    "\n",
    "if (condition1) or (condition2):\n",
    "    print (\"1. Both conditions are true!\")\n",
    "else:\n",
    "    print (\"1. Mmm... something's wrong!\")\n",
    "\n",
    "if 2 > 4 and 6.0/5 == 1:\n",
    "    print (\"2. Both conditions are true!\")\n",
    "else:\n",
    "    print (\"2. Mmm... something's wrong!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### A challenge for you!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Try to change the values of conditions\n",
    "# and see the different outcomes, but first\n",
    "# you'll need to fix the Syntax Errors and \n",
    "# the Exceptions!\n",
    "condition1 = 2 < 4\n",
    "condition2 ??? (6/3) != 2\n",
    "\n",
    "if (condition1) ??? (condition2):\n",
    "    print (\"Either (or both) conditions are true!\")\n",
    "elif:\n",
    "print (\"mmm..they must be false at the same time\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NOT \n",
    "\n",
    "Lastly, the `not` operator allows you to reverse (or invert, if you prefer) the value of a Boolean. So it turns a `True` into a `False` and vice-versa."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Like so:\n",
    "conditionInverted = not (2 == 2) # Should be True\n",
    "print (conditionInverted)\n",
    "\n",
    "# And:\n",
    "conditionInverted = not (\"Foo\" == \"Bar\") # Should be False\n",
    "print (conditionInverted)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### A challenge for you!\n",
    "\n",
    "Can you guess the result of this code _before_ you run it?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "if not conditionInverted:\n",
    "   print(\"I'm True\")\n",
    "elif not (4%3  != 1):\n",
    "   print(\"2\")\n",
    "else:\n",
    "   print(\"99\" == str(99)+1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Code (Applied Geo-Example)\n",
    "---\n",
    "\n",
    "The aim of the exercise is to build a tiny program that allows a user to choose a given London borough from a list, and get in return both its total population and a link to a OpenStreetMap that pin points its location.\n",
    "\n",
    "We are going to introduce a function called `input` that, as the name implies, takes an input from the user (interactively, that is!). We'll use it to interact with the user of our program. The input is going to be saved in a variable called `user_input`.\n",
    "\n",
    "I've provided a basic scaffolding of the code. It covers the case where the user choses the City borough, or inputs something wrong. Complete the script to cover the remaining cases using the scaffolded code.\n",
    "\n",
    "HINT: You will need to use `elif` statements to check for the various cases that use user might input.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# variable with the City's total population\n",
    "city_of_London = 7.375\n",
    "# City's map marker\n",
    "city_coords = \"http://www.openstreetmap.org/?mlat=51.5151&mlon=-0.0933#map=14/51.5151/-0.0933\"\n",
    "\n",
    "# Other use cases\n",
    "# camden = 220.338\n",
    "# camden_coords = \"http://www.openstreetmap.org/?mlat=51.5424&mlon=-0.2252#map=12/51.5424/-0.2252\"\n",
    "# hackney = 246.270\n",
    "# hackney_coords = \"http://www.openstreetmap.org/?mlat=51.5432&mlon=-0.0709#map=13/51.5432/-0.0709\"\n",
    "# lambeth = 303.086\n",
    "# lambeth_coords = http://www.openstreetmap.org/?mlat=51.5013&mlon=-0.1172#map=13/51.5013/-0.1172\n",
    "\n",
    "# Let's ask the user for some input\n",
    "# and store his answer\n",
    "user_input = input(\"\"\"\n",
    "Choose a neighbourhood by type the corresponding number:\n",
    "1- City of London\n",
    "2- Lambeth\n",
    "3- Camden\n",
    "4- Hackney\n",
    "\"\"\")\n",
    "\n",
    "# Arbitrarily assign case 1 to City of London borough\n",
    "\n",
    "if (user_input == '1'):    \n",
    "    chosen_borough = city_of_London\n",
    "    borough_coordinates = city_coords \n",
    "    # print the output\n",
    "    # notice we are casting the user answer to string\n",
    "    print (\"You have chosen number : \"+ str(user_input))\n",
    "    print (\"The corresponding borough has a population of \"+ str(chosen_borough) +\" thousand people\")\n",
    "    print (\"Visit the borough clicking here: \" + borough_coordinates)\n",
    "    # ---------------\n",
    "    # add more cases here...\n",
    "    # ---------------\n",
    "else:\n",
    "    print (\"That's not in my system. Please try again!\")\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "**Congratulations on finishing your fourth notebook!**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### Further references:\n",
    "\n",
    "General list or resources\n",
    "- [Awesome list of resources](https://github.com/vinta/awesome-python)\n",
    "- [Python Docs](https://docs.python.org/2.7/tutorial/introduction.html)\n",
    "- [HitchHiker's guide to Python](http://docs.python-guide.org/en/latest/intro/learning/)\n",
    "- [Python for Informatics](http://www.pythonlearn.com/book_007.pdf)\n",
    "- [Learn Python the Hard Way](http://learnpythonthehardway.org/book/)\n",
    "- [CodeAcademy](https://www.codecademy.com/learn/python)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*The content and structure of this teaching project itself is licensed under the [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 license](https://creativecommons.org/licenses/by-nc-sa/4.0/) , and the contributing source code is licensed under [The MIT License](https://opensource.org/licenses/mit-license.php).   *"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}