notebooks/015_Python_control.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img alt='UCL' src=\"images/ucl_logo.png\" align='center'>\n",
    "\n",
    "\n",
    "[<img src=\"images/noun_post_2109127.svg\" width=\"50\" align='right'>](016_Python_for.ipynb)\n",
    "[<img src=\"images/noun_pre_2109128.svg\" width=\"50\" align='right'>](014_Python_groups.ipynb)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 015 Control in Python: `if`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction\n",
    "\n",
    "### Purpose\n",
    "\n",
    "In this section we will learn how to add conditional control to our codes. We will cover the conditional statement: `if`.\n",
    "\n",
    "### Prerequisites\n",
    "\n",
    "You will need some understanding of the following:\n",
    "\n",
    "\n",
    "* [001 Using Notebooks](001_Notebook_use.ipynb)\n",
    "* [003 Getting help](003_Help.ipynb)\n",
    "* [010 Variables, comments and print()](010_Python_Introduction.ipynb)\n",
    "* [011 Data types](011_Python_data_types.ipynb) \n",
    "* [012 String formatting](012_Python_strings.ipynb)\n",
    "* [013_Python_string_methods](013_Python_string_methods.ipynb)\n",
    "* [014_Python_groups](014_Python_groups.ipynb)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comparison Operators and `if`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comparison Operators\n",
    "\n",
    "A comparison operator 'compares' two terms (e.g. the contents of variables) and returns a boolean data type (`True` or `False`).\n",
    "\n",
    "For example, to see if the value of some variable `a` has 'the same value as' ('equivalent to') the value of some variable `b`, we use the equivalence operator (`==`). To test for non equivalence, we use the not equivalent operator `!=` (read the `!` as 'not'):\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is 100 and b is 10\n",
      "a is equivalent to b? False\n"
     ]
    }
   ],
   "source": [
    "a = 100\n",
    "b = 10\n",
    "#\n",
    "# These are *not* the same, so we expect \n",
    "# a == b : False\n",
    "\n",
    "# Note the use of \\n and \\t in here\n",
    "# from 010 for formatting\n",
    "print (f'a is {a} and b is {b}')\n",
    "print (f'a is equivalent to b? {a == b}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution2": "hidden",
    "solution2_first": true
   },
   "source": [
    "#### Exercise 1\n",
    " \n",
    "* insert a new cell below here. Use f-strings in forming strings.\n",
    "* copy the code above \n",
    "* add a `print` statement to your code that tests for non equivalence of `a` and `b`\n",
    "* repeat this in a new cell, but now change the values (or type) of the variables `a` and `b` to `float` or `bool`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "solution2": "hidden"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is 100 and b is 10\n",
      "a is equivalent to b? False\n",
      "a is not equivalent to b? True\n"
     ]
    }
   ],
   "source": [
    "# ANSWER\n",
    "\n",
    "# copy the code above \n",
    "a = 100\n",
    "b = 10\n",
    "#\n",
    "# These are *not* the same, so we expect \n",
    "# a == b : False\n",
    "\n",
    "# Note the use of \\n and \\t in here\n",
    "# from 010 for formatting\n",
    "print (f'a is {a} and b is {b}')\n",
    "print (f'a is equivalent to b? {a == b}')\n",
    "\n",
    "# add a print statement to your code that tests \n",
    "# for non equivalence of a and b\n",
    "print (f'a is not equivalent to b? {a != b}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "solution2": "hidden"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is 100.0 and b is 10.0\n",
      "a is equivalent to b? False\n",
      "a is not equivalent to b? True\n"
     ]
    }
   ],
   "source": [
    "# ANSWER\n",
    "\n",
    "# repeat this in a new cell, but now change the values \n",
    "# (or type) of the variables `a` and `b` to `float` or `bool`\n",
    "# FLOAT\n",
    "\n",
    "# copy the code above \n",
    "a = 100.0\n",
    "b = 10.0\n",
    "#\n",
    "# These are *not* the same, so we expect \n",
    "# a == b : False\n",
    "\n",
    "# Note the use of \\n and \\t in here\n",
    "# from 010 for formatting\n",
    "print (f'a is {a} and b is {b}')\n",
    "print (f'a is equivalent to b? {a == b}')\n",
    "\n",
    "# add a print statement to your code that tests \n",
    "# for non equivalence of a and b\n",
    "print (f'a is not equivalent to b? {a != b}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "solution2": "hidden"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is True and b is True\n",
      "a is equivalent to b? True\n",
      "a is not equivalent to b? False\n"
     ]
    }
   ],
   "source": [
    "# ANSWER\n",
    "\n",
    "# repeat this in a new cell, but now change the values \n",
    "# (or type) of the variables `a` and `b` to `float` or `bool`\n",
    "# BOOL\n",
    "\n",
    "# copy the code above \n",
    "a = True\n",
    "b = True\n",
    "#\n",
    "# These are *not* the same, so we expect \n",
    "# a == b : False\n",
    "\n",
    "# Note the use of \\n and \\t in here\n",
    "# from 010 for formatting\n",
    "print (f'a is {a} and b is {b}')\n",
    "print (f'a is equivalent to b? {a == b}')\n",
    "\n",
    "# add a print statement to your code that tests \n",
    "# for non equivalence of a and b\n",
    "print (f'a is not equivalent to b? {a != b}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A fuller set of comparison operators allows greater or less than tests:\n",
    "\n",
    "|symbol| meaning|\n",
    "|:---:|:---:|\n",
    "| == | is equivalent to |\n",
    "| != | is not equivalent to |\n",
    "| > | greater than |\n",
    "|>= | greater than or equal to|\n",
    "|<  | less than|\n",
    "|<=  | less than or equal to    |\n",
    "\n",
    "so that, for example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 + 1 == 2    : True\n",
      "1 <= 0.999    : False\n",
      "1 + 1 != 2    : False\n",
      "100 < 2       : False\n"
     ]
    }
   ],
   "source": [
    "# Comparison examples\n",
    "\n",
    "# is one plus one list equal to two list?\n",
    "print (f'1 + 1 == 2    : {1 + 1 == 2}')\n",
    "\n",
    "# is one less than or equal to 0.999?\n",
    "print (f'1 <= 0.999    : {1 <= 0.999}')\n",
    "\n",
    "# is one plus one not equal to two?\n",
    "print (f'1 + 1 != 2    : {1 + 1 != 2}')\n",
    "\n",
    "# \"is 100 less than 2?\"\n",
    "print (f'100 < 2       : {100 < 2}')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution2": "hidden",
    "solution2_first": true
   },
   "source": [
    "#### Exercise 2\n",
    "\n",
    "* insert a new cell below here\n",
    "* create variables `a` and `b` and set them to types and values of your choice\n",
    "* create a variable called `gt_test` and set it to the result of `a > b`\n",
    "* print a statement of what you have used, and the value of `gt_test`\n",
    "* explain why you get the result you do"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "solution2": "hidden"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a > b test for a = 2 and b = 4 :   False\n",
      "\n",
      "  explain why you get the result you do\n",
      "  \n",
      "  gt_test is False here, because the statement that a > b\n",
      "  is not True since a is 2 and b is 4 \n",
      "\n"
     ]
    }
   ],
   "source": [
    "# ANSWER\n",
    "\n",
    "# create variables a and b and set them to values of your choice\n",
    "# here, we choose int values 2 and 4 respectively\n",
    "a = 2\n",
    "b = 4\n",
    "\n",
    "# create a variable called `gt_test` and set it to the result of `a > b`\n",
    "gt_test = a > b\n",
    "\n",
    "# print the statement you have used, and the value of `gt_test`\n",
    "print(f'a > b test for a = {a} and b = {b} :   {gt_test}')\n",
    "\n",
    "# explain why you get the result you do\n",
    "msg = '''\n",
    "  explain why you get the result you do\n",
    "  \n",
    "  gt_test is False here, because the statement that a > b\n",
    "  is not True since a is 2 and b is 4 \n",
    "'''\n",
    "print(msg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conditional test: `if ... elif ... else ...`\n",
    "\n",
    "A common use of comparisons is for program control, using an `if` statement of the form:\n",
    "\n",
    "    if condition1:\n",
    "        # do this 1\n",
    "        doit1()\n",
    "        ...\n",
    "    elif condition2:\n",
    "        # do this 2\n",
    "        doit2()\n",
    "        ...\n",
    "    else:\n",
    "        # do this 3\n",
    "        doit3()\n",
    "        ...\n",
    "        \n",
    "\n",
    "Implicit in these statements is that the conditions return `True` to pass the tests, i.e. we could more fully write:\n",
    "\n",
    "    if condition1 == True:\n",
    "        # do this 1\n",
    "        ...\n",
    "\n",
    "This form of conditional statement allows us to run blocks of code *only under a particular condition* (or set of conditions).\n",
    "\n",
    "In Python, the statement(s) we run on condition are *indented*. \n",
    "\n",
    "The indent can be one or more spaces or a `<tab>` character, the choice is up to the programmer. However, it **must be consistent**. It is generally best to use spaces rather than tab characters, it is all too easy to mistake one for the other.\n",
    "\n",
    "<span class=\"burk\">Pay attention to indentation in conditional statements. Getting it wrong is one of the more common errors new Python coders make.</span> "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "test result is 3\n",
      "passed test 1: \"if test >= 1\"\n",
      "retval is True\n"
     ]
    }
   ],
   "source": [
    "test = 3\n",
    "print('test result is',test)\n",
    "\n",
    "# initialise retval\n",
    "retval = None\n",
    "\n",
    "# conduct some tests, and set the \n",
    "# variable retval to True if we pass\n",
    "# any test\n",
    "\n",
    "if test >= 1:\n",
    "    retval = True\n",
    "    print('passed test 1: \"if test >= 1\"')\n",
    "elif test == 0:\n",
    "    retval = True\n",
    "    print('passed test 2: \"if test == 0\"')\n",
    "else:\n",
    "    retval = False\n",
    "    print('failed both tests')\n",
    "    \n",
    "print('retval is',retval)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "solution2": "hidden",
    "solution2_first": true
   },
   "source": [
    "#### Exercise 3\n",
    "\n",
    "* insert a new cell below here\n",
    "* set a variable `doy` to represent the day of year and initialise it to some integer between 1 and 365 inclusive\n",
    "* set a variable `month` to be `'January'`\n",
    "* set a variable `year` to be `'2020'`\n",
    "* Write a series of conditional statements that set the variable `month` to the correct month for the value of `doy`\n",
    "* Print the month for the given doy\n",
    "* Test that you get the right result for several `doy` values\n",
    "\n",
    "You should assume that `doy` value `1` represents January 1st.\n",
    "\n",
    "You might find a [DOY calendar](https://www.esrl.noaa.gov/gmd/grad/neubrew/Calendar.jsp) helpful here.\n",
    "\n",
    "![DOY calendar](images/doycal.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "solution2": "hidden"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "for doy 230 year 2020 the month is August\n"
     ]
    }
   ],
   "source": [
    "# ANSWER\n",
    "# set a variable doy to represent the day of year and \n",
    "# initialise it to some integer between 1 and 365 inclusive\n",
    "doy = 230\n",
    "\n",
    "# set a variable month to be 'January'\n",
    "month = 'January'\n",
    "\n",
    "# set a variable year to be '2020'\n",
    "year = '2020'\n",
    "\n",
    "# Write a series of conditional statements that set the \n",
    "# variable month to the correct month for the value of doy\n",
    "if ( doy < 1 ) or (doy > 366):\n",
    "    # good to catch errors\n",
    "    month = f'out of bounds error: doy={doy}'\n",
    "elif ( doy <= 31 ):\n",
    "    month = 'January'\n",
    "elif ( doy <= 60 ):\n",
    "    month = 'February'\n",
    "elif ( doy <= 91 ):\n",
    "    month = 'March'\n",
    "elif ( doy <= 121 ):\n",
    "    month = 'April'\n",
    "elif ( doy <= 152 ):\n",
    "    month = 'May'\n",
    "elif ( doy <= 182 ):\n",
    "    month = 'June'\n",
    "elif ( doy <= 213 ):\n",
    "    month = 'July'\n",
    "elif ( doy <= 244 ):\n",
    "    month = 'August'\n",
    "elif ( doy <= 274 ):\n",
    "    month = 'September'\n",
    "elif ( doy <= 305 ):\n",
    "    month = 'October'\n",
    "elif ( doy <= 335 ):\n",
    "    month = 'November'\n",
    "else:\n",
    "    # it must be December !\n",
    "    month = 'December'\n",
    "\n",
    "# Print the month for the given doy\n",
    "print(f'for doy {doy} year {year} the month is {month}')\n",
    "\n",
    "# Test that you get the right result for several doy values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will see later that this is not the best way to do calculations of this sort. First, it is all too easy to make mistakes in typing in both the `doy` boundaries and the month names. Second, it is not very flexible: for instance, consider how would you need to change it for leap or non-leap years. Third, it is not at all [pythonic](https://stackoverflow.com/questions/25011078/what-does-pythonic-mean#:~:text=Pythonic%20means%20code%20that%20doesn,is%20intended%20to%20be%20used.), i.e. doesn't make use of the features of Python that could make it clear and concise.\n",
    "\n",
    "That said, it is an easily-understandable exercise to try out using conditional statements."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Summary\n",
    "\n",
    "We should know know how to use `if` statements in Python to control program flow. We can make choices as to what happens in the code, depending on whether or not one or more tests are passed. This is a common feature of all coding languages, but it is important here that you get used to doing this in Python.\n",
    "\n",
    "We know that conditions inside `if` statements use indentation in Python, and we know to be careful in our use of this.\n",
    "\n",
    "There are additional notes in [docs.python.org](https://docs.python.org/3/tutorial/controlflow.html#the-range-function) you can follow up to deepen your understanding of these topics. \n",
    "\n",
    "Summary of material in this notebook:\n",
    "\n",
    "Comparison operators:\n",
    "\n",
    "|symbol| meaning|\n",
    "|:---:|:---:|\n",
    "| == | is equivalent to |\n",
    "| != | is not equivalent to |\n",
    "| > | greater than |\n",
    "|>= | greater than or equal to|\n",
    "|<  | less than|\n",
    "|<=  | less than or equal to    |\n",
    "\n",
    "\n",
    "`If ... elif ... else`:\n",
    "\n",
    "\n",
    "        if condition1:\n",
    "            # do this 1\n",
    "            doit1()\n",
    "            ...\n",
    "        elif condition2:\n",
    "            # do this 2\n",
    "            doit2()\n",
    "            ...\n",
    "        else:\n",
    "            # do this 3\n",
    "            doit3()\n",
    "            ...\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "[<img src=\"images/noun_post_2109127.svg\" width=\"50\" align='right'>](016_Python_for.ipynb)\n",
    "[<img src=\"images/noun_pre_2109128.svg\" width=\"50\" align='right'>](014_Python_groups.ipynb)\n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "conda env:geog0111-geog0111",
   "language": "python",
   "name": "conda-env-geog0111-geog0111-py"
  },
  "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.13"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": 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
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": false,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "207px"
   },
   "toc_section_display": false,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}