Chapter 3 - Conditions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Chapter 3 - Conditions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## If Statements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Conditions are something everyone is familiar with, for example, if you ask your friend to borrow their pencil.\n",
    "The condition being *if* your friend **agrees** to you borrowing their pencil. We could represent this in code by the following:\n",
    "\n",
    "```python\n",
    "if ask(friend):\n",
    "    take_pencil()\n",
    "```\n",
    "\n",
    "The code tells us that if asking friend returns True, then take the pencil. Now we can **chain** on more conditions in case your friend says no,\n",
    "\n",
    "``` python\n",
    "# ... continued from previous\n",
    "elif ask(friend):\n",
    "    take_pencil()\n",
    "```\n",
    "\n",
    "Now you can see that we ask our friend again if the first time it fails. The elif (else if) indicates this. Again, if our friend agrees, we go into the indented block and take the pencil. If they still do not agree, the indented block is skipped. Finally, we will write a statement for when the friend still does not agree\n",
    "\n",
    "``` python\n",
    "# ... continued\n",
    "else:\n",
    "    find_pencil(your_desk)\n",
    "```\n",
    "\n",
    "Here, if all else is False (or fails), we try to find our own pencil from our own desk. This will activate only when all conditions fail. If one of the if is true, this block will not be activated because when an if statement is true, we go into the if block and break out of the entire if chain afterwards. \n",
    "\n",
    "Here is the whole if chain together in one code block:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ask(friend):\n",
    "    print(f\"Asked {friend} and he said no\")\n",
    "    return False\n",
    "\n",
    "def take_pencil():\n",
    "    print(\"Took pencil\")\n",
    "    \n",
    "def find_pencil(desk):\n",
    "    print(\"Found pencil in your desk\")\n",
    "\n",
    "friend = \"Timmy\"\n",
    "your_desk = \"your desk\"\n",
    "\n",
    "if ask(friend):\n",
    "    take_pencil()\n",
    "elif ask(friend):\n",
    "    take_pencil()\n",
    "else:\n",
    "    find_pencil(your_desk)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comparing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Something that will be essential to programming is comparing things. For example, testing to see if the user responds with a yes or no, example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# question\n",
    "print(\"do you like dogs?\")\n",
    "\n",
    "# input\n",
    "user_input = input(\"yes/no: \")\n",
    "\n",
    "# checks to see what the user inputted\n",
    "if user_input == \"yes\":\n",
    "    print(\"you like dogs!\")\n",
    "elif user_input == \"no\":\n",
    "    print(\"you don't like dogs?\")\n",
    "else:\n",
    "    print(\"your response was not a yes or a no (case sensitive)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here you can see that you get the user input and you compare it with yes or no with the \" **==** \" (equivalent) operator. This operator checks to see if the two sides match including the type if the sides. There are also many other comparison operators listed below\n",
    "\n",
    "* != - not equal\n",
    "* \\> - greater than\n",
    "* \\< - less than\n",
    "* \\>= - greater than or equal to\n",
    "* \\<= - less than or equal to\n",
    "\n",
    "In addition, there are logical operators that take two boolean values and outputs another boolean based on a truth table (see below)\n",
    "\n",
    "* A and B\n",
    "\n",
    "|      |      | A    | A    |\n",
    "| ---- | ---- | ---- | ---- |\n",
    "|      |      | T    | F    |\n",
    "| B    | T    | T    | F    |\n",
    "| B    | F    | F    | F    |\n",
    "\n",
    "* A or B\n",
    "\n",
    "|      |      | A    | A    |\n",
    "| ---- | ---- | ---- | ---- |\n",
    "|      |      | T    | F    |\n",
    "| B    | T    | T    | T    |\n",
    "| B    | F    | T    | F    |\n",
    "\n",
    "* not A\n",
    "\n",
    "| A    | A    |\n",
    "| ---- | ---- |\n",
    "| T    | F    |\n",
    "| F    | T    |\n",
    "\n",
    "With all of these comparison operators, we can link them up and order of operations still applies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dog = False\n",
    "cat = True\n",
    "fish = True\n",
    "\n",
    "if (dog and fish) or (cat and dog) or (cat and fish): \n",
    "    print(\"You have more than or equal two 2 pets\")\n",
    "else:\n",
    "    print(\"You have less than two pets\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Extra"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comparisons can be tricky because things have to be exactly the same. This may be annoying as strings need are case sensitive. There are many functions already in Python that can help make this easier. Here are some examples:\n",
    "\n",
    "* lower() - lower cases all the characters in a string\n",
    "* upper() - upper cases all the characters in a string\n",
    "\n",
    "More can be found in the link [here](https://www.w3schools.com/python/python_ref_string.asp)\n",
    "\n",
    "In addition, strings can have annoying whitespace so something like the following might be needed top remove whitespace"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "string = \"  hello there   \"\n",
    "\n",
    "print(\"Spaces: \")\n",
    "print(string)\n",
    "\n",
    "print(\"\\nNo spaces: \")\n",
    "print(string.strip())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a integer calculator that asks for the two numbers and the operator and responds with the answer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# write your code below\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Chapter 2 Answer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sphere_volume(radius, pi=3.14):\n",
    "    '''\n",
    "    finds sphere volume given the radius and the value of pi\n",
    "    pi defaults to a value of 3.14\n",
    "    '''\n",
    "    \n",
    "    volume = 4/3 * pi * radius ** 3\n",
    "    return volume\n",
    "\n",
    "# input\n",
    "user_input = float(input(\"Radius: \"))\n",
    "\n",
    "# print\n",
    "print(sphere_volume(user_input))"
   ]
  }
 ],
 "metadata": {
  "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.2"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": true,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}