1_conditionals.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "sx2_ytTonyCz",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Boolean and Conditional logic\n",
    "\n",
    "- prepared by [Katarina Nastou](https://www.cpr.ku.dk/staff/?pure=en/persons/672471)\n",
    "\n",
    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/pythontsunami/teaching/blob/intro/1_conditionals.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "f0z_VyIZfL_2",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Objectives\n",
    "\n",
    "\n",
    "- Learn how to get user input in Python\n",
    "- statement grouping is by indentation\n",
    "- Learn about \"Truthiness\"\n",
    "- Learn how to use comparison operators to make a basic program\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "OMcp2kWqi8ik",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## User Input\n",
    "There is a built-in function in Python called \"input\" that will prompt the user and store the result to a variable.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 3474,
     "status": "ok",
     "timestamp": 1583694636703,
     "user": {
      "displayName": "Catherine Nst",
      "photoUrl": "",
      "userId": "00118750132604534762"
     },
     "user_tz": -60
    },
    "id": "90A_eVFDjZSO",
    "outputId": "2ca19a1e-f379-443d-9f97-3864784d83ad",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "name = input(\"Enter your name here: \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 559,
     "status": "ok",
     "timestamp": 1583694638578,
     "user": {
      "displayName": "Catherine Nst",
      "photoUrl": "",
      "userId": "00118750132604534762"
     },
     "user_tz": -60
    },
    "id": "uFvOHE4QjhG_",
    "outputId": "258f0866-22a4-489b-d256-c5f7fa545b0e",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "UEidBq19jrHt",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Boolean Expressions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "kKTTEKx1jv6h",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### Conditional Statements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "g7oUjlMDj1Bh",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "[Conditional logic](https://docs.python.org/3/tutorial/controlflow.html#if-statements) using **`if`** statements represents different paths a program can take based on some type of comparison of input.\n",
    "\n",
    "```python\n",
    "if some condition is True:\n",
    "    do something\n",
    "elif some other condition is True:\n",
    "    do something\n",
    "else:\n",
    "    do something\n",
    "```\n",
    "\n",
    "> Statements which should be executed if a condition is fulfilled, are intendet."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "MBH1G8cJkHyg",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### Quiz:\n",
    "Try setting the name variable to \"Gandalf\" or \"Aragorn\" and run the script above again.\n",
    "\n",
    "> `==` compares if the values of two objects are equal. We will look at the difference between `is` and `==` comparison later."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "lNBhkHV5kB29",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "name = input(\"Enter your name here: \")\n",
    "if name == \"Gandalf\":\n",
    "    print(\"Run, you fools!\")\n",
    "elif name == \"Aragorn\":\n",
    "    print(\"There is always hope.\")\n",
    "else:\n",
    "    print(\"Move on then!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "SKnzmfmgooc6",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Exercise 1\n",
    "At the next code block there is some code that randomly picks a number from 1 to 10. \n",
    "Write a conditional statement to check if `choice` is 5 and print `\"Five it is!\"` and in any other case print `\"Well that's not a 5!\"`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Mb_BZVxPooBS",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "from random import randint\n",
    "choice = randint(1,10)\n",
    "\n",
    "# YOUR CODE GOES HERE vvvvvv\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "kioEJrhzpZnM",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Exercise 2\n",
    "At the next code block there is some code that randomly picks a number from 1 to 1000. Use a conditional statement to check if the number is odd and print `\"odd\"`, otherwise print `\"even\"`.\n",
    "\n",
    "> *Hint*: Remember the numerical operators we saw before in [1_numbers_operators_comments.ipynb](1_numbers_operators_comments.ipynb) and think of which one can help you find an odd number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "zaALh72SpZQi",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "from random import randint\n",
    "num = randint(1, 1000) #picks random number from 1-1000\n",
    "\n",
    "# YOUR CODE GOES HERE vvvvvvv\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "0QVDXNorlaY4",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Comparison Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "YZnI0AZGlc5N",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "In the examples, `a = 2` and `b = 2`, i.e. we are comparing to integers (`int`)\n",
    "\n",
    "\n",
    "operator | Description | Example (`a, b = 2, 2`)\n",
    "---            | ---   |---\n",
    "`==`  | True if a has the same value as b  | `a == b  # True`\n",
    "`!=`  |\tTrue if a does NOT have the same value as b | `a != b  # False`\n",
    "`>`   | True if a is greater than b  |  `a > b  # False`\n",
    "`<`   | True if a is less than be b  | `a < b # False`\n",
    "`>=`    | True if a is greater than or equal to b   |  `a >= b  # True`\n",
    "`<=`    | True if a is less than or equal to b | `a <= b  # True`\n",
    "\n",
    "> Hint: What a comparison does is defined by the type of a and b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a, b = 2, 2\n",
    "a >= b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise: \n",
    "Ask for integer and check \n",
    "- if values is below zero. State that the value is negative.\n",
    "- for values between zero and 20, print the value\n",
    "- for larger values, print that these are out of scope.\n",
    "\n",
    "> Hint: You can chain comparisons."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "IBHh_cJzlMLr",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Truthiness"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "hu3pjkY_lP5n",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "In Python, all conditional checks resolve to `True` or `False`.\n",
    "\n",
    "```python\n",
    "x = 1\n",
    "x == 1  # True\n",
    "x == 0  # False\n",
    "```\n",
    "\n",
    "Besides false conditional checks, other things that are naturally \"falsy\" include: empty objects, empty strings, None, and zero (and non-empty things are normally `True`).\n",
    "\n",
    "\n",
    "> \"Although Python has a bool type, it accepts any object in a boolean context, such as the\n",
    "> expression controlling an if or while statement, or as operands to and, or, and not. \n",
    "> To determine whether a value x is _truthy_ or _falsy_, Python applies `bool(x)`, which always returns True or False.  \n",
    "> \n",
    "> (...) Basically, `bool(x)` calls `x.__bool__()` and uses the result. \n",
    "> If `__bool__` is not implemented, Python tries to invoke `x.__len__()`, and if that returns zero, bool returns `False`. \n",
    "> Otherwise bool returns `True`.\" (Ramalho 2016: Fluent Python, p. 12)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ntvM86pmmVNf",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Logical Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "HIOcNmRdmXkY",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "In Python, the following operators can be used to make Boolean Logic comparisons or statements:\n",
    "\n",
    "\n",
    "`and`, True if both a AND b are true (logical conjunction)\n",
    "\n",
    "```python\n",
    "if cats_are_cute and dogs_are_cute:\n",
    "    print(c) \n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "HIOcNmRdmXkY",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "`or`, True if either a OR b are true (logical disjunction) \n",
    "```python\n",
    "    if am_tired or is_bedtime:\n",
    "        print(\"go to sleep\")\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "HIOcNmRdmXkY",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "`not`, True if the opposite of a is true (logical negation)\n",
    "```python\n",
    "if not is_weekend:\n",
    "    print(\"go to work\")\n",
    "\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Here the `if` statement automatically calls `bool` on the expression, e.g. `bool(cats_are_cute and dogs_are_cute)`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "fJyWAxAkm6un",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### `is` vs `==`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "nSGr7Ozjm9WO",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "In python, `==` and `is` are very similar comparators, however they are not the same.\n",
    "\n",
    "```python\n",
    "a = 1\n",
    "a == 1  # True\n",
    "a is 1  # True (why?)\n",
    "```\n",
    "\n",
    "```python\n",
    "a = [1, 2, 3]  # a list of numbers\n",
    "b = [1, 2, 3]\n",
    "a == b  # True\n",
    "a is b  # False (why not?)\n",
    "```\n",
    "\n",
    "```python\n",
    "c = b\n",
    "b is c  # True\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "xQVMaPxYnOkf",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "**`is`** comparisions only return `True` if the variables reference the same item *in memory*. It is recommendend to [test Singletons with `is`](https://www.python.org/dev/peps/pep-0008/#programming-recommendations) and not `==`, e.g. `None`, `True`, `False`.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "gwg0M-dcqSad",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Quiz\n",
    "\n",
    "**Question 1**: What is truthiness?\n",
    "\n",
    "1. Statements or facts that seem \"kind of true\" even if they aren't true necessarily\n",
    "2. Statements or expressions that result to a True value\n",
    "3. Code that never lies\n",
    "4. Computers have the tendency to believe things are True until proven False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "gwg0M-dcqSad",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "**Question 2**: Is the following expression True or False?\n",
    "\n",
    "```python\n",
    "    x = 15\n",
    "    y = 0\n",
    "    x or y  # this expression\n",
    "```\n",
    "> hint: think about what `bool(x or y)`  results in ? Try it with an `if`-statement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "gwg0M-dcqSad",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**Question 3**: Is the following expression True or False?\n",
    "\n",
    "```python\n",
    "    x = 0\n",
    "    y = None\n",
    "    x or y  # this expression\n",
    "```\n",
    "> hint: think about what `bool(x or y)`  results in?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "gwg0M-dcqSad",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**Question 4**: Is the following expression True or False?\n",
    "\n",
    "```python\n",
    "    x = 0\n",
    "    y = 1000\n",
    "    x and y  # this expression\n",
    "```\n",
    "\n",
    "Choose between the 2 options:\n",
    "        True, because y has a True value, therefore x and y must be true\n",
    "        False, because x is 0 which is \"falsy\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "gwg0M-dcqSad",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**Question 5**: (Hard) Is the following expression True or False?\n",
    "\n",
    "```python\n",
    "    a = -1\n",
    "    not a  # this expression\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "gwg0M-dcqSad",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**Question 6**: Hardest question! Is the following truthy or falsy:\n",
    "```python\n",
    "    x = 0\n",
    "    y = -1\n",
    "    x or y and x - 1 == y and y + 1 == x\n",
    "```\n",
    "> tip: put parentheses around different logical statements to make it easier to break down. Read about the hierachy of operators [here](https://docs.python.org/3/tutorial/datastructures.html#more-on-conditions)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "6y2iwYFuncUy",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Recap\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "i-YiaG6YneFA",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- Conditional logic can control the flow of a program\n",
    "\n",
    "- We can use comparison and logical operators to make conditional if statements\n",
    "\n",
    "- Conditional logic evaluates whether statements are true or false\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "THMUNuzm3jtb",
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "*Note: This notebook's content structure has been adapted from Colt Steele's slides used in [Modern Python 3 Bootcamp Course](https://www.udemy.com/course/the-modern-python3-bootcamp/) on Udemy*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "colab": {
   "authorship_tag": "ABX9TyPA4FNVSbwbHXzTkHRRee18",
   "collapsed_sections": [],
   "name": "conditionals.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.7"
  },
  "rise": {
   "scroll": true
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "toc-autonumbering": true
 },
 "nbformat": 4,
 "nbformat_minor": 4
}