tu010-ControlFlowTwo-IFLogic.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "4ee24606",
   "metadata": {},
   "source": [
    "# Basic control flow in Python II"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9643a583",
   "metadata": {},
   "source": [
    "### Learning outcomes:\n",
    " - Understand and use control flow in python\n",
    " - `if`, `else` statements\n",
    " - Comparisons and Logical operators"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2918365b",
   "metadata": {},
   "source": [
    "Let's make a thought experiment as a start. Imagine giving yourself, a slightly different different, a robot-like person resembling yourself, instructions to navigate outdoor, away from this room, into the open air and sunshine. \n",
    "\n",
    "You might give yourself instructions to do so, and say things like the following:\n",
    "\n",
    "  - Stand up from desk\n",
    "  - Walk to the door\n",
    "  - *If* the door is closed *then* open the door\n",
    "  - *If* the length of the corridor to the right is shorter than that to the left *then* take the corridor to the right, *else* take corridor to the left\n",
    "  - Continue walking *for* the duration of the corridor\n",
    "  - *While* walking avoid people\n",
    "  - When the end of the corridor is reached open door to the outisde\n",
    "  - Etc.\n",
    "\n",
    "Instructions like the ones above are often needed when programming a complex task, just like navigating the college campus."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5fc8610c",
   "metadata": {},
   "source": [
    "### Control flow"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3653a714",
   "metadata": {},
   "source": [
    "**Control flow** comprises of the set of commands available in a programming language to control the flow of information processing, just like the instructions above control your navigation."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6b1ef4c8",
   "metadata": {},
   "source": [
    "Control flow comprises the set of operations that make sure the set of code operations are executed by a program.  A control flow statement allows the program to make a choice among two or more alternatives.\n",
    "\n",
    "A set of control flow operations are generally organized into blocks with a beginning and an end. The end and beginning of a control flow block is codified by dedicated words, or syntax."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "30775168",
   "metadata": {},
   "source": [
    "Control flow is core to all computer programming, not just Python. In this tutorial we are going to get started with control flow and learn about some of the core elements in Python. More specifically we will look at \n",
    "\n",
    "* for and while loops\n",
    "* conditional tests and Boolean logic\n",
    "* control flow\n",
    "* functions\n",
    "\n",
    "We will explore these things using fairly simple examples (that will also give us practice with indexing, operators, Python lists, etc). Later, we will see how useful these core elements are when they are combined!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a38d572b",
   "metadata": {},
   "source": [
    "### Control flow: Logical Tests and Boolean Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d62720d2",
   "metadata": {},
   "source": [
    "Believe it or not, everything that happens on your phone or computer comes down to lots (and I mean **LOTS**) of little decisions based on one or two inputs that can be either \"True\" or \"False\", and an output that can also be \"True\" or \"False\". \n",
    "\n",
    "Seriously, everything on any digitial device – from Tik Tok videos to your Python code – comes down to a whole bunch of truths and falsehoods (ones and zeros) that are themselves the result of decisions based on other truths and falsehoods. The \"decision makers\" are actual physical (but teeny teeny tiny) devices  that are combinations of things called [*transistors*](https://en.wikipedia.org/wiki/Transistor). Transistors perform conditional tests and logical operations on data. \n",
    "\n",
    "Two are the primary operations performed by transistors:\n",
    "\n",
    "* ***Comparison*** operations like `==` (equals) and `>` (greater than) that yield `True` or `False`\n",
    "* ***Logical*** operations that use ***Boolean logic***, which compares two logical inputs and returns `True` or `False` like  `A and B` (`True` only if both A and B are `True`) and `A or B` (`True` if either A or B – or both – are `True`).\n",
    "\n",
    "Let's play with this. It might seem a bit silly and obvious now, but the power of logical tests will reveal itself soon."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97244a25",
   "metadata": {},
   "source": [
    "### Comparison operators\n",
    "\n",
    "These are operators that test a single value. Imagine wanting to ask, whether the number of lives my cat has ([9 for what I was told yesterday, when I was born](https://en.wikipedia.org/wiki/Cat#Superstitions_and_rituals)) is different than the number of lives of [Schrödinger's cat](https://en.wikipedia.org/wiki/Schr%C3%B6dinger%27s_cat) has. Number to number type of questions."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "40148ae3",
   "metadata": {},
   "source": [
    "Let's set a variable `x` to 11. (Why only go to ten when you can go to 11?)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6d8b3d4f",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 11\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5378f9ef",
   "metadata": {},
   "source": [
    "Now let's do some logical tests on our variable `x`. Let's see if `x` is less than `42`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c8841a2d",
   "metadata": {},
   "outputs": [],
   "source": [
    "x < 42"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "70f3a756",
   "metadata": {},
   "source": [
    "Now you test if `x` is greater than `42`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "391f5de7",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "61ba2cac",
   "metadata": {},
   "source": [
    "We can also test for equality. Is `x` equal to `42`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "788198b2",
   "metadata": {},
   "outputs": [],
   "source": [
    "x == 42"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cb0db7bc",
   "metadata": {},
   "outputs": [],
   "source": [
    "x == 11"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "85c23215",
   "metadata": {},
   "source": [
    "Finally, we can test for *inequality*. (We test whether it is true that x is *not* equal to a specific number). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c6149376",
   "metadata": {},
   "outputs": [],
   "source": [
    "x != 42"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e839816",
   "metadata": {},
   "source": [
    "The exclamation point here means \"not\", so the experession `x != 42` can be read as \"is x not equal to 42?\"\n",
    "\n",
    "And the answer is \"That's `True`! The variable `x` is not equal to 42!\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f2ac065",
   "metadata": {},
   "source": [
    "$\\color{blue}{\\text{Complete the following exercise.}}$\n",
    "\n",
    "  - Now you test `x` to see if it's not equal to `11`. Is it?\n",
    "\n",
    "  [Use the cell below to show your code]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "de832c9a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "ce9b435d",
   "metadata": {},
   "source": [
    "As you might have noticed, all these operations are *built in.* This means that we did not have to import any specific package to access the operations. Python provides these operations as they are core functionality, the bread and butter of most users, or better said, of most programmers. Like you!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7019bb28",
   "metadata": {},
   "source": [
    "### Control flow: <if, else> statements"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ded2ac3c",
   "metadata": {},
   "source": [
    "Fundamental to any mature software or code system is the ability to express conditional statements such as `if`, `then` statements. These are among the most basic building blocks of coding, as they allow controlling the flow and allowing a certain operations to occur. For example, operation `a` might be performed only `if` a specific condition 'C' is met. Say, I can eat my cake only if I have been diligent and went out for a nice and long run today."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2148c428",
   "metadata": {},
   "source": [
    "A couple of basic numerical examples can get us started."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "766b0b79",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 3\n",
    "a_big_number = 100\n",
    "\n",
    "if x > 5 :\n",
    "    print('Yes, it is a big number!')\n",
    "else :\n",
    "    print('Nope, small!')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "133dea2b",
   "metadata": {},
   "source": [
    "We can even add another test using the elif (\"else if\") statement. When measuring the temperature in Austin TX, we would say:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0341c2e5",
   "metadata": {},
   "outputs": [],
   "source": [
    "current_temp = 70\n",
    "\n",
    "if current_temp >= 90 :\n",
    "    print('Too hot!')\n",
    "elif current_temp <= 50 :\n",
    "    print('Too cold!')\n",
    "else :\n",
    "    print('Just right!')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "94c6a0ad",
   "metadata": {},
   "source": [
    "`If, then` statements can be combined with logical operators also and help manage complex decisions in a matter of a few lines:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6881fe80",
   "metadata": {},
   "outputs": [],
   "source": [
    "current_temp = 45\n",
    "if not( (current_temp >= 90) or (current_temp <= 50) ) : \n",
    "    print('I will ride my bicycle to school!')\n",
    "else :\n",
    "    print('Too cold! I will take the car or walk.')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c77ffa8",
   "metadata": {},
   "source": [
    "$\\color{blue}{\\text{Complete the following exercise.}}$\n",
    "\n",
    "  - To practice with `if`, `then` statements, write code that when asked if we should eat cake returns `True` only if we have eaten less then 2 slices of cake today and no cake yesterday and the day before yesterday. The code should otherwise tell us to eat soup.\n",
    "  \n",
    "  [Use the cell below to show your code]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "af350e32",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "feba47f1",
   "metadata": {},
   "source": [
    "Again, all these operations are *built in* this means that we did not have to import any specific package. Python provides these basic operations as they are the bread and butter of most users, or better said, of most programmers, like you."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "836629ad",
   "metadata": {},
   "source": [
    "### Control flow: Logical operators\n",
    "\n",
    "So far we have been dealing with testing operations on single numbers. Often times it is important to be able to test multiple operations and compare them, say if `a > 0` **`and`** `b < 0`.  Operations that compare or combine two statements are called **logical**. Logical operations such as `and` and `or` are extremely important and widely used in computer programming, mathematics, neuroscience and in real life.\n",
    "\n",
    "Python provides binary operations `built in`, so there is not requirement to import a specific library."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ab93176e",
   "metadata": {},
   "source": [
    "Imagine wanting to compare the number of cake slices eaten per day by the average individual in three different countries."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2e7971d8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# average number of cake slices eaten in \n",
    "USA = 3  # the United States of America\n",
    "IT = 2   # Italy\n",
    "CA = 4   # Canada "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e686c752",
   "metadata": {},
   "source": [
    "Imagine wanting to know if BOTH the USA AND Canada eat more cake than Italy. We can first compare if the average citizen eats more cake in Italy or the USA:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ac5b3a01",
   "metadata": {},
   "outputs": [],
   "source": [
    "(USA > IT) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d03de9c5",
   "metadata": {},
   "source": [
    "Alright, it looks like more cake is eaten in the USA. What about Canada?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3e356893",
   "metadata": {},
   "outputs": [],
   "source": [
    "(CA > IT)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ae2d010",
   "metadata": {},
   "source": [
    "If we wanted to compare both the USA and Canada at the same time, in python we could conveniently write the operation as follows: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "60f940f3",
   "metadata": {},
   "outputs": [],
   "source": [
    "(USA > IT) and (CA > IT)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7e598abb",
   "metadata": {},
   "source": [
    "The statment about is *only* true if *both* statements are true. Let's test it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9aea94b6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# We will use a temporary value for canada and \n",
    "# then repeat the logical operation with the new value\n",
    "CA_temp = 1\n",
    "(USA > IT) and (CA_temp > IT)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f22c99bc",
   "metadata": {},
   "source": [
    "OK what happened there is that whereas the first statement was true (3 > 2 slices of cake) the second was not true (1 is not more then 2 slices of cake) and the whole statement returned `False`. The `and` operator returns `True` only if all composing statements return `True`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b0620ae",
   "metadata": {},
   "source": [
    "Another logical operation of Key value `OR`. `OR` returns `True` if only one of the two statements is`True`, even if the other is `False`. We can try it: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d396d15b",
   "metadata": {},
   "outputs": [],
   "source": [
    "CA_temp = 1\n",
    "(USA > IT) or (CA_temp > IT)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0aed2e7f",
   "metadata": {},
   "source": [
    "$\\color{blue}{\\text{Complete the following exercise.}}$\n",
    "\n",
    "  - What do you expect would be the result if you were to run `or` between the original statements:\n",
    "     - `(USA > IT)`\n",
    "     - `(CA > IT)` \n",
    " \n",
    "  [Use the cell below to show your code]\n",
    "  \n",
    "  - What is `CA_temp`?\n",
    "  \n",
    "  [Answer here]  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d0f2bd04",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "5d3e2a1b",
   "metadata": {},
   "source": [
    "Another helpful operator, often used in similar questions is `not`. The `not` operator is a modifier that changes the value of the output of other operators suchas `>`, `=`, `and`, etc. \n",
    "\n",
    "For example, if `not` is used, the number of slices of cake eaten by the average citizen in Canada is **not** more than those eaten in the USA:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2e442d2d",
   "metadata": {},
   "outputs": [],
   "source": [
    "not(CA > USA)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d4ce058b",
   "metadata": {},
   "source": [
    "Whereas this is is obeviously `True`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8ca7b2b6",
   "metadata": {},
   "outputs": [],
   "source": [
    "(CA > USA)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0947b390",
   "metadata": {},
   "source": [
    "So, I like to think about `not` as a modifier. It can become useful in many cases, especially when the output of two or more statments needs to be modified (flipped) for the code to advance. For example, the following code shows how three boolean statements (all set to `True`) can be modified but a boolean `not` to save my health."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6fcc8c83",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Save my belly\n",
    "ihaveeatencake = True\n",
    "itislatenight = True\n",
    "ididnotexercisetoday = True\n",
    "\n",
    "INeedToEatCake = not(ihaveeatencake and itislatenight and ididnotexercisetoday)\n",
    "INeedToEatCake"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3bd406b4",
   "metadata": {},
   "source": [
    "$\\color{blue}{\\text{Complete the following exercises.}}$\n",
    "\n",
    "  - Write code containing a `for` look that tests the following operations:\n",
    "     - 2 is bigger than 3\n",
    "     - The square of 2 is smaller than the square of 1\n",
    "     - 4 times 5 is not equal to 20 \n",
    " \n",
    " Return all the results during the for loop using `print()`\n",
    " \n",
    " *Hint: Remember how to measure the length of a list (`len()`). Also remmeber that `range()` is handy to provide lists of numbers to a `for` loop. So if you had two lists of the same length and wanted to compare pairs of values where one value is in the first list and the other value in the second list, you could use something like `range(0, len(list_one))` to create the `i` index in the `for` loop.*\n",
    " \n",
    "  [Use the cell below to show your code]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6d22b002",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "2999724c",
   "metadata": {},
   "source": [
    " - Make a new Python list. You can put whatever you want in it. Make it at least 5 items long."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "545dbce7",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "77d52207",
   "metadata": {},
   "source": [
    " - Get the first element of your new list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cae6c77e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "cf476a55",
   "metadata": {},
   "source": [
    " - Get the last element of your new list in a way that wouldn't depend on list length."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8e8e9b83",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "48189737",
   "metadata": {},
   "source": [
    " - Get all but the last two elements in a way that wouldn't depend on list length."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1e2aeb00",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "c2a25a90",
   "metadata": {},
   "source": [
    " - Get every other element of your list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d9aef5aa",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "50607ad2",
   "metadata": {},
   "source": [
    "$\\color{blue}{\\text{Complete the following exercises.}}$\n",
    "\n",
    " - Use Markdown to make a table and list all the steps necessary to get the new tutorial every class from github, work on it during class and submit the answers to the exercises in the tutorials. Each rown of the table should have a new step. In the first column the table should list the name of the operation, in the second the command used (the full command-line operation executed), in the third where the work is being done (on the cloud, locally on your computer, in a terminal, etc), in the last column there should be a verbal description of what the operation does. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e6453f8",
   "metadata": {},
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}