02a-loops_conditionals.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Programming with Python\n",
    "#### Vedran Šego, [vsego.org](http://vsego.org/)\n",
    "\n",
    "## Contents:\n",
    "\n",
    "1. Loops\n",
    "\n",
    "2. Comparison and logical operators\n",
    "\n",
    "3. Conditionals"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Loops\n",
    "\n",
    "It is rarely useful that a computer performs each operation only once; we usually need it to repeat what it does. To do so, we need *loops*.\n",
    "\n",
    "## `for`-loops\n",
    "\n",
    "The most common one is a `for`-loop, which is usually used to execute some part of the code a predetermined number of times (although, it can be used on a wider range of applications in many C-like languages)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "In Python 3, we often use the `for`-loop together with the `range` function which *pretends* to return a list of numbers (it returns something more complex, we can consider it a list for now). That function can be called as follows:\n",
    "* `range(n)` -- numbers $0, 1, \\dots, n \\color{red}{-1}$;\n",
    "* `range(m, n)` -- numbers $m, m+1, \\dots, n \\color{red}{-1}$;\n",
    "* `range(m, n, s)` -- numbers $m, m+s, \\dots, m + sk$, where $k \\in \\mathbb{N}$ such that $m + sk \\color{red}{<} n \\le m + s(k+1)$.<br>\n",
    "  In other words, numbers from $m$ to $n \\color{red}{-1}$ with step $s$, but we might not hit $n \\color{red}{-1}$, depending on the value of step $s$.\n",
    "\n",
    "Do not forget that the ending is **not included**, hence \"$\\color{red}{-1}$\"!\n",
    "\n",
    "**Python 2 remark:** In Python 2, `range` actually returns a list. The exact equivalent to `range` from Python 3 is called `xrange` in Python 2."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `for`-loop in action\n",
    "\n",
    "Let us make an overly enthusiastic version of the \"Hello, World!\" program that would repeat its message $5$ times."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, World!\n",
      "Hello, World!\n",
      "Hello, World!\n",
      "Hello, World!\n",
      "Hello, World!\n"
     ]
    }
   ],
   "source": [
    "for i in range(5):\n",
    "    print(\"Hello, World!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### How does this work?\n",
    "\n",
    "Let us read it as if it was a sentence in regular English language, taking into account that `range(5)` acts as a list of numbers $0, 1, 2, 3, 4$:\n",
    "\n",
    "> For `i` in (0, 1, 2, 3, 4), print \"Hello, World!\".\n",
    "\n",
    "So, this is equivalent to the code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, World!\n",
      "Hello, World!\n",
      "Hello, World!\n",
      "Hello, World!\n",
      "Hello, World!\n"
     ]
    }
   ],
   "source": [
    "i = 0\n",
    "print(\"Hello, World!\")\n",
    "i = 1\n",
    "print(\"Hello, World!\")\n",
    "i = 2\n",
    "print(\"Hello, World!\")\n",
    "i = 3\n",
    "print(\"Hello, World!\")\n",
    "i = 4\n",
    "print(\"Hello, World!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Obviously, we don't need the variable `i`, but it's part of the loop. If we want to ignore it, we can use the underscore `_` instead:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, World!\n",
      "Hello, World!\n",
      "Hello, World!\n",
      "Hello, World!\n",
      "Hello, World!\n"
     ]
    }
   ],
   "source": [
    "for _ in range(5):\n",
    "    print(\"Hello, World!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is the same as"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, World!\n",
      "Hello, World!\n",
      "Hello, World!\n",
      "Hello, World!\n",
      "Hello, World!\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello, World!\")\n",
    "print(\"Hello, World!\")\n",
    "print(\"Hello, World!\")\n",
    "print(\"Hello, World!\")\n",
    "print(\"Hello, World!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `for`-loop syntax\n",
    "\n",
    "`for`-loops have the following elements:\n",
    "1. start with the keyword \"<span style=\"color: red; font-family: monospace;\">for</span>\",\n",
    "2. followed by <span style=\"color: red;\">the name of the variable</span> that will be assigned all the values through which we want to loop (or \"`_`\" if we don't need those values),\n",
    "3. then a keyword \"<span style=\"color: red; font-family: monospace;\">in</span>\",\n",
    "4. then <span style=\"color: red;\">a list</span> or something that acts like it (we'll see more examples throughout the course), and\n",
    "5. then <span style=\"color: red;\">a colon \"<span style=\"color: red; font-family: monospace;\">:</span>\"</span>.\n",
    "\n",
    "**Do not forget the colon!** That will make Python somewhat nervous..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Indentation <span style=\"color: red; font-variant: small-caps;\">&larr; Very Important!</span>\n",
    "\n",
    "Notice the indentation in the second line:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, World!\n",
      "Hello, World!\n",
      "Hello, World!\n",
      "Hello, World!\n",
      "Hello, World!\n"
     ]
    }
   ],
   "source": [
    "for i in range(5):\n",
    "    print(\"Hello, World!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "All the commands with the same indentation \"belong\" to that loop. Observe the difference:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The first loop:\n",
      "Inside loop.\n",
      "And where is this? Inside or outside of the loop?\n",
      "Inside loop.\n",
      "And where is this? Inside or outside of the loop?\n",
      "Inside loop.\n",
      "And where is this? Inside or outside of the loop?\n",
      "\n",
      "The second loop:\n",
      "Inside loop.\n",
      "Inside loop.\n",
      "Inside loop.\n",
      "And where is this? Inside or outside of the loop?\n"
     ]
    }
   ],
   "source": [
    "print(\"The first loop:\")\n",
    "\n",
    "for i in range(3):\n",
    "    print(\"Inside loop.\")\n",
    "    print(\"And where is this? Inside or outside of the loop?\")\n",
    "\n",
    "print()\n",
    "print(\"The second loop:\")\n",
    "\n",
    "for i in range(3):\n",
    "    print(\"Inside loop.\")\n",
    "print(\"And where is this? Inside or outside of the loop?\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<div style=\"color: #a00000; font-size:123%; margin:0; padding: 3mm; text-align: justify;\">Blocks of commands, like the ones above, are defined via indentation, **and indentation alone!** There are no curly brackets `{...}` like in C-like languages, no `begin...end` like in Pascal, no `end` like in MATLAB,... **only indentation, so pay close attention to it!**<br><br>\n",
    "\n",
    "Empty lines are completely ignored. Do use them for better code readability!</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### A more useful example\n",
    "\n",
    "Write a program that inputs an integer $n$, then inputs $n$ numbers $a_1, a_2, \\dots, a_n$ and prints\n",
    "$$S = \\sum_{k=1}^n a_k.$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "How would we do it manually?\n",
    "1. Input $n$.\n",
    "2. Initialize $S$ to $0$ (meaning give $S$ its initial value $0$).\n",
    "3. Then input a number, say $x$ (by \"number\", we usually mean a \"real number\", but it can be an integer or something else, depending on the context).\n",
    "4. Add $x$ to $S$, i.e., $S \\leftarrow S + x$.\n",
    "5. Repeat steps 3 and 4 a grand total of $n$ times.\n",
    "6. Print the result $S$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Since computers prefer to know in advance that we wish to loop through some of the code, we shall rearrange the above (i.e., put the item 5 where the loop starts):\n",
    "\n",
    "1. Input $n$.\n",
    "2. Set $S = 0$.\n",
    "3. Repeat the following steps $n$ times\n",
    "   1. Input a number $x$.\n",
    "   2. Add $x$ to $S$, i.e., $S \\leftarrow S + x$.\n",
    "4. Print the result $S$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "We are now ready for a Python code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "How many numbers do you want to summarize? 3\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input a_1: 17\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input a_2: 13\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input a_3: 19\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "49.0\n"
     ]
    }
   ],
   "source": [
    "n = int(input(\"How many numbers do you want to summarize? \"))\n",
    "s = 0\n",
    "for i in range(n):\n",
    "    x = float(input(\"Input a_\" + str(i+1) + \": \"))\n",
    "    s += x\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the above code, we use the variable `i` to explain to the user which number they have to input. However, since `range(n)` traverses through numbers $0, 1, \\dots, n-1$ and we want then to be $1, 2, \\dots, n$, we used `i+1` for such a description."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "We can avoid this extra addition by simply explaining to the `range()` function that we want the numbers to start from $1$ and go up to $n$ (i.e., numbers from $1$, strictly smaller than $n+1$):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "How many numbers do you want to summarize? 3\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input a_1: 17\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input a_2: 13\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input a_3: 19\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "49.0\n"
     ]
    }
   ],
   "source": [
    "n = int(input(\"How many numbers do you want to summarize? \"))\n",
    "s = 0\n",
    "for i in range(1, n+1):\n",
    "    x = float(input(\"Input a_\" + str(i) + \": \"))\n",
    "    s += x\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Usually, the first approach is better because indexing of lists (we'll get to them later) is zero-based and you'll almost always want your loop counter to respect that."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## `while`-loops\n",
    "\n",
    "It is not always known ahead of the execution how many times the loop will have to repeat its block. For example:\n",
    "* Load some numbers until a zero is loaded and do something with them;\n",
    "* Do something with number's digits (technically, we can count the digits first, but it's a waste of time);\n",
    "* Read the data as long as there is input (from a file, standard input, etc).  \n",
    "  ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Equivalent to the basic `for`-loop,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "n = 5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "n = int(input(\"n = \"))\n",
    "for i in range(n):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "is the following code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "n = 5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "n = int(input(\"n = \"))\n",
    "i = 0\n",
    "while i < n:\n",
    "    print(i)\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### How does this work?\n",
    "\n",
    "Let us, as before, read the above code as if it was a sentence in regular English language, taking into account that `i += 1` stands for \"add 1 to `i`\", i.e., \"increase `i` by 1\":\n",
    "\n",
    "> While $i$ is less than $n$, print $i$ and increase it by one.\n",
    "\n",
    "And this is exactly how `while`-loops work:\n",
    "1. check the condition,\n",
    "2. if the condition is true, execute the loop's body and go back to step 1,\n",
    "3. if the condition is false, skip the body and continue the execution behind the loop."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `while`-loop syntax\n",
    "\n",
    "`while`-loops have the following elements:\n",
    "1. start with the keyword \"<span style=\"color: red; font-family: monospace;\">while</span>\",\n",
    "2. followed by <span style=\"color: red;\">the condition</span> that has to be checked,\n",
    "3. then <span style=\"color: red;\">a colon \"<span style=\"color: red; font-family: monospace;\">:</span>\"</span>.\n",
    "\n",
    "As with the `for`-loop, **do not forget the colon!**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### When is the condition checked?\n",
    "\n",
    "Before each execution of the body, **and only then!**\n",
    "\n",
    "Observe the following code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Before the increment: 0\n",
      "After the increment: 1\n",
      "Before the increment: 1\n",
      "After the increment: 2\n"
     ]
    }
   ],
   "source": [
    "i = 0\n",
    "while i < 2:\n",
    "    print(\"Before the increment:\", i)\n",
    "    i += 1\n",
    "    print(\"After the increment:\", i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "So, even after `i` took the value 2 (thus, making the condition `i < 2` false), the body still executed until the end, before rechecking the condition and terminating the loop!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Can we change how the loops run?\n",
    "\n",
    "Yes, we can break the loop earlier than it would normally stop and we can skip parts of it. This will be addressed later on, along with other methods of changing the normal flow of control in programs."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Comparison and logical operators\n",
    "\n",
    "These are the comparison operators that can be used on numbers (and some other types, for example strings):\n",
    "\n",
    "Operator | Example      | Meaning\n",
    "---------|--------------|--------\n",
    "`<`      | `a < b`      | The value of `a` is smaller than the value of `b`\n",
    "`<=`     | `a <= b`     | The value of `a` is smaller than or equal to the value of `b`\n",
    "`>`      | `a > b`      | The value of `a` is bigger than the value of `b`\n",
    "`>=`     | `a >= b`     | The value of `a` is bigger than or equal to the value of `b`\n",
    "`==`     | `a == b`     | The value of `a` is equal to the value of `b` (but not necessarily identical!)\n",
    "`!=`     | `a != b`     | The value of `a` is not equal to the value of `b`\n",
    "`is`     | `a is b`     | `a` and `b` are exactly the same object\n",
    "`not is` | `a is not b` | `a` and `b` are not exactly the same object\n",
    "`or`     | `a or b`     | `a` is true or `b` is true (or both); `a` and `b` can be non-Boolean values\n",
    "`and`    | `a and b`    | Both `a` and `b` are true; `a` and `b` can be non-Boolean values\n",
    "`not`    | `not a`      | `True` if `a` is false; `False` otherwise; `a` can be a non-Boolean value\n",
    "\n",
    "When checking if the value of a variable `x` is undefined (i.e., it is `None`), always use `x is None` or `x is not None`, and **not** `x == None` or `x != None` (the reasons are quite technical and far beyond the scope of this course; those interested can read more about the subject [here](http://jaredgrubb.blogspot.co.uk/2009/04/python-is-none-vs-none.html)).\n",
    "\n",
    "Also, do not use `not x is None` or `not (x is None)`; instead, use a much more readable `x is not None`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## A note on composite comparisons\n",
    "\n",
    "As we have seen, `a < b` is `True` if `a` is less than `b` and `False` otherwise:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 < 2: True\n",
      "1 < 1: False\n",
      "2 < 1: False\n"
     ]
    }
   ],
   "source": [
    "print(\"1 < 2:\", 1 < 2)\n",
    "print(\"1 < 1:\", 1 < 1)\n",
    "print(\"2 < 1:\", 2 < 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "In Python, we can also use\n",
    "```python\n",
    "a < b < c\n",
    "```\n",
    "as a shorthand for\n",
    "```python\n",
    "a < b and b < c\n",
    "```\n",
    "and\n",
    "```python\n",
    "a < b > c\n",
    "```\n",
    "as a shorthand for\n",
    "```python\n",
    "a < b and b > c\n",
    "```\n",
    "as shown below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 < 2 < 3: True\n",
      "1 < 2 < 1: False\n",
      "1 < 2 > 3: False\n",
      "1 < 2 > 1: True\n"
     ]
    }
   ],
   "source": [
    "print(\"1 < 2 < 3:\", 1 < 2 < 3)\n",
    "print(\"1 < 2 < 1:\", 1 < 2 < 1)\n",
    "print(\"1 < 2 > 3:\", 1 < 2 > 3)\n",
    "print(\"1 < 2 > 1:\", 1 < 2 > 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Of course, all of the comparison operators can be used (do try to not sacrifice the code readability):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 < 2 == 2 >= 0: True\n",
      "1 < 2 == 0 >= 2: False\n",
      "1 < 2 >= 2 > 0:  True\n",
      "1 <= 2 >= 2 > 0: True\n"
     ]
    }
   ],
   "source": [
    "a = 1\n",
    "b = 2\n",
    "c = 2\n",
    "d = 0\n",
    "print(\"1 < 2 == 2 >= 0:\", a < b == c >= d)\n",
    "print(\"1 < 2 == 0 >= 2:\", a < b == d >= c)\n",
    "print(\"1 < 2 >= 2 > 0: \", a < b >= c > d)\n",
    "print(\"1 <= 2 >= 2 > 0:\", a <= b >= c > d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "However, **be very careful in other languages**: the form with more than one comparison will be accepted by almost all of them, but it will not work as one would expect (like it does in Python)! This affects C/C++, MATLAB, PHP, PERL, Java, JavaScript,... It does work as expected in Mathematica. In R, it won't work at all (but at least it will report an error)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## A note on (in)equality operators\n",
    "\n",
    "The equality `==` and inequality `!=` operators ignore the types of data to a certain extent. For example,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False == 0: True\n",
      "  type(False): <class 'bool'>\n",
      "  type(0): <class 'int'>\n",
      "  type(False) == type(0): False\n",
      "True == 1: True\n",
      "  type(True): <class 'bool'>\n",
      "  type(1): <class 'int'>\n",
      "  type(True) == type(1): False\n",
      "True != 2: True\n",
      "  type(True): <class 'bool'>\n",
      "  type(2): <class 'int'>\n",
      "  type(True) == type(2): False\n"
     ]
    }
   ],
   "source": [
    "print(\"False == 0:\", False == 0)\n",
    "print(\"  type(False):\", type(False))\n",
    "print(\"  type(0):\", type(0))\n",
    "print(\"  type(False) == type(0):\", type(False) == type(0))\n",
    "print(\"True == 1:\", True == 1)\n",
    "print(\"  type(True):\", type(True))\n",
    "print(\"  type(1):\", type(1))\n",
    "print(\"  type(True) == type(1):\", type(True) == type(1))\n",
    "print(\"True != 2:\", True != 2)\n",
    "print(\"  type(True):\", type(True))\n",
    "print(\"  type(2):\", type(2))\n",
    "print(\"  type(True) == type(2):\", type(True) == type(2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some languages (like PHP and JavaScript) have a *strict equality operator* `===` and *strict inequality operator* `!==` that check both types and values of the compared objects. However, Python doesn't have that."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Conditionals\n",
    "\n",
    "We have seen how to say\n",
    "\n",
    "> While some condition is true, do this.\n",
    "\n",
    "However, we don't always want to repeat doing things. Sometimes, we want:\n",
    "\n",
    "> If some condition is true, do this.\n",
    "\n",
    "This request leads us to *conditionals*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "A conditional is created with `if` statement and it is very similar to `while`-loops, with the main difference being that its block will be executed at most once (if the condition is true).\n",
    "\n",
    "Since the execution of the body is not repeated by the `if` statement, there are two possible branches:\n",
    "1. the one that is executed **if the condition is true**,\n",
    "2. the one that is executed **if the condition is false**.\n",
    "\n",
    "However, sometimes, we want to say\n",
    "> If `condition1` is true, do `job1`, else if `condition2` is true, do `job2`, else do `job3`\n",
    "\n",
    "Here is an example of all three of these:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input an integer: 17\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number 17 is positive.\n"
     ]
    }
   ],
   "source": [
    "n = int(input(\"Input an integer: \"))\n",
    "if n < 0:\n",
    "    print(\"Number\", n, \"is negative.\")\n",
    "elif n > 0:\n",
    "    print(\"Number\", n, \"is positive.\")\n",
    "else:\n",
    "    print(\"Number\", n, \"has an identity crisis!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Notice how `else if` is abbreviated to `elif`. This is to avoid too much indentation. Without it, we'd have to write:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input an integer: 0\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number 0 is a rebel!\n"
     ]
    }
   ],
   "source": [
    "n = int(input(\"Input an integer: \"))\n",
    "if n < 0:\n",
    "    print(\"Number\", n, \"is negative.\")\n",
    "else:\n",
    "    if n > 0:\n",
    "        print(\"Number\", n, \"is positive.\")\n",
    "    else:\n",
    "        print(\"Number\", n, \"is a rebel!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "As before, all the controlling parts of a conditional (`if condition`, `elif condition`, and `else`) **need to end with a colon!**\n",
    "\n",
    "Of course, we can stack as many `elif` parts as we need (including none of them), and we can ommit the `else` part if we don't need it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Using `else` with loops\n",
    "\n",
    "In Python 3, it is possible to use `else` in conjuction with loops. However, it is an unusual construct that other languages do not use and is best avoided by the new programmers. At this point, we haven't covered enough of Python to explain what it does.\n",
    "\n",
    "So, be careful not to write\n",
    "```python3\n",
    "while condition1:\n",
    "    if condition2:\n",
    "        some_code\n",
    "else:\n",
    "    some_code\n",
    "```\n",
    "instead of\n",
    "```python3\n",
    "while condition1:\n",
    "    if condition2:\n",
    "        some_code\n",
    "    else:\n",
    "        some_code\n",
    "```\n",
    "as Python will not report an error. It will instead do *something*, but not what you wanted.\n",
    "\n",
    "We shall cover loops' `else` statement later on in the course."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# An example: minimum and maximum\n",
    "\n",
    "Give two variables `a` and `b`, find which one is the minimum and which one is the maximum. Store those values in variables `min_value` and `max_value`, respectively."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a = 19\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b = 17\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a =  19.0\n",
      "b =  17.0\n",
      "Min: 17.0\n",
      "Max: 19.0\n"
     ]
    }
   ],
   "source": [
    "# We load some values, so we can test the code\n",
    "a = float(input(\"a = \"))\n",
    "b = float(input(\"b = \"))\n",
    "# The solution to the problem\n",
    "if a < b:\n",
    "    min_value = a\n",
    "    max_value = b\n",
    "else:\n",
    "    min_value = b\n",
    "    max_value = a\n",
    "# Print the result, to check if it's correct\n",
    "print(\"a = \", a)\n",
    "print(\"b = \", b)\n",
    "print(\"Min:\", min_value)\n",
    "print(\"Max:\", max_value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Since Python has functions `min` and `max`, we can do this in a more Pythonic way:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a = 19\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b = 17\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a =  19.0\n",
      "b =  17.0\n",
      "Min: 17.0\n",
      "Max: 19.0\n"
     ]
    }
   ],
   "source": [
    "# We load some values, so we can test the code\n",
    "a = float(input(\"a = \"))\n",
    "b = float(input(\"b = \"))\n",
    "# The solution to the problem\n",
    "min_value = min(a, b)\n",
    "max_value = max(a, b)\n",
    "# Print the result, to check if it's correct\n",
    "print(\"a = \", a)\n",
    "print(\"b = \", b)\n",
    "print(\"Min:\", min_value)\n",
    "print(\"Max:\", max_value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## (Sub)example\n",
    "\n",
    "Load `a` and `b` in a way that `a <= b`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "This is wrong:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a = 19\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b = 17\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loaded:\n",
      "  a = 17.0\n",
      "  b = 17.0\n"
     ]
    }
   ],
   "source": [
    "a = float(input(\"a = \"))\n",
    "b = float(input(\"b = \"))\n",
    "if a > b:\n",
    "    # a and b are in a wrong order, so we swap their values\n",
    "    a = b\n",
    "    b = a\n",
    "# Print the result, to check if it's correct\n",
    "print(\"Loaded:\")\n",
    "print(\"  a =\", a)\n",
    "print(\"  b =\", b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "This is correct:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a = 19\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b = 17\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loaded:\n",
      "  a = 17.0\n",
      "  b = 19.0\n"
     ]
    }
   ],
   "source": [
    "a = float(input(\"a = \"))\n",
    "b = float(input(\"b = \"))\n",
    "if a > b:\n",
    "    # a and b are in a wrong order, so we swap their values\n",
    "    tmp = a\n",
    "    a = b\n",
    "    b = tmp\n",
    "# Print the result, to check if it's correct\n",
    "print(\"Loaded:\")\n",
    "print(\"  a =\", a)\n",
    "print(\"  b =\", b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "A Pythonic solution would be:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a = 19\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b = 17\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loaded:\n",
      "  a = 17.0\n",
      "  b = 19.0\n"
     ]
    }
   ],
   "source": [
    "a = float(input(\"a = \"))\n",
    "b = float(input(\"b = \"))\n",
    "if a > b:\n",
    "    # a and b are in a wrong order, so we swap their values\n",
    "    (a, b) = (b, a)\n",
    "# Print the result, to check if it's correct\n",
    "print(\"Loaded:\")\n",
    "print(\"  a =\", a)\n",
    "print(\"  b =\", b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Please, **do not use this** until you know how and why it works."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": null
    }
   },
   "source": [
    "# An example: digits of a number\n",
    "\n",
    "Here is the problem:\n",
    "\n",
    "> Find the sum of a given number's digits.\n",
    "\n",
    "While there is a very \"Pythonic\" way to get the digits of a number, we shall do the usual integer arithmetic algorithm that is easy to port to all major modern languages."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "How do we find digits of a number `x`?\n",
    "\n",
    "The last one is easy: `x % 10` is the remainder of the division $x / 10$. But what about the rest?\n",
    "\n",
    "Here is a simple trick: once we're done with the last digit, we don't need it anymore and we can discard it. How do we do that?\n",
    "\n",
    "Hint: we have just used the `%` operator to get the last digit. Is there an operator that gives `x` **without** the last digit?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Of course there is: operator `//` (integer division) is complementary to `%`. More precisely, `x // 10` gives us `x` without the last digit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1719\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = 1719\n",
      "x % 10 = 9\n",
      "x // 10 = 171\n"
     ]
    }
   ],
   "source": [
    "x = int(input())\n",
    "print(\"x =\", x)\n",
    "print(\"x % 10 =\", x % 10)\n",
    "print(\"x // 10 =\", x // 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "A word of warning: try the above code with a negative `x`!\n",
    "\n",
    "How do we deal with that?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "There is a nice function for getting the absolute value of a number, conveniently called `abs()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-1719\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = 1719\n",
      "x % 10 = 9\n",
      "x // 10 = 171\n"
     ]
    }
   ],
   "source": [
    "x = abs(int(input()))\n",
    "print(\"x =\", x)\n",
    "print(\"x % 10 =\", x % 10)\n",
    "print(\"x // 10 =\", x // 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "So, here is a sketch of how to solve the above problem (sum of digits):\n",
    "1. initialize `s = 0`,\n",
    "2. load an integer and save its absolute value to `x`,\n",
    "3. get the last digit from `x` and add it to `s`,\n",
    "4. remove that last digit from `x`,\n",
    "5. repeat the steps 3-4 until `x` has no more digits (i.e., it drops to zero).\n",
    "\n",
    "We'll add additional `print()` to the loop, to follow the states of the variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-1719\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = 1719\n",
      "sum = 9; x = 171\n",
      "sum = 10; x = 17\n",
      "sum = 17; x = 1\n",
      "sum = 18; x = 0\n",
      "final sum = 18\n",
      "final x = 0\n"
     ]
    }
   ],
   "source": [
    "s = 0\n",
    "x = abs(int(input()))\n",
    "print(\"x =\", x)\n",
    "while x > 0:\n",
    "    s += x % 10\n",
    "    x //= 10\n",
    "    print(\"sum = \" + str(s) + \"; x =\", x)\n",
    "print(\"final sum =\", s)\n",
    "print(\"final x =\", x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Important:** Notice the final value of `x` in the last line -- it is zero. Doing the above, the value of the variable is **lost** and cannot be recreated!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "If we need the value of `x` afterwards, we have to keep it in another variable (or do the whole thing in a function, as we shall soon see):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-1719\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = 1719; s = 0; tmp = 1719\n",
      "x = 1719; s = 9; tmp = 171\n",
      "x = 1719; s = 10; tmp = 17\n",
      "x = 1719; s = 17; tmp = 1\n",
      "x = 1719; s = 18; tmp = 0\n",
      "Final values: x = 1719; s = 18; tmp = 0\n"
     ]
    }
   ],
   "source": [
    "s = 0\n",
    "x = abs(int(input()))\n",
    "tmp = x\n",
    "print(\"x = \" + str(x) + \"; s = \" + str(s) + \"; tmp = \" + str(tmp))\n",
    "while tmp > 0:\n",
    "    s += tmp % 10\n",
    "    tmp //= 10\n",
    "    print(\"x = \" + str(x) + \"; s = \" + str(s) + \"; tmp = \" + str(tmp))\n",
    "print(\"Final values: x = \" + str(x) + \"; s = \" + str(s) + \"; tmp = \" + str(tmp))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "By the way, there is a shorter way to do this, but specific to Python:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-1719\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "18\n"
     ]
    }
   ],
   "source": [
    "print(sum(int(d) for d in str(abs(int(input())))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "We'll be able to understand the above code later on."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# A bit more on Boolean expressions\n",
    "\n",
    "Whenever we write\n",
    "\n",
    "```python\n",
    "if some_condition:\n",
    "    do_something()\n",
    "```\n",
    "\n",
    "we are effectively saying\n",
    "\n",
    "> If `some_condition` is true, then `do_something()`.\n",
    "\n",
    "This is pretty straighforward when `some_condition` has a Boolean value. But, one can use most of the types in a condition. In this case, we say that we are using those values in a *Boolean context*.\n",
    "\n",
    "Some general rules of evaluation in Boolean context:\n",
    "\n",
    "1. `None` and 0 (zero) evaluate to `False`.\n",
    "\n",
    "2. Non-zero numbers evaluate to `True`.\n",
    "\n",
    "Some examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 is false.\n",
      "17 is true.\n",
      "x is false.\n",
      "y is false.\n",
      "1-1 is false.\n"
     ]
    }
   ],
   "source": [
    "x = 0\n",
    "y = 1-1\n",
    "if 0:\n",
    "    print(\"0 is true.\")\n",
    "else:\n",
    "    print(\"0 is false.\")\n",
    "if 17:\n",
    "    print(\"17 is true.\")\n",
    "else:\n",
    "    print(\"17 is false.\")\n",
    "if x:\n",
    "    print(\"x is true.\")\n",
    "else:\n",
    "    print(\"x is false.\")\n",
    "if y:\n",
    "    print(\"y is true.\")\n",
    "else:\n",
    "    print(\"y is false.\")\n",
    "if 1-1:\n",
    "    print(\"1-1 is true.\")\n",
    "else:\n",
    "    print(\"1-1 is false.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "As we learn new data structures, we will mention their Boolean interpretations as well. However, a general rule is: if it resembles a zero or if it is empty, its Boolean interpretation is `False`; otherwise, it is `True`. Still, if unsure, check for yourself:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(bool(1))"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow"
 },
 "nbformat": 4,
 "nbformat_minor": 0
}