02 Control statements.ipynb

{
  "cells": [
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "# Introduction\n\nControl statements allow a program to change what it does depending on input or other data.\nTypical flows in a computer program involve structures like:\n\n- if 'X' do task 'A', else if 'Y' do task 'B'\n- perform the task 'A' 'N' times\n- perform the task 'B' until 'X' is true\n\nThese flows are implemented using what are called 'control statements'. They are also known as branching - the path a program follows depends on the input data. Control statements are a major part of all non-trivial computer programs.\n\n\n## Objectives\n\n- Introduce Boolean types\n- Introduce comparison operators\n- Learn to use control statements\n\n\n## Example of a control statement in pseudo code\n\nAn electric window opener, attached to a rain sensor and a temperature \ngauge, might be controlled by the following program:\n\n    if raining:  # If raining, close the window\n        close_window()\n    else if temperature > 26:  # If the temperature is over 26 deg, open window\n        open_window()\n    else if temperature < 19:  # If the temperature is below 19 deg, close window\n        close_window()\n    else:  # Otherwise, do nothing and leave window as it is\n        pass\n\nIt is easy to imagine the program being made more sophisticated using the time of the day and the day of the week, or being attached to a smoke alarm.\n\nWe will look at different types of control statements, but first we need to introduce boolean types and comparison operators."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "# Booleans\n\nBefore starting with control statements, we need to introduce booleans.\nA Boolean is a type of variable that can take on one of two values - true or false."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "a = True\nprint(a)\n\na = False\nprint(a)",
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "text": "True\nFalse\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Booleans are used extensively in control statements."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "# Comparison operators\n\nWe often want to check in a program how two variables are related to each other, for example if one is less than the other, or if two variables are equal. We do this with 'comparison operators', such as `<`, `<=`, `>`, `>=` and `==`. \n\nBelow is an example checking if a number `a` is less than or greater than a number `b`:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "a = 10.0\nb = 9.9\nprint(a < b)\nprint(a > b)",
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": "False\nTrue\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Equality is checked using '`==`', and '`!=`' is used to test if two variables are not equal. Below are some examples to read through."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "a = 14\nb = -9\nc = 14\n\n# Check if a is equal to b \nprint(\"Is a equal to b?\")\nprint(a == b)\n\n# Check if a is equal to c \nprint(\"Is a equal to c?\")\nprint(a == c)\n\n# Check if a is not equal to c \nprint(\"Is a not equal to c?\")\nprint(a != c)\n\n# Check if a is less than or equal to b \nprint(\"Is a less than or equal to b?\")\nprint(a <= b)\n\n# Check if a is less than or equal to c \nprint(\"Is a less than or equal to c?\")\nprint(a <= c)\n\n# Check if two colours are the same\ncolour0 = 'blue'\ncolour1 = 'green'\nprint(\"Is colour0 the same as colour1?\")\nprint(colour0 == colour1)",
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "text": "Is a equal to b?\nFalse\nIs a equal to c?\nTrue\nIs a not equal to c?\nFalse\nIs a less than or equal to b?\nFalse\nIs a less than or equal to c?\nTrue\nIs colour0 the same as colour1?\nFalse\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "# Boolean operators\n\nIn the above we have only used one comparison at a time. Boolean operators allow us to 'string' together multiple checks using the operators '`and`', '`or`' and '`not`'.\nThe operators '`and`' and '`or`' take a boolean on either side, and the code\n```python\nX and Y\n```\nwill evaluate to `True` if `X` *and* `Y` are both true, and otherwise will evaluate to `False`. The code\n```python\nX or Y\n```\nwill evaluate to `True` if `X` *or* `Y` is true, and otherwise will evaluate to `False`.\nHere are some examples:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "# If 10 < 9 (false) and 15 < 20 (true) -> false\nprint(10 < 9 and 15 < 20)",
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "text": "False\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "# Check if 10 < 9 (false) or 15 < 20 (true) -> true\nprint(10 < 9 or 15 < 20)",
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "text": "True\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "The meaning of the statement becomes clear if read it left-to-right.\n\nBelow is a very simple example that, given the current time of day reports \n\n- true if it is lunch time; and \n- true if we are outside of working hours."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "time = 13.05  # The current time\n\nwork_starts = 8.00  # Start of working day \nwork_ends = 17.00  # End of working day\n\nlunch_starts = 13.00  # Start of lunchtime\nlunch_ends = 14.00  # End of lunchtime\n\n# Check if it's lunch time\nprint(\"Is it lunchtime?\")\nis_lunchtime = time >= lunch_starts and time < lunch_ends\nprint(is_lunchtime)\n\n# Check if we're outside of working hours\nprint(\"Are we outside of working hours?\")\noutside_working_hours = time < work_starts or time >= work_ends\nprint(outside_working_hours)",
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "text": "Is it lunchtime?\nTrue\nAre we outside of working hours?\nFalse\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Note that the comparison operators (`>=`, `<=`, `<` and `>`) are evaluated before the Boolean operators (`and`, `or`).\n\nIn Python, the '`not`' operator negates a statement, e.g.:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "# Is 12 *not* less than 7 -> true\na = 12\nb = 7\nprint(not a < b)",
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "text": "True\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Only use '`not`' when it makes a program easy to read. For example,"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "print(not 12 == 7)",
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "text": "True\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "is not good practice. Better is"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "print(12 != 7)",
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "text": "True\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Here is a double-negation, which is very cryptic (and poor programming):"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "print(not not 12 == 7)",
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "text": "False\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "## Multiple comparison operators\n\nThe examples so far use at most two comparison operators. In some cases we might want to perform more checks. We can control the order of evaluation using brackets. For example, if we want to check if a number is strictly between 100 and 200, or between 10 and 50:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "value = 150.5\nprint ((value > 100 and value < 200) or (value > 10 and value < 50)) ",
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "text": "True\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "The two checks in the brackets are evaluated first (each evaluates to `True` or `False`), and then the '`or`' checks if one of the two is true."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "# Control statements\n\nNow that we've covered comparison, we are ready to look at control statements. These are a central part of computing. Here is a control statement in pseudo code:\n\n    if A is true\n        Perform task X (only)\n    else if B is true\n        Perform task Y (only)\n    else   \n        Perform task Z (only)\n\nThe above is an 'if' statement. Another type of control statement is\n\n    do task X 10 times\n    \nWe make this concrete below with some examples."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "## `if` statements\n\nBelow is a simple example that demonstrates the Python syntax for an if-else control statement. \nFor a value assigned to a variable `x`, the program prints a message and modifies `x`.\nThe message and the modification of `x` depend on the initial value of `x`:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "x = -10.0  # Initial x value\n\nif x > 0.0:  \n    print('Initial x is greater than zero')\n    x -= 20.0\nelif x < 0.0:  \n    print('Initial x is less than zero')\n    x += 21.0\nelse: \n    print('Initial x is not less than zero and not greater than zero, therefore it must be zero')\n    x *= 2.5\n\n# Print new x value\nprint(\"New x value:\", x)",
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "text": "Initial x is less than zero\nNew x value: 11.0\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Try changing the value of `x` and re-running the cell to see the different paths the code can follow."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "We now dissect the control statement example. The control statement begins with an `if`, followed by the expression to check, followed by '`:`'\n```python\nif x > 0.0:\n```\nBelow that is a block of code, indented by four spaces, that is executed if the check (`x > 0.0`) is true:\n````python\n    print('Initial x is greater than zero')\n    x -= 20.0\n````\nand in which case the program will then move beyond the end of the control statement. If the check evaluates to false, then the `elif` (else if) check  \n```python\nelif x < 0.0:\n    print('Initial x is less than zero')\n    x += 21.0\n```      \nis performed, and if true '`print('x is less than zero')`' is executed and the control block is exited. The code following the `else` statement is executed\n```python\nelse:\n    print('Initial x is not less than zero and not greater than zero, therefore it must be zero')\n```\nif none of the preceding statements were true."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### Example: currency trading\n\nA currency trader makes a commission by selling US dollars to travellers at a rate below the market rate. The mark-down multiplier they apply is show below.  \n\n|Amount (GBP)                                |reduction on market rate |\n|--------------------------------------------|-------------------------|\n| Less than $100$                            | 0.9                     |   \n| From $100$ and less than $1,000$           | 0.925                   |   \n| From $1,000$ and less than $10,000$        | 0.95                    |   \n| From $10,000$ and less than $100,000$      | 0.97                    |   \n| Over $100,000$                             | 0.98                    |   \n\nThe currency trader incurs extra costs for handling cash over electronic transactions, so for cash transactions they retain an extra 10% after conversion. \n\nAt the current market rate 1 GBP is 1.33153 USD."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "GBP  = 15600.05  # The amount in GBP to be changed into USD\ncash = True  # True if selling cash, otherwise False\n\nmarket_rate = 1.33153  # 1 GBP is worth this many dollars at the market rate\n\n# Apply the appropriate reduction depending on the amount being sold\nif GBP < 100:\n    USD = 0.9*market_rate*GBP\nelif GBP < 1000:  \n    USD = 0.925*market_rate*GBP\nelif GBP < 10000:\n    USD = 0.95*market_rate*GBP\nelif GBP < 100000:\n    USD = 0.97*market_rate*GBP\nelse:\n    USD = 0.98*market_rate*GBP\n\nif cash:\n    USD *= 0.9  # recall that this is shorthand for USD = 0.9*USD \n    \nprint(\"Amount in GBP sold:\", GBP)\nprint(\"Amount in USD purchased:\", USD)\nprint(\"Effective rate:\", USD/GBP)",
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "text": "Amount in GBP sold: 15600.05\nAmount in USD purchased: 18133.898885284503\nEffective rate: 1.1624256900000003\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "## `for` loops\n\nA `for` loop is a block that repeats an operation a specified number of times (loops). The concept is rich, but we start with the simplest and most common usage:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "for n in range(4):\n    print(\"----\")\n    print(n, n**2)",
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "text": "----\n0 0\n----\n1 1\n----\n2 4\n----\n3 9\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "The above executes 4 loops, over the integers 0, 1, 2 and 3. The statement \n```python\nfor n in range(4):\n```\nsays that we want to loop over four integers, and by default it starts from zero\n(see https://docs.python.org/3/library/stdtypes.html#range for the documentation for `range`). \nThe value of `n` is incremented in each loop iteration. The code we want to execute inside the loop is indented four spaces: \n```python\n    print(\"----\")\n    print(n, n**2)\n```\nThe loop starts from zero and does not include 4 - `range(4)` is a shortcut for `range(0, 4)`. We can change the starting value if we need to:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "for i in range(-2, 3):\n    print(i)",
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "text": "-2\n-1\n0\n1\n2\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "The loop starts at -2, but does not include 3. If we want to step by three rather than one:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "for n in range(0, 10, 3):\n    print(n)",
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "text": "0\n3\n6\n9\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### Example: conversion table from degrees Fahrenheit to degrees Celsius\n\nWe can use a `for` loop to create a conversion table from degrees Fahrenheit ($T_F$) to degrees Celsius ($T_c$), using the formula:\n\n$$\nT_c = 5(T_f - 32)/9\n$$\n\nComputing the conversion from -100 F to 200 F in steps of 20 F (not including 200 F):"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "print(\"T_f,    T_c\")\nfor Tf in range(-100, 200, 20):\n    print(Tf, (Tf - 32)*5/9)",
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "text": "T_f,    T_c\n-100 -73.33333333333333\n-80 -62.22222222222222\n-60 -51.111111111111114\n-40 -40.0\n-20 -28.88888888888889\n0 -17.77777777777778\n20 -6.666666666666667\n40 4.444444444444445\n60 15.555555555555555\n80 26.666666666666668\n100 37.77777777777778\n120 48.888888888888886\n140 60.0\n160 71.11111111111111\n180 82.22222222222223\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "## `while` loops\n\nWe have seen that `for` loops perform an operation a specified number of times. A `while` loop performs a task while a specified statement is true. For example:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "print(\"Start of while statement\")\nx = -2\nwhile x < 5:\n    print(x)\n    x += 1  # Increment x\nprint(\"End of while statement\")",
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "text": "Start of while statement\n-2\n-1\n0\n1\n2\n3\n4\nEnd of while statement\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "The body of the `while` statement, which follows the `while` statement and is indented four spaces, is executed and repeated until `x < 5` is `False`.\n\nIt can be quite easy to crash your computer using a `while` loop. E.g.,\n```python\nx = -2\nwhile x < 5:\n    print(x)\n```\nwill continue indefinitely since `x < 5 == False`  will never be satisfied. This is known as an *infinite loop*. It is usually good practice to add checks to avoid getting stuck in an infinite loop, e.g. specify a maximum number of permitted loops.\n\nThe above example could have been implemented using a `for` loop and a `for` loop would be preferred in this case. The following is an example of where a `while` is appropriate:"
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "x = 0.9\nwhile x > 0.001:\n    # Square x (we could have used the shorthand x *= x)\n    x = x*x\n    print(x)",
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "text": "0.81\n0.6561000000000001\n0.43046721000000016\n0.18530201888518424\n0.03433683820292518\n0.001179018457773862\n1.390084523771456e-06\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "since we might not know beforehand how many steps are required before `x > 0.001` becomes false. \n\nIf $x \\ge 1$, the above would lead to an infinite loop. To make a code robust, it would be good practice to check that $x < 1$ before entering the `while` loop."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "## `break`, `continue` and `pass`\n\n### `break`\n\nSometimes we want to break out of a `for` or `while` loop. Maybe in a `for` loop we can check if something is true, and then exit the loop prematurely, e.g."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "for x in range(10):\n    print(x)\n    if x == 5:\n        print(\"Time to break out\")\n        break",
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "text": "0\n1\n2\n3\n4\n5\nTime to break out\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Below is a program for finding prime numbers that uses a `break` statement. Take some time to understand what it does. It might be helpful to add some print statements to understand the flow."
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "N = 50  # Check numbers up 50 for primes (excludes 50)\n\n# Loop over all numbers from 2 to 50 (excluding 50)\nfor n in range(2, N):\n\n    # Assume that n is prime\n    n_is_prime = True\n\n    # Check if n can be divided by m, where m ranges from 2 to n (excluding n)\n    for m in range(2, n):\n         if n % m == 0:  # This is true if the remainder for n/m is equal to zero\n            # We've found that n is divisable by m, so it can't be a prime number. \n            # No need to check for more values of m, so set n_is_prime = False and\n            # exit the 'm' loop.\n            n_is_prime = False\n            break\n\n    #  If n is prime, print to screen        \n    if n_is_prime:\n        print(n)",
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "text": "2\n3\n5\n7\n11\n13\n17\n19\n23\n29\n31\n37\n41\n43\n47\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "Try modifying the code for finding prime numbers such that it finds the first $N$ prime numbers (since you do not know how many numbers you need to check to find $N$ primes, use a `while` loop)."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### `continue`\n\nSometimes we want to go prematurely to the next iteration in a loop, skipping the remaining code.\nFor this we use `continue`. Here is an example that loops over 20 numbers (0 to 19) and checks if the number is divisible by 4. If it is divisible by 4 it prints a message before moving to the next value. If it is not divisible by 4 it advances the loop. "
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "for j in range(20):\n    if j % 4 == 0:  # Check remained of j/4\n        continue  # jump to next iteration over j\n    print(\"Number is not divisible by 4:\", j)",
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "text": "Number is not divisible by 4: 1\nNumber is not divisible by 4: 2\nNumber is not divisible by 4: 3\nNumber is not divisible by 4: 5\nNumber is not divisible by 4: 6\nNumber is not divisible by 4: 7\nNumber is not divisible by 4: 9\nNumber is not divisible by 4: 10\nNumber is not divisible by 4: 11\nNumber is not divisible by 4: 13\nNumber is not divisible by 4: 14\nNumber is not divisible by 4: 15\nNumber is not divisible by 4: 17\nNumber is not divisible by 4: 18\nNumber is not divisible by 4: 19\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### `pass`\n\nSometimes we need a statement that does nothing. It is often used during development where syntactically some code is required but which you have not yet written. For example:  "
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "for x in range(10):\n    if x < 5:\n        # TODO: implement handling of x < 5 when other cases finished \n        pass\n    elif x < 9:\n        print(x*x)\n    else:\n        print(x)",
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "stream",
          "text": "25\n36\n49\n64\n9\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "It can also help readability. Maybe in a program there is nothing to be done, but someone reading the code might reasonably think that something should be done and suspect a bug. Using `pass` says to the reader that it was the programmer's intention that nothing should be done."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "## Infinite loops: cause and guarding against\n\nA common bug, especially when using `while` statements, is the [infinite loop](https://en.wikipedia.org/wiki/Infinite_loop). This is when a loop is entered but never terminates (exits).\nInfinite loops can render a system unresponsive, sometimes requiring a shutdown to restore function.\n\nIt is good practice, espeically when learning, to add guards against infinite loops. For example, "
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": "x = 0.0\n\ncounter = 0\nwhile x < 0.05:\n\n    # Guard against infinite loop\n    counter += 1\n    if counter > 2000:\n        print(\"Loop count exceeded 2000. Exiting\")\n        break",
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "text": "Loop count exceeded 2000. Exiting\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "# Exercises\n\nComplete now the [02 Exercises](Exercises/02%20Exercises.ipynb) notebook."
    }
  ],
  "metadata": {
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3",
      "language": "python"
    },
    "language_info": {
      "mimetype": "text/x-python",
      "nbconvert_exporter": "python",
      "name": "python",
      "pygments_lexer": "ipython3",
      "version": "3.5.4",
      "file_extension": ".py",
      "codemirror_mode": {
        "version": 3,
        "name": "ipython"
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 1
}