4 Flow_control.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4. Flow control"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "By default, Python moves through the code in a linear way. It simply executes all the statements in the order in which they are found in the programme. In some cases, however, a statement only needs to be performed under a certain condition. In other situations, statements may need to be repeated as long as a certain condition applies. \n",
    "\n",
    "Flow control is the process of determining how often, or under which circumstances, a certain set of statement needs to be executed. In Python, there are various keywords that you can use to specify if, or how many times, a statement needs to be run. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Conditional execution\n",
    "\n",
    "\n",
    "To make sure that a certain section of your program is executed only if a certain condition is true, you can use the keyword `if`. This keyword is followed by a Boolean expression. This Boolean expression, in turn, is followed by a colon ('`:`'). When the expression following `if` is indeed true, the statements underneath the expression are executed. If not, these statements are ignored. The listing below offers an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "grade = 7.5\n",
    "\n",
    "print( f\"Your grade is {grade}\" )\n",
    "\n",
    "if grade > 5.5:\n",
    "    print(\"This grade is sufficient!\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Importantly, the spatial layout of the code is not arbitrary. The block of code that must be executed when the condition is true is indented. In Python, such indents consist of four spaces. In most code editors, this indentation is added automatically when you hit the enter button after the colon following a Boolean expression. The statements that have the same indentation are all assumed to belong to the same block of code.\n",
    "\n",
    "The exampe that was given only contains one condition. It is also possible to let Python evaluate a series of conditions. In this case, you need to use the keywords `if`, `elif` and `else`. An example can be seen below.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "grade = 7.5\n",
    "\n",
    "if grade > 9:\n",
    "    label = 'outstanding'\n",
    "elif grade > 8:\n",
    "    label = 'very good'\n",
    "elif grade > 7:\n",
    "    label = 'good'\n",
    "elif grade > 6:\n",
    "    label = 'satisfactory'\n",
    "else:\n",
    "    label = 'insufficient'\n",
    "    \n",
    "print( f'The grade is {grade} ({label})' )\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If the condition that follows the `if` keyword can be evaluated as `True`, the first code block will be caried out. If not, the condition that is given after `elif` will be evaluated. Python will execute the second block of code if that second condition is found to be `True`. The final set of statements will be executed only if all the two earlier conditions are evaluated as `False`. \n",
    "\n",
    "Note that only the keywords `if` and `elif` can be followed by a condition. The keyword `else` always appears WITHOUT such a condition. The code block given after else contains the actions that must be performed if all the earlier conditions are false. \n",
    "\n",
    "Importantly, the lines starting with `if`, `elif` and `else` all end in a colon.  \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iteration\n",
    "\n",
    "Next to the flow structures for selection, there are also flow control structures that can be used for repetitions of statements. Such repetitions are generally referred to as iterations. In Python, you can specify the number of times a set of statements need to be repeated by making use of `while` or `for`. As is the case for `if`, the `while` keyword should be followed by a test, or, more precisely, by a Boolean expression. \n",
    "\n",
    "The `while` keyword initiates a loop. The statements that follow `while` will be repeated as long as the expression is true. Clearly, it is necessary to ensure that the expression can also be evaluated to `False` at some point, since the repetition will otherwise continue endlessly. The variable that can end the loop is called the iteration value. \n",
    "\n",
    "The code below prints the multiplication table for the number 7. In the code below, the number of repetitions are counted using a variable named `i`. This variable captures the iteration value. The value of this variable is incremented with te value 1 in each repetition, using the `+=` operator. The loop will terminate after the variable `i` has reached the value 11. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "number = 7\n",
    "\n",
    "i = 1\n",
    "\n",
    "while i <= 10:\n",
    "    print( f\"{ i } times { number } is { i*number }.\" )\n",
    "    i += 1\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The same algorithm can be implemented using the `for` keyword. This keyword can be used in combination with the `range()` function, for instance, which can be used to generate a list of numbers. When this `range()` function is used with two integers, the function starts the list with the number which is mentioned first and it continues to add integers, as long as the value of these numbers is less than the number which is mentioned secondly. When you use `range( 1, 11 )`, for instance, this results in a list of integers ranging from 1 up and until 10, but not including 11. \n",
    "\n",
    "The line `for i in range( 1 , 11 )`, in the code below, starts a sequence of 10 loops. The code block below the `for` keyword will be repeated 10 times. \n",
    "\n",
    "The `for` loop assigns the next value in the given range to the variable `i`, just before the code block is *entered*. This is unlike the `while` loop, in which you have to make sure to increment the loop condition yourself.\n",
    "\n",
    "You are free to choose the name of the *loop variable* (except for the reserved words), so as always you should choose a variable name that is meaningful in the context of the code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "number = 8\n",
    "\n",
    "for i in range(1,11):\n",
    "    print( f\"{ i } times { number } is { i*number }.\" )\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remember that the code blocks that follow lines starting with `if`, `elif`, `else`, `for` and `while` all need to be indented. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercises"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 4.1.\n",
    "\n",
    "Write code which can print headingings in a syllabus for a university course which has 12 weeks. More specifically, print the headings 'Week 1', 'Week 2', 'Week 3', etc. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 4.2.\n",
    "\n",
    "Write some code which can print a text to welcome its users with messages such as 'Good morning', 'Good afternoon', or 'Good evening'. The message that is printed should vary along with the time of the day. \n",
    "\n",
    "\n",
    "Follow the steps below:\n",
    "\n",
    "* Create a variable named `hour` \n",
    "* Assign it a value in between 0 and 23. \n",
    "* Assuming that this variable represents a given time, print a message that is appropriate for the part of the day this hour is in. If the variable `hour` has value 10, for instance, the code should print `'Good morning!'` and if `hour` has value 23, the code should print `'Good night!'`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 4.3.\n",
    "\n",
    "The standard function `input()` can be used to request a value from the user. \n",
    "\n",
    "Use this function to request a year from the user. You can copy the code below:\n",
    "\n",
    "`\n",
    "year = int( input( f\"Please enter a year: \") )\n",
    "`\n",
    "\n",
    "The `input()` returns a string by default. You can use `int()` to change this calue into an an integer.\n",
    "\n",
    "Next, write some code which can describe the century a given year is in. Given the year 1767, for instance, the application must be able to print the following sentence: “The year 1767 is in the eighteenth century”. Limit your algorithm to years in between 1500 and 2020. \n",
    "Note that it is possible to combine two different Boolean expressions using the word ‘and’."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "year = int( input( f\"Please enter a year: \") )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 4.4\n",
    "\n",
    "Program a small guessing game. In this game, the player needs to guess a number in between 1 and 50. You can use the code below as a basis. \n",
    "\n",
    "The `randint()` method from `random` can be used, firstly, to generate a random integer. \n",
    "\n",
    "Use the function `input()` to request a value from the user. The function int() needs to be used to convert the input into an integer.\n",
    "\n",
    "When the user enters a value which is too low or too high, this information is communicated to the user via a print statement. To test whether the number that is guesses is correct, you can work with the equality (`==`) and the inequality (`!=`) operators. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}