03-flow-conditionals.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "8z5cONg8rUrX",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Program flow, conditionals & selection\n",
    "\n",
    "## Programming Fundamentals (NB03)\n",
    "\n",
    "### MIEIC/2020-21\n",
    "\n",
    "#### João Correia Lopes\n",
    "\n",
    "FEUP/DEI and INESC TEC"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "MZzE7pYorju5",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Goals\n",
    "\n",
    "By the end of this class, the student should be able to:\n",
    "\n",
    "- Describe how to `import` and do simple graphics with the module \"turtle\"\n",
    "\n",
    "- Describe an instance of Turtle, its own attributes and methods\n",
    "\n",
    "- Describe the flow of execution of the for loop\n",
    "\n",
    "- Describe the `range` function\n",
    "\n",
    "- Describe conditionals and selection\n",
    "\n",
    "- Describe Boolean values, logical operators, and expressions\n",
    "\n",
    "- Describe the use of if-then-else blocks for conditional execution\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "eR5Lh1jNroE2",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Bibliography\n",
    "\n",
    "- Peter Wentworth, Jeffrey Elkner, Allen B. Downey, and Chris Meyers, *How to Think Like a Computer Scientist — Learning with Python 3* (Section 3.1 & Section 3.2)\n",
    "\n",
    "- Brad Miller and David Ranum, Learning with Python: Interactive Edition. Based on material by Jeffrey Elkner, Allen B. Downey, and Chris Meyers (Chapter 4 & Chapter 7)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "UlT41tXPHeAx",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Program flow (with Turtles)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Vl0u1-guAR-3",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Python Modules\n",
    "\n",
    "- There are many modules in Python that provide very powerful features\n",
    "    that we can use in our own programs:\n",
    "  * to do maths\n",
    "  * to send email\n",
    "  * to fetch web pages (*scraping*)\n",
    "  * ... and many others\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "QVMIGeFZLScL",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- With `turtle` one creates turtles and get them to draw shapes and\n",
    "    patterns\n",
    "\n",
    "- ... but the aim is to develop the theme: \"computational thinking\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "KKXsawb3A6MI",
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Runestone Interactive vídeo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "49y1cw2oA-pU",
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "from IPython.display import YouTubeVideo\n",
    "YouTubeVideo('GCLHuPBtLdQ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "5zHy3QBYTFef",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Modules\n",
    "\n",
    "\n",
    "- A **module** is a file containing Python definitions and statements\n",
    "    intended for use in other Python programs\n",
    "\n",
    "- There are many Python modules that come with Python as part of the\n",
    "    Standard Library\n",
    "\n",
    "- Once we import the module, we can use things that are defined inside\n",
    "\n",
    "$\\Rightarrow$ <https://docs.python.org/3.8/>\\\n",
    "$\\Rightarrow$ <https://docs.python.org/3.8/library/>\\\n",
    "$\\Rightarrow$ <https://docs.python.org/3/py-modindex.html>\\\n",
    "$\\Rightarrow$ <https://docs.python.org/3.8/library/turtle.html>\\\n",
    "$\\Rightarrow$ <https://github.com/python/cpython/blob/3.8/Lib/turtle.py>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "lE7M5KmHTiqI",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Using Modules\n",
    "\n",
    "- The first thing we need to do when we wish to use a module is\n",
    "    perform an import\n",
    "\n",
    "- The statement `import turtle` creates a new name, `turtle`, and\n",
    "    makes it refer to a module object\n",
    "\n",
    "- This looks very much like the reference diagrams for simple\n",
    "    variables\n",
    "\n",
    "![turtle module](images/03/turtle.png)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "U7nQ3C5gUGBQ",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### The `math` module\n",
    "\n",
    "\n",
    "- The math module contains the kinds of mathematical functions you\n",
    "    would typically find on your calculator, and\n",
    "\n",
    "- some mathematical constants like *pi* and *e*\n",
    "\n",
    "![math](images/03/math.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### An example with `math`\n",
    "\n",
    "\n",
    "$\\Rightarrow$\n",
    "<https://github.com/fpro-feup/public/blob/master/lectures/03/math.py>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "print(math.pi)\n",
    "print(math.e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(math.sqrt(2.0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(math.sin(math.radians(90)))   # sin of 90 degrees"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "U06Lzg_cU3Gr",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### The `random` module\n",
    "\n",
    "We often want to use **random numbers** in programs<sup>1</sup>. \n",
    "Here are a few typical uses:\n",
    "\n",
    "-   To play a game of chance where the computer needs to throw some\n",
    "    dice, pick a number, or flip a coin\n",
    "\n",
    "-   To shuffle a deck of playing cards randomly\n",
    "\n",
    "-   To randomly allow a new enemy spaceship to appear and shoot at you\n",
    "\n",
    "-   To simulate possible rainfall when we make a computerised model for\n",
    "    estimating the environmental impact of building a dam\n",
    "\n",
    "-   For encrypting your banking session on the Internet\n",
    "\n",
    "<sup>1</sup>It is important to note that random number generators are based on\n",
    "    a *deterministic algorithm* --- repeatable and predictable. So\n",
    "    they're called *pseudo-random generators* --- they are not genuinely\n",
    "    random."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### An example with `random`\n",
    "\n",
    "$\\Rightarrow$\n",
    "<https://github.com/fpro-feup/public/blob/master/lectures/03/random.py>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "# random() returns a floating point number in the range [0.0, 1.0)\n",
    "\n",
    "prob = random.random()\n",
    "print(prob)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# randrange function generates an integer between its lower and upper argument\n",
    "\n",
    "diceThrow = random.randrange(1, 7)       # return an int, one of 1,2,3,4,5,6\n",
    "print(diceThrow)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# converted the result of the method call to a number in the range [0.0, 5.0)\n",
    "\n",
    "prob = random.random()\n",
    "result = prob * 5\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "uKHg5sKMBdmb",
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Runestone Interactive vídeo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "DmGI_zu_BfCr",
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "from IPython.display import YouTubeVideo\n",
    "YouTubeVideo('SGVgAV0v-Ww')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "kHauPk-OKzdn",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 3.1.1 Our first turtle program\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "X67Z1ULILfld",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- Every window contains a *canvas*, which is the area inside\n",
    "the window on which we can draw\n",
    "\n",
    "$\\Rightarrow$\n",
    "<https://github.com/fpro-feup/public/blob/master/lectures/03/turtles.py>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "h13amj_Qvyz9",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "import turtle\n",
    "\n",
    "window = turtle.Screen()\n",
    "\n",
    "window.bgcolor(\"lightgreen\")\n",
    "window.title(\"Hello, Alex!\")\n",
    "\n",
    "alex = turtle.Turtle()\n",
    "alex.color(\"blue\")\n",
    "alex.pensize(3)\n",
    "\n",
    "alex.forward(50)\n",
    "alex.left(120)\n",
    "alex.forward(50)\n",
    "\n",
    "# window.mainloop()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "kjpwUJ2M_gm0",
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Runestone Interactive vídeo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "EU64IFvl_jI0",
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "from IPython.display import YouTubeVideo\n",
    "YouTubeVideo('Yxyx6KpKRzY')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "YDe_ay_AHor-",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 3.1.2 Instances — a herd of turtles"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Teycmy-8MLxX",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- From a *class* (Turtle) one may have many *objects* (**instances** of\n",
    "Turtle)\n",
    "\n",
    "- Each instance has its own **state** and **behaviour**\n",
    "\n",
    "``` \n",
    "import turtle\n",
    "\n",
    "window = turtle.Screen()   # Set up the window and its attributes\n",
    "window.title(\"Tess & Alex\")\n",
    "\n",
    "tess = turtle.Turtle()     # Create tess and set some attributes\n",
    "tess.color(\"Pink\"); \n",
    "\n",
    "alex = turtle.Turtle()     # Create alex\n",
    "alex.color(\"Navy\"); \n",
    "\n",
    "# ... and more\n",
    "```\n",
    "$\\Rightarrow$ \n",
    "<https://github.com/fpro-feup/public/blob/master/lectures/03/herd.py>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "0ReMim-vHvl5",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 3.1.3  The for loop\n",
    "\n",
    "- A basic building block of all programs to be able to *repeat*\n",
    "    some code, over and over again.\n",
    "\n",
    "- In computer science, we refer to this repetitive idea as *iteration*\n",
    "\n",
    "- it has a *loop variable*, an indented *loop body*, and a terminating\n",
    "    condition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "v5Nwv7KGgFSE",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "for friend in [\"Joe\", \"Zoe\", \"Zuki\", \"Thandi\", \"Paris\"]:\n",
    "    # note the indentation of the loop body!\n",
    "    invite = \"Hi \" + friend + \". Please come to my party!\"\n",
    "    print(invite)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "d7D9iqzP_xn6",
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Runestone Interactive vídeo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "shoxl4id_5sq",
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "from IPython.display import YouTubeVideo\n",
    "YouTubeVideo('xGSfiZt5cdw')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "uoP2C_dXKQ86",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 3.1.4 Flow of Execution of the for loop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "xRBaDJLnhmrU",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Flow of Execution\n",
    "\n",
    "- As a program executes, the interpreter always keeps track of which\n",
    "    statement is about to be executed.\n",
    "\n",
    "- We call this the **control flow**, of the **flow of execution** of\n",
    "    the program.\n",
    "\n",
    "- Control flow until now has been strictly top to bottom, one\n",
    "    statement at a time (**sequential control**)\n",
    "  * The `for` loop changes this.\n",
    "\n",
    "- In Python flow is *sequential* as long as successive statements are indented the *same*\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "oalfztCOVKOc",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "for name in [\"Joe\", \"Amy\", \"Brad\", \"Angelina\", \"Zuki\", \"Thandi\", \"Paris\"]:\n",
    "    print(\"Hi \", name, \"  Please come to my party on Saturday!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "The *indented* statements that follow the \":\" are called a **block**. \n",
    "The first *unindented* statement marks the end of the block."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "W5s1iKZJVOnD",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "\n",
    "- [See it running in [pythontutor.com](http://www.pythontutor.com/visualize.html#mode=edit)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "nSvTOSeBxd2U",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Flow of Execution of `for`\n",
    "\n",
    "![for flow](images/03/for.png)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "xhpa-BDwHzPn",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 3.1.5 The loop simplifies our turtle program\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "gvkv8JsEjFhb",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### `for` loop to do a square\n",
    "\n",
    "\n",
    "To draw a square we’d like to do the same thing four times — move the turtle forward some distance and turn 90 degrees\n",
    "\n",
    "\n",
    "```\n",
    "import turtle            # set up alex\n",
    "wn = turtle.Screen()\n",
    "alex = turtle.Turtle()\n",
    "\n",
    "for i in [0, 1, 2, 3]:   # repeat four times\n",
    "    alex.forward(50)\n",
    "    alex.left(90)\n",
    "\n",
    "wn.mainloop()\n",
    "```\n",
    "$\\Rightarrow$\n",
    "<https://github.com/fpro-feup/public/blob/master/lectures/03/for.py>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "XhzX_DJIVmrj",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "for a_color in [\"yellow\", \"red\", \"purple\", \"blue\"]:  # repeat four times\n",
    "    alex.color(a_color)\n",
    "    alex.forward(50)\n",
    "    alex.left(90)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "9V38wmzkVrYt",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "colors = [\"yellow\", \"red\", \"purple\", \"blue\"]\n",
    "for color in colors:                                # for each color\n",
    "    alex.color(color)\n",
    "    alex.forward(50)\n",
    "    alex.left(90)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "j7GTWCakj8lu",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### The range Function\n",
    "\n",
    "- Python gives us special built-in range objects\n",
    "\n",
    "- Computer scientists like to count from 0!\n",
    "\n",
    "- The most general form of the range is\n",
    "    `range(start, beyondLast, step)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "TG_EySy9kNor",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "for i in range(4):\n",
    "    # Executes the body with i = 0, then 1, then 2, then 3\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "XYjlsqfRkQAA",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "for _ in range(10):\n",
    "    # Sets x to each of ... [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
    "    print(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "1OkOyVNFkTeZ",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "for i in range(0, 20, 2):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "sgfpOwYDWDaM",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### `range` is lazy\n",
    "\n",
    "The range function is lazy: \n",
    "\n",
    "- It produces the next element only when needed\n",
    "\n",
    "- With a regular Python 3 interpreter, printing a range does not calculate all the elements\n",
    "\n",
    "- To immediately calculate all the elements in a range, convert the range in a list (later!)\n",
    "  * `list(range(4))`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "4NIuUzJAATK2",
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Runestone Interactive vídeo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "WRHwVXAQAUPz",
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "from IPython.display import YouTubeVideo\n",
    "YouTubeVideo('YK8QlIT3__M')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "vIvn-158kcm4",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 3.1.6 A few more turtle methods and tricks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "PicDe9iskj28",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- `tess.left(-30)` / `tess.right(330)` ?\n",
    "\n",
    "- `alex.backward(-100)` / `alex.forward(100)` ?\n",
    "\n",
    "- `alex.penup()` and `alex.pendown()`\n",
    "\n",
    "- `alex.shape(\"turtle\")`\n",
    "\n",
    "- `alex.speed(10)`\n",
    "\n",
    "$\\Rightarrow$\n",
    "<https://github.com/fpro-feup/public/blob/master/lectures/03/stamp.py>\n",
    "\n",
    "$\\Rightarrow$\n",
    "<https://github.com/fpro-feup/public/blob/master/lectures/03/clock.py>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ctRIEHAQH4pt",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Conditionals & selection"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "vbbGCyS0kT6j",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 3.2.1 Boolean values and expressions\n",
    "\n",
    "- Programs get really interesting when we can test conditions and\n",
    "    change the program behaviour\n",
    "\n",
    "- A *Boolean* value is either true or false\n",
    "\n",
    "- In Python, the two Boolean values are `True` and `False` and the\n",
    "    type is `bool`\n",
    "\n",
    "- A Boolean expression is an expression that evaluates to produce a\n",
    "    result which is a Boolean value\n",
    "\n",
    "- For example, the operator `==` tests if two values are equal"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Booleans"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "LxmLNnIXXyqH",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(True)\n",
    "print(type(True))\n",
    "print(type(False))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "8jiD_7sWZEws",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(type(True))\n",
    "print(type(\"True\"))\n",
    "type(true)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "3-_fwKYtX0P0",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(5 == (3 + 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "BBQ3B9NDYG1M",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "age = 17\n",
    "old_enough_to_get_driving_licence = age >= 18\n",
    "print(old_enough_to_get_driving_licence)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "y2B7J3s3YJut",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "$\\Rightarrow$\n",
    "<https://github.com/fpro-feup/public/blob/master/lectures/03/booleans.py>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "V-89I9XfYm8T",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Comparison operators\n",
    "\n",
    "```\n",
    "x == y          # Produce True if ... x is equal to y\n",
    "x != y          # ... x is not equal to y\n",
    "x > y           # ... x is greater than y\n",
    "x < y           # ... x is less than y\n",
    "x >= y          # ... x is greater than or equal to y\n",
    "x <= y          # ... x is less than or equal to y\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Ob-aZZ1xIKoy",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 3.2.2 Logical operators\n",
    "\n",
    "- There are three logical operators, `and`, `or`, and `not`\n",
    "\n",
    "- Used to build more complex Boolean expressions from simpler Boolean\n",
    "    expressions\n",
    "\n",
    "- The semantics (meaning) of these operators is similar to their\n",
    "    meaning in English\n",
    "\n",
    "- The expression on the left of the `or` operator is evaluated first:\n",
    "\n",
    "    -   if the result is `True`, Python does not (and need not) evaluate\n",
    "        the expression on the right\n",
    "\n",
    "    -   this is called **short-circuit evaluation**\n",
    "\n",
    "-   Similarly, for the `and` operator:\n",
    "\n",
    "    -   if the expression on the left yields `False`, Python does not\n",
    "        evaluate the expression on the right"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ke0ntDITaAvG",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "x = 5\n",
    "print(x > 0 and x < 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "h3hNe_0BaDnP",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "n = 25\n",
    "print(n % 2 == 0 or n % 3 == 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "5z2FE5pG6bj1",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a = 5+2 == 7\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "C8bnlC8ZawNh",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Common Mistake!\n",
    "\n",
    "- There is a very common mistake that occurs when programmers try to write boolean expressions\n",
    "\n",
    "- For example, what if we have a variable number and we want to check to see if its value is 5, 6, or 7\n",
    "\n",
    "- In words we might say: “number equal to 5 or 6 or 7”\n",
    "\n",
    "- Here you cannot take a shortcut!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "vHDBPXERbq24",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "number = 4\n",
    "number == 5 or 6 or 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "voIGyBzAbyva",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "number = 4\n",
    "number == 5 or number == 6 or number == 7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "JAY2Lg23IN6w",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 3.2.3 Truth Tables\n",
    "\n",
    "A truth table is a small table that allows us to list all the possible inputs, and to give the results for the logical operators."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "MHcxJFpRZ7bh",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Truth Table: `and`\n",
    "\n",
    "| a       | b       | a and b |\n",
    "| ------- | ------- | ------- |\n",
    "| False   | False   | False   |\n",
    "| False   | True    | False   |\n",
    "| True    | False   | False   |\n",
    "| True    | True    | True    |\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "_xt228pKaQ19",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Truth Table: `or`\n",
    "\n",
    "| a       | b       | a or b   | \n",
    "| ------- | ------- | -------- |\n",
    "| False   | False   | False    |\n",
    "| False   | True    | True     |\n",
    "| True    | False   | True     |\n",
    "| True    | True    | True     |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Ai07ULFOaV4Q",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Truth Table: `not`\n",
    "\n",
    "| a       | not a   |\n",
    "| ------- | ------- |\n",
    "| False   | True    |\n",
    "| True    | False   |\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "YaQXhnfTabUI",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Precedence of Operators\n",
    "\n",
    "The order of evaluation (**rules of precedence**) now with the boolean values.\n",
    "\n",
    "| **Level**   | **Category**     | **Operators** |\n",
    "| ----------- | ---------------- | ------------- |\n",
    "| 7(high)     | exponent         | **            |\n",
    "| 6           | multiplication   | *, /, //, %   |\n",
    "| 5           | addition         | +,-           |\n",
    "| 4           | **relational**   | ==, !=, \\<=, \\>=, \\>, \\< |\n",
    "| 3           | **logical**      | not           |\n",
    "| 2           | **logical**      | and           |\n",
    "| 1(low)      | **logical**      | or            |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "2kgXqqxWIQ-z",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 3.2.4 Simplifying Boolean Expressions\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "BFP9aR08bAgY",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Boolean algebra\n",
    "\n",
    "- A set of rules for simplifying and rearranging expressions is called\n",
    "    an *Algebra*\n",
    "\n",
    "- The *Boolean algebra* provides rules for working with Boolean values, thus simplifying Boolean expressions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "n4v2hi-abS8m",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Boolean algebra: `and`\n",
    "\n",
    "\n",
    "```\n",
    "x and False == False\n",
    "False and x == False\n",
    "y and x == x and y\n",
    "x and True == x\n",
    "True and x == x\n",
    "x and x == x\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "LsD33no5bczw",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Boolean algebra: `or`\n",
    "\n",
    "\n",
    "```\n",
    "x or False == x\n",
    "False or x == x\n",
    "y or x == x or y\n",
    "x or True == True\n",
    "True or x == True\n",
    "x or x == x\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "tueGJLcLb-gk",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Boolean algebra: `not`\n",
    "\n",
    "\n",
    "```\n",
    "not (not x) == x\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "fzM2CPUQIT08",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 3.2.5 Conditional execution\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "yrO1PwXbcI4D",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Conditional statements: `if`\n",
    "\n",
    "- Conditional statements give us the ability to check conditions and\n",
    "    change the behavior of the program accordingly\n",
    "\n",
    "- The simplest form is the *if statement*\n",
    "\n",
    "- The Boolean expression after the if statement is called the\n",
    "    **condition**\n",
    "\n",
    "- The `if` statement referred to as **binary selection** since there are two possible paths of execution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "hptWbD3McW1a",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "x = 15\n",
    "\n",
    "if x % 2 == 0:\n",
    "    print(x, \"is even\")\n",
    "else:\n",
    "    print(x, \"is odd\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Runestone Interactive vídeo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "from IPython.display import YouTubeVideo\n",
    "YouTubeVideo('HriDtn-0Dcw')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "7KNuKvRpcgVD",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### If statement with an else clause\n",
    "\n",
    "\n",
    "```\n",
    "if <BOOLEAN EXPRESSION>:\n",
    "    <STATEMENTS_1>\n",
    "else:\n",
    "    <STATEMENTS_2>\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "8N1jAK-scnit",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### if-then-else flowchart\n",
    "\n",
    "![if-else](images/03/if-else.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "jM6sBDHmdCQK",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Blocks and indentation\n",
    "\n",
    "\n",
    "- The indented statements that follow are called a **block**\n",
    "\n",
    "- The first unindented statement marks the end of the block\n",
    "\n",
    "- There is no limit on the number of statements that can appear under\n",
    "    the two clauses of an if statement\n",
    "\n",
    "- ... but there has to be at least one statement in each block\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ceKSOBWidVr-",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Scaffolding\n",
    "\n",
    "- Occasionally, it is useful to have a section with no statements\n",
    "\n",
    "  * usually as a place keeper, or *scaffolding*, for code we haven't\n",
    "    written yet\n",
    "\n",
    "```\n",
    "if True:  # This is always True,\n",
    "   pass   # so this is always executed, but it does nothing\n",
    "else:\n",
    "   pass   # And this is never executed\n",
    "```\n",
    "\n",
    "$\\Rightarrow$\n",
    "<https://github.com/fpro-feup/public/blob/master/lectures/03/selections.py>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ya6Tz2j4IWTW",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 3.2.6 Omitting the else clause\n",
    "\n",
    "- Another form of the if statement is one in which the else clause is omitted entirely\n",
    "\n",
    "- This creates what is sometimes called **unary selection**\n",
    "\n",
    "\n",
    "```\n",
    "if <BOOLEAN EXPRESSION>:\n",
    "    <STATEMENTS>\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "toVKf6xEdLi4",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### unary selection flowchart\n",
    "\n",
    "![if](images/03/if.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "asEDaG6fdQv3",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "x = 10\n",
    "if x < 0:\n",
    "    print(\"The negative number \",  x, \" is not valid here.\")\n",
    "print(\"This is always printed\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Runestone Interactive vídeo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "from IPython.display import YouTubeVideo\n",
    "YouTubeVideo('Fd4a8ktQURc')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Np4RdifjIZKd",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 3.2.7 Chained conditionals\n",
    "\n",
    "```\n",
    "if <BOOLEAN EXPRESSION_1>:\n",
    "    <STATEMENTS_A>\n",
    "elif <BOOLEAN EXPRESSION_2>:\n",
    "    <STATEMENTS_B>\n",
    "else:\n",
    "    <STATEMENTS_C>\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "_svwUYJ59TvA",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Chained conditionals flowchart\n",
    "\n",
    "![if-elif](images/03/if-elif.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "MKH6ta2DIcAR",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 3.2.8 Nested conditionals\n",
    "\n",
    "```\n",
    "if <BOOLEAN EXPRESSION 1>:\n",
    "    <STATEMENTS_A>\n",
    "else:\n",
    "    if <BOOLEAN EXPRESSION 2>:\n",
    "        <STATEMENTS_B>\n",
    "    else:\n",
    "        <STATEMENTS_C>\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "UJw7XPUh9kzM",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Nested conditionals flowchart\n",
    "\n",
    "\n",
    "![if-nested](images/03/if-nested.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "6gSW77AFz2yk",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "x = 10\n",
    "y = 10\n",
    "\n",
    "if x < y:\n",
    "    print(\"x is less than y\")\n",
    "else:\n",
    "    if x > y:\n",
    "        print(\"x is greater than y\")\n",
    "    else:\n",
    "        print(\"x and y must be equal\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "0V_qPI7xETt4",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "\n",
    "- [See it running in [pythontutor.com](http://www.pythontutor.com/visualize.html#mode=edit)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "L-KLOrH_Iepw",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## 3.2.9 Logical opposites\n",
    "\n",
    "| operator | logical opposite |\n",
    "| -------- | ---------------- |\n",
    "| ==       |  !=              |\n",
    "| !=       |  ==              |\n",
    "| \\<       |  \\>=             |\n",
    "| \\<=      |  \\>              |\n",
    "| \\>       |  \\<=             |\n",
    "| \\>=      |  \\<              | \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ZWWmg4tif49e",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Get rid of `not` operators\n",
    "\n",
    "\n",
    "- Understanding the logical opposites allows us to sometimes get rid\n",
    "    of not operators.\n",
    "\n",
    "- `not` operators are often quite difficult to read in computer code,\n",
    "    and our intentions will usually be clearer if we can eliminate them\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "nBWQ4zkfgGo2",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "age = 17\n",
    "if not (age >= 18):\n",
    "   print(\"Hey, you're too young to get a driving licence!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "OUjYCfLygLic",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "if age < 18:\n",
    "   print(\"Hey, you're too young to get a driving licence!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "W2gFpo2XggJ_",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### de Morgan's laws\n",
    "\n",
    "- Two powerful simplification laws that are often helpful when dealing\n",
    "    with complicated Boolean expressions\n",
    "\n",
    "```\n",
    "(not (x and y))  ==  ((not x) or (not y))\n",
    "(not (x or y))   ==  ((not x) and (not y))\n",
    "```\n",
    "\n",
    "$\\Rightarrow$\n",
    "<https://github.com/fpro-feup/public/blob/master/lectures/03/simplify.py>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "iJIhEYptglyi",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Ternary operators\n",
    "\n",
    "\n",
    "\\<condition_if_true\\> **if** \\<condition\\> **else** \\<condition_if_false\\>\n",
    "\n",
    "\n",
    "- It allows to quickly test a condition instead of a multiline if\n",
    "    statement\n",
    "\n",
    "- Often it can be immensely helpful and can make your code compact\n",
    "    but still maintainable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Q4rDgTAOjYcG",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "is_nice = True\n",
    "pretty = \"nice\" if is_nice else \"not nice\"\n",
    "pretty"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "XFxdiQt6050p",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Boolean functions\n",
    "\n",
    "Looking forward: you will see functions soon."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "q7NkqzlX0-tc",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def is_divisible(x, y):\n",
    "    return x % y == 0\n",
    "\n",
    "if is_divisible(10, 5):\n",
    "    print(\"That works\")\n",
    "else:\n",
    "    print(\"Those values are no good\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "R8NlCrRxIjll",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Ticket to leave"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "MDIr4o7BI0W4",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Moodle activity\n",
    "\n",
    "[LE03: Flow & conditionals](https://moodle.up.pt/course/view.php?id=1738#section-1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "5chD-xywI7XC",
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "\n",
    "$\\Rightarrow$ \n",
    "[Go back to the Table of Contents](00-contents.ipynb)\n",
    "\n",
    "$\\Rightarrow$ \n",
    "[Read the Preface](00-preface.ipynb)"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "None",
  "colab": {
   "collapsed_sections": [],
   "name": "03-flow-conditional.ipynb",
   "private_outputs": true,
   "provenance": [],
   "toc_visible": true
  },
  "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.8.5"
  },
  "rise": {
   "enable_chalkboard": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}