Tutorial_chapter3_statements.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3 Statements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are several kinds of statements, such as assignment statements, choice statements (select and if statements), and loop statements (while and for statements).\n",
    "Semicolons are **not** required after statements, however, a semicolon can surpress the output of the last statement."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.1 The assignment statement"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An *assignment* statement is used to assign values to variables. Two examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 2\n",
    "y = x + 10\n",
    "\n",
    "print(x, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first assignment, assigns the integer value `2` to `x`. It concists of the name of the variable (`x`), an assignment symbol (`=`), and value `2`. The second assignment consists of a name of the variable (`y`), an assignment symbol (`=`), and an expression (`x + 10`) yielding a value. When `x` is `2`, the value of the expression for `y` is `12`. Execution of this statement copies the value to the `y` variable, immediately after executing the assignment, the value of the `y` variable is `10` larger than the value of the `x` variable at this point of the program. \n",
    "\n",
    "The value of the `y` variable will not change until the next assignment to `y`, for example, performing the assignment `x = x + 7` has no effect on the value of the `y` variable. This is shown below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = x + 7\n",
    "print(x, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Independent assignments can also be combined in a multi-assignment, e.g.:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i, j = x+1, 1\n",
    "print(i, j)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The result is the same as the above described example, the first value goes into the first variable, the second value into the second variable, etc. In an assignment statement, first all expression values are computed before any assignment is actually done. In the following example the values of `x` and `y` are swapped:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 1\n",
    "y = 2\n",
    "x, y = y, x\n",
    "print(x, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.2 The if statement"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The *if* statement is used to express decisions. In Python there are no `end` statements; instead indentations are used to indicate the scope of the statement block. An example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-1 1\n"
     ]
    }
   ],
   "source": [
    "x = -1\n",
    "if x < 0:\n",
    "    y = -x  # indented, and thus in the scope of the if statement.\n",
    "    \n",
    "print(x, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If the value of `x` is negative, assign its negated value to `y`. Otherwise, do nothing (skip the `y = -x` assignment statement).\n",
    "\n",
    "To perform a different statement when the decision fails, an `if`-statement with an else alternative can be used. It has the following form. An example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 10\n",
    "b = 4\n",
    "if a > 0:\n",
    "    c = a\n",
    "else:\n",
    "    c = b\n",
    "    \n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If `a` is positive, variable `c` gets the value of `a`, otherwise it gets the value of `b`. Try it out with different values of a and b!\n",
    "\n",
    "\n",
    "In some cases more alternatives must be tested. One way of writing it is by nesting an `if`-statement in the `else` alternative of the previous `if`-statement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i = 12\n",
    "if i < 0:\n",
    "    print(\"i < 0\")\n",
    "else:\n",
    "    if i == 0:\n",
    "        print(\"i = 0\")\n",
    "    else:\n",
    "        if i > 0 and i < 10:\n",
    "            print(\"0 < i < 10\")\n",
    "        else:\n",
    "            # i must be greater or equal 10\n",
    "            print(\"i >= 10\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This tests `i < 0`. If it fails, the `else` is chosen, which contains a second `if`-statement with the `i == 0` test. If that test also fails, the third condition `i > 0` and `i < 10` is tested, and one of the `print`-statements is chosen. The above can be written more compactly by combining an `else`-part and the `if`-statement that follows, into an `elif`part. Each `elif` part consists of a boolean expression, and a statement list. Using `elif` parts results in:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i = 12\n",
    "if i < 0:\n",
    "    print(\"i < 0\")\n",
    "elif i == 0:\n",
    "    print(\"i = 0\")\n",
    "elif i > 0 and i < 10:\n",
    "    print(\"0 < i < 10\")\n",
    "else:\n",
    "    # i must be greater or equal 10\n",
    "    print(\"i >= 10\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Each alternative starts at the same column, instead of having increasing indentation. The execution of this combined statement is still the same, an alternative is only tested when the conditions of all previous alternatives fail.\n",
    "\n",
    "Note that the line \"`# i must be greater or equal 10`\" is a comment to clarify when the alternative is chosen. It is not executed by the simulator. You can write comments either at a line by itself like above, or behind program code. It is often useful to clarify the meaning of variables, give a more detailed explanation of parameters, or add a line of text describing what the purpose of a block of code is from a birds-eye view."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.3 The while statement"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The *while* statement is used for repetitive execution of the same statements, a so-called *loop*. A fragment that calculates the sum of `10` integers, `10`, `9`, `8`, `...`, `3`, `2`, `1`, is:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i = 10\n",
    "Sum=0\n",
    "while i > 0:\n",
    "    Sum = Sum + i; i = i - 1\n",
    "    \n",
    "print(Sum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Each iteration of a `while` statement starts with evaluating its condition (`i > 0` above). When it holds, the statements inside the while (the `Sum = Sum + i; i = i - 1` assignments) are executed (which adds `i` to the sum and decrements `i`). At the end of the statements, the `while` is executed again by evaluating the condition again. If it still holds, the next iteration of the loop starts by executing the assignment statements again, etc. When the condition fails (`i` is equal to `0`), the `while` statement ends, and execution continues beyond the `while` code block.\n",
    "\n",
    "A fragment with an infinite loop is:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i = 0\n",
    "while True:\n",
    "    i = i + 1;\n",
    "    # This code can be terminated by pressing the stop-sign in the menu at the\n",
    "    # top"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The condition in this fragments always holds, resulting in `i` getting incremented \"forever\". Such loops are very useful to model things you switch on but never off, e.g. processes in a factory.\n",
    "\n",
    "A fragment to calculate $z = x^y$, showing the use of two while\n",
    "loops, is:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 2\n",
    "y = 3\n",
    "z = 1\n",
    "while y > 0:\n",
    "    while y % 2 == 0:\n",
    "        y = y / 2; x = x * x\n",
    "    y = y - 1; z = x * z\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A fragment to calculate the greatest common divisor (GCD) of two integer numbers `j` and `k`, showing the use of `if` and `while` statements, is:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "j = 28\n",
    "k = 77\n",
    "while j != k:\n",
    "    if j > k:\n",
    "        j = j - k\n",
    "    else:\n",
    "        k = k - j\n",
    "print(k)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The symbol `!=` stands for \"differs from\" (\"not equal\")."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.4 The for statement"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `while` statement is useful for looping until a condition fails. The *for* statement is used for iterating over a collection of values. A fragment with the calculation of the sum of `10` integers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Sum = 0\n",
    "for i in range(1,11):\n",
    "    Sum = Sum + i\n",
    "print(Sum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The result of the expression `range(1, 11)` is a list whose items are consecutive integers from `1` (included) up to `11` (excluded): `[1, 2, 3, ..., 9, 10]`. The following example illustrates the use of the `for` statement in relation with container-type variables. Another way of calculating the sum of a list of integer numbers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "xs = [1,2,3,5,7,11,13]\n",
    "Sum = 0\n",
    "for x in xs:\n",
    "    Sum = Sum + x\n",
    "print(Sum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This statement iterates over the elements of list `xs`. This is particularly useful when the value of `xs` may change before the `for` statement."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.5 Notes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this chapter the most used statements are described. The language offers the following extensions:\n",
    "1. Inside loop statements *break* and *continue* statements are allowed. The `break` statements allows \"breaking out of a loop\", that is, abort a `while` or a `for` statement. The `continue` statement aborts execution of the statements in a loop. It \"jumps\" to the start of the next iteration.\n",
    "2. A rarely used statement is the *pass* statement. It's like an `x = x` assignment statement, but more clearly expresses \"nothing is done here\"."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.6 Exercises"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 3.6.1\n",
    "\n",
    "Study the specification below and explain why, though it works, it is not an elegant way of modelling the selection. Make a suggestion for a shorter, more elegant version."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Original code:\n",
    "i = 3\n",
    "if (i < 0) == True:\n",
    "    print(i,\"is a negative number\")\n",
    "elif (i <= 0) == False:\n",
    "    print(i,\"is a positive number\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# More elegant version:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 3.6.2\n",
    " Construct a list with the squares of the first 10 integers:\n",
    "-  **(a)** using a `for` statement.\n",
    "-  **(b)** using a `while` statement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 2a: Using for statement\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 2b: Using while statement\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 3.6.3\n",
    "Write a program that: \n",
    "- **(a)** makes a list with the first 50 prime numbers.\n",
    "- **(b)** Extend the program with computing the sum of the first 7 prime numbers.\n",
    "- **(c)** Extend the program with computing the sum of the last 11 prime numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3a: generate a list of 50 prime numbers\n",
    "\n",
    "primes = []\n",
    "#..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3b: Extend the program with computing the sum of the first 7 prime numbers.\n",
    "# Use the previously calculated list of primes in this answer (no need to recalculate it)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3c: Extend the program with computing the sum of the last 11 prime numbers.\n",
    "# Again, use the previously calculated list of primes in this answer (no need to recalculate it)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.7 Answers to exercises"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Answer to 3.6.1\n",
    "\n",
    "\n",
    "<details>\n",
    "    <summary>[Click for the answer to 3.6.1]</summary>\n",
    "\n",
    "In the original code, `if (i < 0) == True` basically translates to `if (i < 0)`. Using `True` is redundant and can be reduced to:\n",
    "    \n",
    "```python\n",
    "i = 3\n",
    "if i < 0:\n",
    "    print(i,\"is a negative number\")\n",
    "elif i > 0:\n",
    "    print(i,\"is a positive number\") \n",
    "```\n",
    "</details>\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Answer to 3.6.2\n",
    "\n",
    "<details>\n",
    "    <summary>[Click for the answer to 3.6.2]</summary>\n",
    "\n",
    "**A.** Using for statement:\n",
    "    \n",
    "```python\n",
    "l = []\n",
    "for i in range(0,10):\n",
    "    l = l + [i*i]\n",
    "print(l)\n",
    "```\n",
    "\n",
    "---\n",
    "**B.** Using while statement\n",
    "    \n",
    "```python\n",
    "l = []\n",
    "j = 0\n",
    "while j<10:\n",
    "    l = l + [j*j]\n",
    "    j = j+1\n",
    "print(l)\n",
    "```\n",
    "</details>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Answer to 3.6.3\n",
    "\n",
    "<details>\n",
    "    <summary>[Click for the answer to 3.6.3]</summary>\n",
    "\n",
    "**A.** Generating a list of 50 prime numbers:\n",
    "    \n",
    "```python\n",
    "primes = []\n",
    "i = 2\n",
    "lsum = 0\n",
    "\n",
    "while len(primes) < 50:\n",
    "    b = True\n",
    "    for j in primes:\n",
    "        b = (b and (i % j != 0))\n",
    "    if b:\n",
    "        primes = primes + [i]\n",
    "    i = i+1\n",
    "\n",
    "print(primes)\n",
    "```\n",
    "---\n",
    "**B.** Extend the program with computing the sum of the first 7 prime numbers.\n",
    "\n",
    "\n",
    "```python\n",
    "sum = 0\n",
    "for j in primes[:7]:\n",
    "    sum = sum + j\n",
    "\n",
    "print(sum)\n",
    "```\n",
    "---\n",
    "**C.** Extend the program with computing the sum of the last 11 prime numbers.\n",
    "\n",
    "```python\n",
    "lsum = 0\n",
    "for j in primes[-11:]:\n",
    "    lsum = lsum + j\n",
    "print(lsum)\n",
    "```\n",
    "</details>\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python (pychEnv)",
   "language": "python",
   "name": "pychenv"
  },
  "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}