06-flow-of-control.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "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.7.3"
    },
    "colab": {
      "name": "06-flow-of-control.ipynb",
      "provenance": []
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DgHhuakFNo0F"
      },
      "source": [
        "# 7PAVITPR: Introduction to Statistical Programming\n",
        "# Python practical 6\n",
        "\n",
        "_Angus Roberts<br/>\n",
        "Department of Biostatistics and Health Informatics<br/>\n",
        "Institute of Psychiatry, Psychology and Neuroscience<br/>\n",
        "King's College London<br/>_\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FdZ8MnMfNo0G"
      },
      "source": [
        "# Flow of control: if, while, for, and range\n",
        "\n",
        "Python's main control statements are:\n",
        "- `if`\n",
        "- `while`\n",
        "- `for`\n",
        "\n",
        "`if` and `while` are very similar to their counterparts in other languages. `for` behaves a little differently, as we will explain later.\n",
        "\n",
        "We will also cover two built-in functions that can be used to extend the use of `for`:\n",
        "- `range()`\n",
        "- `enumerate()`\n",
        "\n",
        "Python also has statements to break out of and force continuation of `while` and `for` control loops. We will not cover these - see the [Python tutorial](https://docs.python.org/3/tutorial/controlflow.html#break-and-continue-statements-and-else-clauses-on-loops) for details.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nAiklpr_No0G"
      },
      "source": [
        "### Indentation\n",
        "\n",
        "When defining control of flow, we need to know which statements a loop (`for` or `while`) or a condition (`if`) applies to. R (and some other languages) delineate these blocks of code with pairs of curly braces `{}`:\n",
        "\n",
        "`while (test_1) {\n",
        "  statement_a\n",
        "  if (test_2) {\n",
        "    statement_b\n",
        "    statement_c\n",
        "  }\n",
        "}`\n",
        "\n",
        "In these languages:\n",
        "\n",
        "- The control statement (in this case `while` and `if`) applies to everything in their following braces.\n",
        "- Any whitespace or indentation before each line is not neccesary, and has no meaning to the program interpreter. It is a convention, and there only to aid readability\n",
        "\n",
        "In Python, whitespace matters - it is meaningful.\n",
        "\n",
        "- No braces are used\n",
        "- Instead the amount of indentation determines the block of code\n",
        "- All lines with the same amount of indentation are in the same block\n",
        "- A colon is used at the end of a test, to signal that an associated block starts on the next line\n",
        "\n",
        "The above R code in Python is:\n",
        "\n",
        "`while test_1:\n",
        "  statement_a\n",
        "  if test_2:\n",
        "    statement_b\n",
        "    statement_c`\n",
        "    \n",
        "\n",
        "## <font color=green>💬 Discussion point</font>\n",
        "Can you think of any advantages or disadvantages with Python's meaningful whitespace approach?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CGE2gIWgNo0H"
      },
      "source": [
        "### If statements\n",
        "\n",
        "The simplest form of the `if` in Python is:\n",
        "\n",
        "`if test:\n",
        "  statement\n",
        "else:\n",
        "  statement`\n",
        "  \n",
        "## <font color=green>❓ Question</font>\n",
        "\n",
        "Write an if statement to take an integer input from a user, and print out whether the integer is even or odd. You can make use of the following:\n",
        "\n",
        "- the `input()` function, which takes input from the user (STDIN)\n",
        "- the `int()` function, which casts a value to an integer\n",
        "- the `%` operator, which finds the remainder\n",
        "- the fact that zero has a truth value of false\n",
        "\n",
        "\n",
        "## <font color=green>⌨️ Your answer</font>\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MQJCuDRKNo0H"
      },
      "source": [
        "# Uncomment and complete the lines below to give your answer\n",
        "\n",
        "# value = \n",
        "# if test:\n",
        "#    print('odd')\n",
        "#else:\n",
        "#    print('even')\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Qm0SWpA7No0K"
      },
      "source": [
        "__Multiple conditions in an if statement__\n",
        "\n",
        "What if we want to carry out multiple tests? We could nest our if statements, like this:\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1MS1pGdPNo0L"
      },
      "source": [
        "value = input('Enter a character: ')\n",
        "if value == 'c':\n",
        "    print('cytosine')\n",
        "else:\n",
        "    if value == 'g':\n",
        "        print('guanine')\n",
        "    else:\n",
        "        if value == 't':\n",
        "            print('thymine')\n",
        "        else:\n",
        "            print('something else')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MQIkaKfYNo0N"
      },
      "source": [
        "But this will get tedious and hard to read very quickly. Instead, we can chain lots of tests together with `elif`, which is similar to `else if` in R and java. Run the example below. Note how the final `else` catches any value not covered by the previous tests:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kTIjYs_gNo0N"
      },
      "source": [
        "value = input('Enter a character: ')\n",
        "if value == 'c':\n",
        "    print('cytosine')\n",
        "elif value == 'g':\n",
        "    print('guanine')\n",
        "elif value == 't':\n",
        "    print('thymine')\n",
        "else:\n",
        "    print('something else')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "N1Nn014tNo0P"
      },
      "source": [
        "## <font color=green>❓ Question</font>\n",
        "\n",
        "Write an if / elif / else statement to take an integer input from a user, and print out whether the integer is zero, negative, positive even or positive odd.\n",
        "\n",
        "## <font color=green>⌨️ Your answer</font>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qL8s_sSHNo0P"
      },
      "source": [
        "# Uncomment and complete the lines below to give your answer\n",
        "\n",
        "# value = \n",
        "# if test:\n",
        "#    print('zero')\n",
        "# elif test:\n",
        "#    print('negative')\n",
        "# etc etc\n",
        "# else:\n",
        "# etc etc"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7UQvM0kFNo0R"
      },
      "source": [
        "### While loops\n",
        "\n",
        "`while` loops allow you to carry out some block of statements until a condition is no longer met. This is called the _termination condition_. It is most  useful when you don't know how many times you will need to repeat some statements, for example, when handling data being streamed from some device, or when taking user input. It is less useful when you will know how many data items you have before looping (for this, see the `for` loop below). Subsequently, you may not use them often.\n",
        "\n",
        "`while` loops make use of the same syntax as `if` statements:\n",
        "- the keyword `while` followed by a condition\n",
        "- a colon `:` after the condition\n",
        "- indentation of the body of the loop\n",
        "\n",
        "\n",
        "\n",
        "Here's an example:\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "y7PVD9DLNo0S"
      },
      "source": [
        "values = list()\n",
        "print('Enter values.')\n",
        "print('Enter an empty line to quit.')\n",
        "\n",
        "value = input('Next value: ')    # initalize\n",
        "while value:                     # termination condition\n",
        "  values.append(value)\n",
        "  value = input('Next value: ')  # reset\n",
        "\n",
        "\n",
        "print('\\nThe values were:')\n",
        "print(values)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Aimret7ANo0U"
      },
      "source": [
        "## <font color=green>💬 Discussion point</font>\n",
        "What roles is the variable `value` playing in the above code?\n",
        "\n",
        "## <font color=green>❓ Question</font>\n",
        "- An app sends a stream of characters to some cloud based program as follows:\n",
        "  - characters '1', '2', '3', '4', or '5' indicating user mood scores collected over the last day\n",
        "  - the character 'z' to indicate all scores have been sent, and that the program should compute the mean\n",
        "- Using keyboard input to simulate the stream of characters from the app, write the program that computes the mean\n",
        "\n",
        "\n",
        "## <font color=green>⌨️ Your answer</font>\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1JcsEh8INo0U"
      },
      "source": [
        "# Complete the code below, replacing the four REPLACE words with your own code\n",
        "\n",
        "\n",
        "prompt = 'Next mood score (z to finish): '  # we will use this prompt multiple times\n",
        "\n",
        "score = input(REPLACE)                      # get the first score\n",
        "sum = 0                                     # initialise the sum of scores\n",
        "count = 0                                   # initialise the count of scores\n",
        "while REPLACE :                             # test for terminating condition\n",
        "    sum = REPLACE                           # calculate the new sum\n",
        "    count = REPLACE                         # increment the count\n",
        "    score = input(REPLACE)                  # get the next score\n",
        "    \n",
        "print('Mean score: ', sum/count)            # print out the answer\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AzkqAEdTNo0X"
      },
      "source": [
        "## <font color=green>💬 Discussion point</font>\n",
        "In your code above,\n",
        "- why has the prompt string been placed in a variable, instead of using it directly in the `input()` statements?\n",
        "- why does the `sum` variable have to be initialised?\n",
        "- why are there two `input()` statements - couldn't we use one?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s8iSIOPaNo0X"
      },
      "source": [
        "### For loops\n",
        "\n",
        "`for` loops in Python have very similar functionality to those in R, in that they iterate over the items in any sequence. As you might expect, the syntax follows the same pattern as for `while` loops:\n",
        "\n",
        "`for item in sequence:\n",
        "   statement\n",
        "   statement\n",
        "   ...`\n",
        "   \n",
        "The `in` keyword indicates an assignment. Each item from the sequence is assigned to a variable, in turn. Here's an example for you to try:\n",
        "   \n",
        "   "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gjRRKpaYNo0X"
      },
      "source": [
        "readings = ['+++++','++','++', '+++']\n",
        "for item in readings:\n",
        "  print(len(item))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7H3Z9PEUNo0Z"
      },
      "source": [
        "## <font color=green>❓ Question</font>\n",
        "\n",
        "You have a list of integer results from some instrument run. On every instrument run, the first and last four results in this list are artefacts and discarded. Write a piece of code to count the number of results over 50, and the number 50 or less. (___Hint:___ use list slices)\n",
        "\n",
        "## <font color=green>⌨️ Your answer</font>\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eyc7YLCjNo0a"
      },
      "source": [
        "# Complete the code below to give your answer\n",
        "\n",
        "# Here are the results\n",
        "results = [0, 0, 1, 1, 55, 67, 42, 78, 34, 56, 2, 2, 0, 0]\n",
        "\n",
        "big_count = 0        # Initialise the count of big results (over 50) \n",
        "small_count = 0      # Initialise the count of small results (50 or less)\n",
        "\n",
        "# Iterate over all of the list except first and last four values\n",
        "for r in REPLACE THIS:\n",
        "    # increment the count variables according to the value of r\n",
        "    ADD CODE HERE\n",
        "\n",
        "# Print out the results\n",
        "print('Big:', big_count)\n",
        "print('Small:', small_count)\n",
        "    "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wiTbxWV6No0c"
      },
      "source": [
        "## <font color=green>💬 Discussion point</font>\n",
        "Take a look at the code below, and run it.\n",
        "\n",
        "- What type of assignment is happening here?\n",
        "- What do you think the built in `zip` function doing?\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8p83tMmPNo0c"
      },
      "source": [
        "list_a = [12, 50, 45]\n",
        "list_b = [3, 10, 5]\n",
        "\n",
        "for a, b in zip(list_a, list_b):\n",
        "    print(a/b)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sQKRxAB-No0e"
      },
      "source": [
        "## <font color=green>💬 Discussion point</font>\n",
        "\n",
        "Take a look at the code below, and run it.\n",
        "\n",
        "- What is the expression `items[:]` doing?\n",
        "- Why do you think this neccesary?\n",
        "- Try this thought experiment, walking through the code in your head (i.e. don't try running this for real!): what would  happen if you used this as you for statement in the same code?\n",
        "  - `for item in items:`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KjPCbvjONo0f"
      },
      "source": [
        "items = ['+++++','++','++', '+++']\n",
        "for item in items[:]:\n",
        "    if len(item) > 3:\n",
        "        items.append('☺️' + item)\n",
        "print(items)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uDPGIoDqNo0g"
      },
      "source": [
        "#### Using range() with for loops\n",
        "\n",
        "All of the examples of `for` that we have looked at above assume that we already have some sequence to iterate over. What if we have no sequence, but we know that we need to execute some statements a fixed number of times?\n",
        "\n",
        "- We can use `range()` for this.\n",
        "- `range(n)` creates the sequence [0, 1, 2, 3, ..., n-1] \n",
        "\n",
        "For example,  try running the below code:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ghBwL2I_No0h"
      },
      "source": [
        "for i in range(5):\n",
        "    print(i*'+')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "K5ITuV0sNo0j"
      },
      "source": [
        "## <font color=green>❓ Question</font>\n",
        "\n",
        "`range()` is described in the Python documentation [here](https://docs.python.org/3/library/stdtypes.html#range). Take a look. Now write a piece of code, using `for` and `range()`, that prints out all of the cubes (powers of three) of the even numbers from 4 to 16. Make sure it prints the last one, 16 cubed!\n",
        "\n",
        "## <font color=green>⌨️ Your answer</font>\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zrkNMx7kNo0j"
      },
      "source": [
        "# Type your answer here, replacing the REPLACE words:\n",
        "for REPLACE:\n",
        "    print(REPLACE)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qMLuPWSMNo0m"
      },
      "source": [
        "#### Using enumeration with for loops\n",
        "\n",
        "Often when looping over sequences, we want to make use of not only the current item, but also its numeric position. We can do this with the `enumerate()` function.\n",
        "\n",
        "Try the following code:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FiewYlFtNo0m"
      },
      "source": [
        "bases = ['C', 'G', 'G', 'C', 'C', 'T', 'A', 'T', 'A']\n",
        "for value in enumerate(bases):\n",
        "    print(value)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "w5IEl6W4No0o"
      },
      "source": [
        "This is what is happening:\n",
        "\n",
        "- The `enumerate()` iterates over the list.\n",
        "- It creates a _tuple_ for each item.\n",
        "- The _tuple_ consists of an int for the index of the item, and the item\n",
        "\n",
        "(a tuple is a Python immutable sequence)\n",
        "\n",
        "## <font color=green>❓ Question</font>\n",
        "\n",
        "Write a new version of the above code, using double assignment to get the index and the item in to separate variables, and print them both\n",
        "\n",
        "## <font color=green>⌨️ Your answer</font>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CeKWcdFXNo0p"
      },
      "source": [
        "# Edit the below code, changing the REPLACE words to give your answer\n",
        "\n",
        "bases = ['C', 'G', 'G', 'C', 'C', 'T', 'A', 'T', 'A']\n",
        "for REPLACE in enumerate(bases):\n",
        "    print('Index:', REPLACE, 'Base:', REPLACE)"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}