conditionals.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conditionals"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " \n",
    " A very simple program might just be a sequence of statements:\n",
    "\n",
    "    a = 1\n",
    "    print(a)\n",
    "    a = 2\n",
    "    print(a)\n",
    "    \n",
    "But virtually nothing interesting can be written this way -- because what happens can never change. The program cannot change depending on what button you clicked on screen, what packets have come in over the network, what bytes you have read from a file or upon calculations done in advance.\n",
    "\n",
    "We can use simple diagrams to show how branching affects programs. Consider the sequence of statements above. We can draw that as:\n",
    "<img src=\"statement_graph.merm.png\" width=\"200px\">\n",
    "\n",
    "This is pretty boring, so we can simplify all the statements to just:\n",
    "<img src=\"simple_graph.merm.png\" width=\"200px\">\n",
    "where the arrow is assumed to include a sequence of statements without branches.\n",
    "\n",
    "\n",
    "If we add a **branch** to our program, we now have two possible exits at some block in the code:\n",
    "<img src=\"if_graph.merm.png\" width=\"200px\">\n",
    "\n",
    "Here, **true_path** is only executed if some condition was true at the `if` block. \n",
    "\n",
    "Learning to see the structure of programs as graphs like this is a key part of understanding how programs will run. We'll see several of these graphs in this lecture."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conditionals\n",
    "A conditional is an expression that evaluates to True or False (i.e. a **boolean** expression). `if` takes a conditional to decide which branch of code to execute.\n",
    "\n",
    "The comparison operators are used to test values and the boolean operators combine sub-expressions together.\n",
    "\n",
    "Valid conditional expressions include:\n",
    "\n",
    "    x == 0   [equality]\n",
    "    x > 5    [comparison]\n",
    "    status == \"alive\" or status == \"dead\"    [boolean operator]\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The expression following an if statement must be a conditional. It must evaluate to either `True` or `False`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Block syntax: indentation\n",
    "In Python, we denote the section of code following `if` by **indenting** it (putting spaces in front of the following lines). The `if` continues until the code indentation moves back to where it was before. An indented block always starts with a colon `:`.\n",
    "\n",
    "**All blocks of code in Python are denoted this way. Python is whitespace-sensitive. **\n",
    "\n",
    "There are no block markers like braces `{ }` or `begin` and `end` in Python. The block of code is defined by the colon followed by the indentation (spacing) **alone**. The code that \"belongs\" to a `if` statement is everything which has the matching indentation. \n",
    "\n",
    "All other language features which deal with blocks of code (i.e. need to work with multiple statements) use indentation to mark the blocks of code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after\n"
     ]
    }
   ],
   "source": [
    "# this is fine\n",
    "x = False\n",
    "if x:\n",
    "    print(\"hello\")\n",
    "    print(\"there\")  \n",
    "print(\"after\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndentationError",
     "evalue": "unexpected indent (<ipython-input-2-163600e8d357>, line 5)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-2-163600e8d357>\"\u001b[1;36m, line \u001b[1;32m5\u001b[0m\n\u001b[1;33m    print (\"there\")\u001b[0m\n\u001b[1;37m    ^\u001b[0m\n\u001b[1;31mIndentationError\u001b[0m\u001b[1;31m:\u001b[0m unexpected indent\n"
     ]
    }
   ],
   "source": [
    "# this is an indentation error -- it will not run!\n",
    "x = True\n",
    "if x:\n",
    "    print (\"hello\")      \n",
    "      print (\"there\")\n",
    "#   ^\n",
    "#   | does not match any possible indentation!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndentationError",
     "evalue": "expected an indented block (<ipython-input-3-bd9736164df8>, line 4)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-3-bd9736164df8>\"\u001b[1;36m, line \u001b[1;32m4\u001b[0m\n\u001b[1;33m    print (\"hello\")\u001b[0m\n\u001b[1;37m        ^\u001b[0m\n\u001b[1;31mIndentationError\u001b[0m\u001b[1;31m:\u001b[0m expected an indented block\n"
     ]
    }
   ],
   "source": [
    "# this is also an indentation error -- it will not run!\n",
    "x = True\n",
    "if x:\n",
    "print (\"hello\")      \n",
    "print (\"there\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## if\n",
    "How do we introduce such branches in our programs. The simplest branching statement is `if`. \n",
    "\n",
    "`if` takes an expression and executes one sequence of code only if the given expression is `True`.\n",
    "\n",
    "    if <condition>:\n",
    "        <true_block>\n",
    "        ...\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## else\n",
    "We can have a branch with two different paths using `else`. One of the two paths is always executed; the `if` path if the expression is True or the `else` path if it is False.\n",
    "\n",
    "\n",
    "    if <condition>:\n",
    "        <true_block>\n",
    "    else:\n",
    "        <false_block>\n",
    "\n",
    "<img src=\"if_else_graph.merm.png\" width=\"300px\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You failed the exams\n"
     ]
    }
   ],
   "source": [
    "#If the if condition is true, the if statement is executed. \n",
    "#The program then continues after the else statement.\n",
    "\n",
    "exam = 28\n",
    "\n",
    "if exam < 40:\n",
    "    print(\"You failed\", end = \" \")\n",
    "else:\n",
    "    print(\"You passed\", end = \" \")\n",
    "print(\"the exams\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## if....elif....else\n",
    "Sometimes we need to have more than two branches. For example, we might have a temperature scale in a recipe in Celsius, and we need to work out what Gas Mark to put our oven at: We can use `elif` to combine an `else` and an `if` together. We can still use a final `else` statement."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"if_elif_graph.merm.png\" width=\"400px\">\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "temp = 150\n",
    "if temp<135:\n",
    "    gas_mark=1\n",
    "elif temp<149:\n",
    "    gas_mark =2 \n",
    "elif temp<163:\n",
    "    gas_mark = 3\n",
    "else:\n",
    "    # if it's hotter than that, just turn the burner on full blast!\n",
    "    gas_mark = 100\n",
    "    \n",
    "print(gas_mark)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5. Compound Boolean Expressions\n",
    "The can have more than one condition on an if statement. The conditions need to be joined together with `and` , `or` or `not` operators to create a large boolean expression.\n",
    "\n",
    "\n",
    "                `and`  All the conditions need to be true for the expression to be true.\n",
    "                `or`   Any of the conditions need to be true for the expression to be true.        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I'm not going outside today\n"
     ]
    }
   ],
   "source": [
    "#Both conditions of the or expression are true.\n",
    "\n",
    "weather = \"wet\"\n",
    "temp = 24\n",
    "\n",
    "if weather == \"wet\" or temp < 0:\n",
    "    print(\"I'm not going outside today\")\n",
    "elif weather == \"sunny\" and temp > 20:\n",
    "    print(\"I'm going to need suncream today\")\n",
    "else:\n",
    "    print(\"Not sure what I'll do today\")"
   ]
  }
 ],
 "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.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}