08_boolean_logic.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "source": [
    "## Boolean Logic\n",
    "\n",
    "We've now learned how to manipulate numbers, strings, and lists in Python. We will now learn how to manipulate a new type of Python entity: **boolean values**. The term **boolean values** is a long and complicated way of saying \"true or false.\" In Python, the boolean values `True` and `False` (no quotes, otherwise they would be strings!) can be stored in variables just like any other values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "this_is_true = True\n",
    "this_is_false = False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "source": [
    "What is special about boolean values? Boolean values allow our programs to *make decisions*. Using boolean values in combination with an **if statement**, we can make our code take one action if a value is `True`, and another if it is `False`. Consider the example code below, which decides whether or not to give a customer a discount:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "congratulations - you get a discount!\n"
     ]
    }
   ],
   "source": [
    "customer_should_get_discount = True\n",
    "if customer_should_get_discount:\n",
    "    print(\"congratulations - you get a discount!\")\n",
    "else:\n",
    "    print(\"no discount for you!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "source": [
    "Let's break down the lines above. The if statement consists of:\n",
    "\n",
    "\n",
    "1. The keyword `if`\n",
    "2. A *condition*, which must be a boolean value: `customer_should_get_discount`\n",
    "3. A colon: `:`\n",
    "4. One-or-more indented lines, which execute if the boolean value in step (2) is `True`\n",
    "5. An optional `else` keyword, followed by another colon `:`\n",
    "6. An optional series of one-or-more indented lines, which execute if the boolean value in step (2) is `False`\n",
    "\n",
    "You can see how the above code *makes decisions* by changing the value of `customer_should_get_discount` from `True` to `False` and re-running the cell. If the value is `False`, our code will run the second print statement."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "source": [
    "But what if we don't know whether to put `True` or `False` in our `customer_should_get_discount` variable? What if a particular customer should get a discount only if their total purchases exceed $10,000? We can write additional code to generate the appropriate boolean values using a **comparison operator**: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "customer_purchases_usd = 40000\n",
    "discount_threshold = 10000\n",
    "customer_purchases_usd > discount_threshold"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "source": [
    "We can see that the comparison operator `>` (the \"greater than\" operator) has generated the boolean value `True` by comparing our two values. It returns `True` because the left-side value is greater than the right-side value - otherwise, it would return `False`, as in the following example: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1000 > 2000"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "source": [
    "We can use the boolean values returned by such comparison operators directly in our code as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "congratulations - you get a discount!\n"
     ]
    }
   ],
   "source": [
    "if customer_purchases_usd > discount_threshold:\n",
    "    print(\"congratulations - you get a discount!\")\n",
    "else:\n",
    "    print(\"no discount for you!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "source": [
    "There are several other comparison operators. The `<` (\"less than\") operator is the reverse of the `>` operator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(5 < 3)\n",
    "print(5 < 6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "source": [
    "The equality operator `==` (notice: this is different than the assignment operator, `=`!) returns `True` if both operands are equal - otherwise, it returns `False`. Think of it as being the same as the statement \"A is equal to B\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(5 == 5)\n",
    "print(5 == 6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "source": [
    "The \"or-equal-to\" variants `<=` and `>=` work similarly to `<` and `>`, respectively, except that they also return `True` if both operands are equal:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(5 <= 6)\n",
    "print(5 <= 5)\n",
    "print(3 >= 2)\n",
    "print(3 >= 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "source": [
    "The equality operator also works on other types of objects, like strings:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(\"foo\" == \"foo\")\n",
    "print(\"bar\" == \"bar\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "source": [
    "### More Complex `if` Statements\n",
    "\n",
    "We can use the `elif` string, which stands for \"else if,\" to chain together as many different `if` statements as we wish, as shown below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "i do not recognize that name\n"
     ]
    }
   ],
   "source": [
    "name = \"joe\"\n",
    "if name == \"jim\":\n",
    "    print(\"i recognize jim\")\n",
    "elif name == \"samantha\":\n",
    "    print(\"i recognize samantha\")\n",
    "else:\n",
    "    print(\"i do not recognize that name\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "source": [
    "Experiment with editing the cell above and changing the value of the variable `name`; you can see that if we change it to `\"jim\"`, the first boolean expression will evaluate to `True`, and that branch of the `if` statement will execute. Similarly, if we change the value of `name` to `\"samantha\"`, the boolean expression in the first statement will evaluate to `False`, but the expression in the `elif` statement will evaluate to `True`, so that branch will execute."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "source": [
    "We can use such complex `if` statements to make our functions smarter; instead of always returning a single value from our `return` statements, we can return multiple different values depending on the circumstances. The following function, which implements the classic \"buy high, sell low\" strategy of stock market investing, illustrates how this is done:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def stock_market_decisions(stock_index_value):\n",
    "    if stock_index_value <= 20000:\n",
    "        return \"panic - sell sell sell\"\n",
    "    elif stock_index_value >= 30000:\n",
    "        return \"stocks going to the moon - buy buy buy buy\"\n",
    "    else:\n",
    "        return \"not interesting - buy bitcoins instead\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "source": [
    "We can see that this function now *makes a decision* about what we should do:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "panic - sell sell sell\n",
      "stocks going to the moon - buy buy buy buy\n",
      "not interesting - buy bitcoins instead\n"
     ]
    }
   ],
   "source": [
    "print(stock_market_decisions(15000))\n",
    "print(stock_market_decisions(32000))\n",
    "print(stock_market_decisions(22000))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "source": [
    "<span style=\"color:blue;font-weight:bold\">Exercise</span>: Write a function called `get_loyalty_program` that receives a single argument called `customer_spending_usd`. If the customer spent more than \\$50,000, your function should return `\"platinum\"`. If the customer spent more than \\$20,000, your function should return `\"gold\"`. Otherwise, your function should return `\"no status\"`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "tags": [
     "exercise"
    ]
   },
   "outputs": [],
   "source": [
    "def get_loyalty_program(customer_spending_usd): \n",
    "    if customer_spending_usd > 50000:\n",
    "        return \"platinum\" \n",
    "    elif customer_spending_usd > 20000:\n",
    "        return \"gold\"\n",
    "    else:\n",
    "        return \"no status\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "deletable": false,
    "editable": false,
    "strategicml": {
     "execution_time": 1584758876239,
     "exercise_id": "b280144a-de10-433e-94db-1f2c48ca24a7",
     "points": 2
    },
    "tags": [
     "test"
    ]
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div style=\"background-color:#e8fcef\n",
       ";color:#333333;padding:10px;border-style:solid;border-width:2px;border-color:#038c33\">\n",
       "<div style=\"font-weight:bold\">Correct!</div>\n",
       "</div>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "check_function_definition(\"get_loyalty_program\")\n",
    "assert get_loyalty_program(70000) == \"platinum\"\n",
    "assert get_loyalty_program(45000) == \"gold\"\n",
    "assert get_loyalty_program(0) == \"no status\"\n",
    "success()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "source": [
    "### Combining Expressions with `and`/`or`\n",
    "\n",
    "We may wish to check whether the combination of two statements is `True`, or if either individually is `True`. We can do this with the `and`/`or` boolean operators, which are illustrated in the cells below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 > 3 and 3 > 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 > 3 and 3 > 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 > 3 or 3 > 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3 < 1 or 9 >= 9"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "source": [
    "As you can see above, an `or` statement will be `True` if any statement on either side is `True`, while an `and` statement will only be `True` if the statments on both sides are `True`. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "source": [
    "### Negating Boolean Values\n",
    "\n",
    "We can obtain the opposite of a boolean value by using the `not` operator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "not True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "source": [
    "This can be applied to any boolean expression, no matter how complex. For example, we can combine `not` with a comparison operator as shown in the cell below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "five is not less than three\n"
     ]
    }
   ],
   "source": [
    "if not 5 < 3:\n",
    "    print(\"five is not less than three\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "source": [
    "<span style=\"color:blue;font-weight:bold\">Exercise</span>: Write a function called `should_get_hired` that accepts two arguments: `interview_one_score` and `interview_two_score` and returns the following values:\n",
    "\n",
    "1. If both `interview_one_score` and `interview_two_score` are greater than four, return `\"hire\"` \n",
    "2. If either `interview_one_score` or `interview_two_score` (but not both) are greater than four, return `\"interview again\"`\n",
    "3. Otherwise, return `\"nope\"`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "tags": [
     "exercise"
    ]
   },
   "outputs": [],
   "source": [
    "def should_get_hired(interview_one_score, interview_two_score):\n",
    "    if interview_one_score > 4 and interview_two_score > 4:\n",
    "        return \"hire\"\n",
    "    elif interview_one_score > 4 or interview_two_score > 4:\n",
    "        return \"interview again\"\n",
    "    else:\n",
    "        return \"nope\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "deletable": false,
    "editable": false,
    "strategicml": {
     "execution_time": 1584758959253,
     "exercise_id": "6faad11f-1191-4c62-a2e9-1e496c494e79",
     "points": 2
    },
    "tags": [
     "test"
    ]
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div style=\"background-color:#e8fcef\n",
       ";color:#333333;padding:10px;border-style:solid;border-width:2px;border-color:#038c33\">\n",
       "<div style=\"font-weight:bold\">Correct!</div>\n",
       "</div>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "check_function_definition(\"should_get_hired\")\n",
    "assert should_get_hired(5,5) == \"hire\"\n",
    "assert should_get_hired(3,5) == \"interview again\"\n",
    "assert should_get_hired(5,3) == \"interview again\"\n",
    "assert should_get_hired(2,2) == \"nope\"\n",
    "success()"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": null,
  "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.3"
  },
  "strategicml": {
   "lesson_id": "e98f7ae8-7ae3-4720-bd4f-2335e1417fcc",
   "release": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}