05-Boolean Logics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5. Boolean Logics, operators and conditional statements\n",
    "Booleans represent one of two values `True` or `False`. can be stored in variables just like any other values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "bool_true = True\n",
    "bool_false = False\n",
    "bool_test_true = True #capital case for the boolean value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool_true"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bool"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(bool_true)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python supports the usual logical conditions similar to many other programming languages:\n",
    "\n",
    "Equals to: a == b <br>\n",
    "Not Equals: a != b <br>\n",
    "Less than: a < b <br>\n",
    "Less than or equal to: a <= b <br>\n",
    "Greater than: a > b <br>\n",
    "Greater than or equal to: a >= b\n",
    "\n",
    "Using the combination of `operators`, `boolean` and `If..Else` you can program control structures which are the blocks of codes that analyze variables and choose directions in which to go based on given parameters.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Your ticket is valid please enter\n"
     ]
    }
   ],
   "source": [
    "ticket_validity = True\n",
    "\n",
    "if ticket_validity:\n",
    "    print(\"Your ticket is valid please enter\")\n",
    "else:\n",
    "    print(\"Sorry your ticket is invalid!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " The comparison operator `>` (greater than) can be used to generated the boolean value `True` or `False` "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# This will generate False\n",
    "100 > 200"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# This will generate True\n",
    "200 > 100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Combination of if..else and comparison operator\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No, x might be greater than y\n"
     ]
    }
   ],
   "source": [
    "# Using a comparison operator in if statement:\n",
    "x = 200\n",
    "y = 150\n",
    "if y > x:\n",
    "  print(\"y is greater than x\")\n",
    "else:\n",
    "  print(\"No, x might be greater than y\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The equality operator `==` returns `True` if both operands are equal. Else, it returns `False`. Note: This is different than the assignment operator, `=`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(2 == 2)\n",
    "print(3 == 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The \"or-equal-to\" variants `<=` and `>=` work similarly to `<` and `>`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(2 <= 4)\n",
    "print(5 <= 5)\n",
    "print(7 >= 2)\n",
    "print(7 >= 7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The equality operator also works on strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(\"str\" == \"str\")\n",
    "print(\"bad\" == \"good\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python if...elif...else Statement\n",
    "\n",
    "**elif** in Python, stands for \"else if,\" it can be used to combine as many **if** statements as we wish. **elif** may be used when the previous conditions were not true:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Yes Mohd3\n"
     ]
    }
   ],
   "source": [
    "name = \"Mohd3\"\n",
    "\n",
    "if name == \"John\":\n",
    "    print(\"Yes John\")\n",
    "elif name == \"Samantha\":\n",
    "    print(\"Yes Samantha\")\n",
    "elif name == \"Mohd\":\n",
    "    print(\" Yes Mohd\")\n",
    "elif name == \"Mohd2\":\n",
    "    print(\" Yes Mohd2\")\n",
    "elif name == \"Mohd3\":\n",
    "    print(\" Yes Mohd3\")\n",
    "else:\n",
    "    print(\"The given name not in system\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "not found\n",
      "not found\n",
      "not found\n",
      "its d\n"
     ]
    }
   ],
   "source": [
    "# If else in for loop\n",
    "list1 = ['a','b','c','d']\n",
    "\n",
    "for i in list1:\n",
    "    if i == 'e':\n",
    "        print ('its e')\n",
    "    elif i == 'd':\n",
    "        print ('its d')\n",
    "    else:\n",
    "        print('not found')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Alternative way\n",
    "'d' in list1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The comparison operators with if..elif..else can be used for numerical problems"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x and y are equal\n"
     ]
    }
   ],
   "source": [
    "x = 100\n",
    "y = 100\n",
    "if y > x:\n",
    "  print(\"y is greater than x\")\n",
    "elif x == y:\n",
    "  print(\"x and y are equal\")\n",
    "else:\n",
    "  print(\"x is greater than y\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`if` statements can be used in functions; for example it can be used for conditional `return` statements as follows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# if else in function\n",
    "def get_decisions(price):\n",
    "    if price <= 50000:\n",
    "        return \"Buy the property\"\n",
    "    elif price >= 80000:\n",
    "        return \"Sorry not interested\"\n",
    "    else:\n",
    "        return \"Will think about it\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Buy the property\n",
      "Will think about it\n",
      "Sorry not interested\n"
     ]
    }
   ],
   "source": [
    "print(get_decisions(25000))\n",
    "print(get_decisions(70000))\n",
    "print(get_decisions(100000))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color=\"blue\">Exercise</font>: Write a function called **get_bonus** that receives a single argument called **annual_sales**. If the annual sales more than RM500000, your function should return **\"RM1000 bonus\"**. If the annual sales more than RM200000, your function should return **\"RM500 bonus\"**. Otherwise, your function should return **\"no bonus\"**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "# YOUR CODE HERE\n",
    "def get_bonus(annual_sales):\n",
    "    if annual_sales > 500000:\n",
    "        return \"RM1000 bonus\"\n",
    "    elif annual_sales > 200000:\n",
    "        return \"RM500 bonus\"\n",
    "    else:\n",
    "        return \"no bonus\"\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'RM500 bonus'"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "get_bonus(300000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example of if and else on a single line"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Three more than zero\n"
     ]
    }
   ],
   "source": [
    "if 3>0: print(\"Three more than zero\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Three more than zero\n"
     ]
    }
   ],
   "source": [
    "print(\"Three more than zero\") if 3>0 else print(\"No\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "fruit = 'Apple'\n",
    "isApple = True if fruit == 'Apple' else False\n",
    "print(isApple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Change these statements on a single line\n",
    "if 3>10: print(\"Three more than ten\")\n",
    "else:print(\"Three less than ten\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color=\"blue\">Exercise</font>: Change the if-else statements above to a single line statement:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# YOUR CODE HERE\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### logical  `and`/`or` operators\n",
    "\n",
    "Suppose if we need to check whether the combination of two statements is `True`, or if either individually is `True`. It can be done with the `and` or `or` operators, as illustrated below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "6 > 2 and 5 > 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "6 > 2 and 2 > 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "6 > 2 or 2 > 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5 < 1 or 10 >= 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### logical not operator - Negating Boolean Values\n",
    "\n",
    "Obtain the opposite of a boolean value using `not` operator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "not False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if not 2 > 10:\n",
    "    print(\"two is not more than ten\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color=\"blue\">Exercise</font>: Define a function called `offer_new_product` that accepts two arguments: `monthly_spending` and `monthly_income` and returns the following values:\n",
    "\n",
    "1. If both `monthly_spending` more than 1000 and `monthly_income` more than 3000, return `\"Send new product proposal\"` \n",
    "2. If either `monthly_spending` more than 1000 or `monthly_income` more than 3000, return `\"Monitor another month\"`\n",
    "3. Otherwise, return `\"KIV\"`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "# YOUR CODE HERE\n",
    "def offer_new_product(monthly_spending, monthly_income):\n",
    "    if monthly_spending > 1000 and monthly_income > 3000:\n",
    "        return \"Send new product proposal\"\n",
    "    elif monthly_spending > 1000 or monthly_income > 3000:\n",
    "        return \"Monitor another month\"\n",
    "    else:\n",
    "        return \"KIV\"\n",
    "        \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Monitor another month'"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "offer_new_product(500,3500)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color=\"blue\">Exercise</font>: Write tax calculator.\n",
    "\n",
    "1. Write a function **calculate_tax** to calculate the tax using the following brackets:\n",
    "\n",
    "        a. If the citizen's income was not higher than usd9800, the tax was equal to 10% of the income.\n",
    "\n",
    "        b. If the citizen's income was between usd9800 until usd85000, the tax was equal to 22% of the income.\n",
    "\n",
    "        c. If the citizen's income was higher than usd85000, then the tax was equal to 32% of the income.\n",
    "\n",
    "2. Accept user input assign it to the variable **income** after casting it to floating-point value.\n",
    "3. Call the **calculate_tax** function, use income as argument.\n",
    "4. print the return tax  rounding it to 2 decimal using the round() function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# YOUR CODE HERE\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "calculate_tax(10000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Example of rounding using round\n",
    "round(200.206,2)"
   ]
  }
 ],
 "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.10.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}