Program Control Statements.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: center;\"> <img src=https://www.dropbox.com/s/lqbw58ewkd6k9ha/pythonfundamentals1-1.jpg?raw=1 width=800/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "toc-hr-collapsed": true
   },
   "source": [
    "\n",
    "# **Program control**\n",
    "\n",
    "## **Introduction**\n",
    "Solving any computational problem requires executing a set of actions in a particular order. An algorithm is a list of instructions used in performing tasks. A cooking recipe found in any [Cookbook](https://www.amazon.com/s?k=cookbook&ref=nb_sb_noss_2) is the most common example of an algorithm. Any recipe has a list of instructions (actions) and order of these actions. Algorithms used for computational purposes are not much different. In the context of programming, an *algorithm*  is a set of procedures used for solving a problem. Any algorithm contains:\n",
    "\n",
    "  1. the **actions** to be executed\n",
    "  2. the **order** in which these actions be executed\n",
    "    \n",
    "A Python program is a list of **actions** performed by the computer in a particular **order**. Python uses three different forms of *program control* for specifying the order of instructions: sequential execution, selection statement, and repetition statement. Most programs use combination of these program controls. \n",
    "<br>\n",
    "<hr style=\"border: 0.3px solid gray; background-color:black; width:40%;\"></hr>\n",
    "\n",
    "## **Sequential execution**\n",
    "\n",
    "\n",
    "\n",
    "In sequential execution, as the name suggests, statements are performed in the order they're written. Here is an example\n",
    " >```python\n",
    " > x = 10\n",
    " > y = 20\n",
    " > sum = x + y\n",
    " > average = sum / 2\n",
    " > print(average)\n",
    " >```\n",
    " \n",
    "Python executes these instructions sequentially (one after another one) to find average of two numbers. \n",
    "<br>\n",
    "<hr style=\"border: 0.3px solid gray; background-color:black; width:40%;\"></hr>\n",
    "\n",
    "## **Selection statement**\n",
    "\n",
    "executes code based on a *condition* (an expression that evaluates to either *True* or *False*). Here is an early example\n",
    "> ```python\n",
    ">grade = 75\n",
    ">if grade >=70:\n",
    ">    print (\"pass\")\n",
    ">else:\n",
    ">    print (\"fail\")\n",
    ">```\n",
    "\n",
    "This snippet will **not** performs instructions sequentially. Only one of the 3rd or 5th lines will be executed. If $\\text{grade}\\ge75$ is `True`, Python will skip 4th and 5th lines; and if $\\text{grade} \\ge 75$ is `False`, Python will skip the 3rd line. So the execution order is **not** sequential. \n",
    "\n",
    "Python has three types of selection statements: **`if`** statement, **`if . . . else`** statement, and **`if . . . elif . . . else`** statement.\n",
    "<br>\n",
    "<hr style=\"border: 0.3px dashed gray; background-color:white; width:15%; align: left\"></hr>\n",
    "\n",
    "### `if` statement\n",
    "\n",
    "**`if`** statement performs an action (or a set of actions) if a condition is `True` or skips the action if the condition is `False`. The following snippet accepts a floating point $\\text{grade}$ from the user and prints *Pass* and *Great job* in two separate lines if *grade >= 70*.\n",
    "\n",
    ">```python\n",
    ">grade = float(input('Enter a grade'))\n",
    ">if grade>=70:\n",
    ">    print('Pass')\n",
    ">    print('Great job!')\n",
    ">```\n",
    "\n",
    "**Note 1:** All statements that belong to `if` suite, must be indented and must have the same indentation. Otherwise, you will get <span style=\"color:red\"> IndentationError </span>.\n",
    "\n",
    "**Note 2:** There is a difference between `=` and `==`. The `=`  is the assignment statement. $grade = 92$ will assign (bind) value of 92 to identifier $\\text{grade}$. On the other hand, `==` is used for evaluating a condition. $\\text{grade == 92}$ will evaluate if grade is equal to 92 and will return `True` if grade is indeed 92 and will return `False` if grade is not equal to 92. \n",
    "\n",
    "**Note 3:** The `if` condition could be *any* expression. Any non-zero value is True. Zero is False. Strings containing characters are True and empty strings ('', \"\", \"\"\"\"\"\") are False. \n",
    "<br>\n",
    "<hr style=\"border: 0.3px dashed gray; background-color:white; width:15%;\"></hr>\n",
    "\n",
    "### `if . . . else` Statement\n",
    "\n",
    "`if . . . else` statement performs an action(or a set of actions) if a condition is `True`; otherwise, it performs a different action. The following will show different messages depending on a student's grade received from the user.\n",
    "\n",
    "```python\n",
    "grade = float(input('Enter a grade'))\n",
    "if grade >= 70:\n",
    "    print('Pass')\n",
    "    print('Great job')\n",
    "else:\n",
    "    print('Failed')\n",
    "    print('Try harder next time')\n",
    "```\n",
    "\n",
    "<br>\n",
    "\n",
    "**A concise alternative**: Sometimes suites inside `if` and `else` are very short; in this case, you can put the whole `if . . . else` block in just one line. Here is an example:\n",
    "\n",
    ">```python\n",
    ">grade = float(input('Enter a grade'))\n",
    ">print('Pass') if grade >= 70 else print('fail')\n",
    ">```\n",
    "    \n",
    "This snippet will take a grade from the user and  will print `Pass` if grade >= 70; otherwise, will print `fail`. *Use this concise notation only if the suites inside `if . . . else` are very short*\n",
    "<br>\n",
    "<hr style=\"border: 0.3px dashed gray; background-color:white; width:15%;\"></hr>\n",
    "\n",
    "### `if . . . elif . . .else` Statement\n",
    "\n",
    "`if . . . elif . . . else` statement performs one of many different actions, depending on the truth of falsity of several conditions. The following snippet will accept a `float` input from the user and will print out the corresponding grade.\n",
    "\n",
    ">```python\n",
    ">grade = float(input(\"Hi\"))\n",
    ">if grade >= 90:\n",
    ">    print(\"A\")\n",
    ">elif grade >= 80:\n",
    ">    print(\"B\")\n",
    ">elif grade >= 70:\n",
    ">    print(\"C\")\n",
    ">elif grade >= 60:\n",
    ">    print(\"D\")\n",
    ">else:\n",
    ">    print(\"F\")\n",
    ">```\n",
    "\n",
    "**Note 1:** Only the action for the first `True` condition executes. \n",
    "\n",
    "**Note 2:** keyword `elif` is short for *else if*.\n",
    "\n",
    "**Note 3:** `else` statement in `if . . . elif . . .else` is optional. It allows you to handle situations where none of the conditions in `if` and `elif` are satisfied. If you would like to use `else`, it must be placed after the last `elif` condition. \n",
    "<br>\n",
    "<hr style=\"border: 0.3px solid gray; background-color:black; width:40%;\"></hr>\n",
    "\n",
    "## **Repetition statement**\n",
    "\n",
    "Repetition statements (sometimes called *loops*) are used to repeat the same code multiple times in succession. Python has two types of loops: `while` and `for`\n",
    "- **`while`** statement: repeats an action (or a group of actions) as long as a condition remains `True` (*condition-controlled* loop). Basic syntax for a `while` loop is:\n",
    ">```python \n",
    "> while condition:\n",
    ">    statement(s) # These statement(s) must be indented (relative to the while)\n",
    ">```\n",
    "\n",
    "- **`for`** statement: repeats an action (or a group of actions) for a specific number of times (*count-controlled* loop). Basic syntax for a `for` loop is:\n",
    "> ```python\n",
    "> for variable in [value1, value2, etc.]:\n",
    ">    statement(s) # These statement(s) must be indented (relative to the for)\n",
    ">```\n",
    "<br>\n",
    "<hr style=\"border: 0.3px dashed gray; background-color:white; width:15%;\"></hr>\n",
    "\n",
    "### `while` loop\n",
    "\n",
    "- Used to repeat a block of code as long as a condition is `True`. `while` condition is tested before executing the statements (block).\n",
    "- This is how a `while` loop works:\n",
    "  * Test the condition in front of the `while` statement to decide whether the look must be repeated.\n",
    "    - If the condition is **`True`**, repeat the block again.\n",
    "    - If the condition is **`False`**, quit!\n",
    "\n",
    "> **Example:** The following , very rudimentary, snippet will get two numbers from the user and will print out their sum; then it will ask user if they want to continue calculating sum of another two numbers.\n",
    ">\n",
    ">>```python\n",
    ">>keep_going = \"yes\" # variable to control the loop\n",
    ">>while keep_going == \"yes\": \n",
    ">>    a = float(input(\"enter a valid number\")) # get the first number\n",
    ">>    b = float(input(\"enter another valid number\")) # get the second number\n",
    ">>    sum = a + b # calculate the sum\n",
    ">>    print(\"sum of\", a, \"and\", b, \"is\", sum) # print out the results\n",
    ">>    keep_going = input(\"Do you want to calculate sum of another two numbers?\").lower() # See if the user wants to continue.\n",
    ">>```\n",
    ">\n",
    "> **Note 1**: This is a rudimentary program; make sure to enter correct arguments as the input. \n",
    ">\n",
    "> **Note 2**: The `.lower()` method at the last line converts all uppercase characters in a string into lowercase characters and returns it. This helps continue the loop even when user enters combinations of lower case and upper case letters in the word *yes*. \n",
    "\n",
    "\n",
    "\n",
    "<span style=\"color:red\"> Be aware of *infinite* loops: </span> In all practical applications, the while condition must eventually become `False` inside the `while` loop; otherwise, the loop will continue infinitely; this is called an <span style=\"color:red\"> **infinite loop**. </span>  \n",
    "\n",
    "**Practice Problem:** Write a snippet (using `while` loop) determining the smallest power of 5 that is larger than or equal to 7200. Mathematically, find smallest $5^n$ such that $5^n \\ge 7200$\n",
    "<br>\n",
    "<hr style=\"border: 0.3px dashed gray; background-color:white; width:15%;\"></hr>\n",
    "\n",
    "### `for` loop\n",
    "\n",
    "`for` loop repeats a block of statements for a specific number of times. The `for` statement executes its block of statements for each item in a **sequence** of items. Let's look at a few examples.\n",
    "\n",
    "**Example 1**\n",
    ">>```python\n",
    ">>for item in [\"Good Dog\", \"Bad Cat\"]:\n",
    ">>    print(item)\n",
    ">>```\n",
    ">\n",
    ">outputs\n",
    ">>```python\n",
    ">> Good Dog\n",
    ">> Bad Cat\n",
    ">>```\n",
    "\n",
    "**Example 2**\n",
    ">>```python\n",
    ">>for i in range(2, 7):\n",
    ">>    print(i)\n",
    ">>```\n",
    ">\n",
    ">outputs\n",
    ">>```python\n",
    ">>2 \n",
    ">>3 \n",
    ">>4 \n",
    ">>5 \n",
    ">>6 \n",
    ">>```\n",
    "\n",
    "**Example 3**\n",
    ">>```python\n",
    ">>for item in \"Python 3.8\":\n",
    ">>    print(item)\n",
    ">>```\n",
    ">\n",
    ">outputs\n",
    ">>```python\n",
    ">>P\n",
    ">>y\n",
    ">>t\n",
    ">>h\n",
    ">>o\n",
    ">>n\n",
    ">> \n",
    ">>3\n",
    ">>.\n",
    ">>8\n",
    ">>```\n",
    "\n",
    "**Example 4**\n",
    ">>```python\n",
    ">>for item in \"Python 3.8\":\n",
    ">>    print(item, end = \"   \")\n",
    ">>```\n",
    ">\n",
    ">outputs\n",
    ">>```python\n",
    ">>P   y   t   h   o   n       3   .   8 \n",
    ">>```\n",
    "<br>\n",
    "\n",
    "**Note 1:** In **Example 2** `range(2, 7)` is a sequence of numbers starting from 2 through and up till, but not including 7. In other words, \n",
    "\n",
    "```python\n",
    "for i in range(2, 7)\n",
    "```\n",
    "is equivalent to \n",
    "\n",
    "```python\n",
    "for i in [2, 3, 4, 5, 6]\n",
    "```\n",
    "**Note 2:** `print()` function prints its argument(s), then moves the cursor to the next line. You see in **Example 2** and **Example 3** that this behavior may *waste* a lot of *vertical space*. We changed this behavior with the additional (optional) argument of `end = \"   \"` in **Example 4**. This moves cursor by three spaces rather than moving it to the next line. This is how we can display items horizontally on the same line. \n",
    "\n",
    "**Note 3:** You can construct **any** Python program from only six different forms of control (*sequential execution*, and the `if`, `if . . . else`, `if . . . elif . . . else`, `while`, and `for`). \n",
    "<br>\n",
    "<hr style=\"border: 0.3px solid gray; background-color:black; width:40%;\"></hr>\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `range()` function\n",
    "\n",
    "`range()` is a built-in python function that could be used with one, two, or three arguments as follows:\n",
    "- **`range()` function with one argument:** `range(a)` produces a sequence of consecutive integers from 0 up to, but not including a. `range(a)` is equivalent to `[0, 1, ..., a-1]`. Hint: for a non-positive a, this function will generate nothing! \n",
    "  >**Example 1:**\n",
    "  >>```python\n",
    "  >>for i in range(5):\n",
    "  >>    print(i)\n",
    "  >>```\n",
    "  >\n",
    "  > produces all the integers from 0 up to but not including 5; which are\n",
    "  >\n",
    "  >>```python\n",
    "  >>0\n",
    "  >>1\n",
    "  >>2\n",
    "  >>3\n",
    "  >>4\n",
    "  >>```\n",
    "  \n",
    "- **`range()` function with two arguments:** `range(a, b)` produces a sequence of consecutive integers from a up to, but not including b. `range(a, b)` is equivalent to `[a, a+1, ..., b-1]`. Hint: for a $\\ge $ b this function will generate nothing! \n",
    "  >**Example 2:**\n",
    "  >>```python\n",
    "  >>for i in range(2, 7):\n",
    "  >>    print(i)\n",
    "  >>```\n",
    "  >\n",
    "  > produces all the integers from 2 up to but not including 7; which are\n",
    "  >\n",
    "  >>```python\n",
    "  >>2\n",
    "  >>3\n",
    "  >>4\n",
    "  >>5\n",
    "  >>6\n",
    "  >>```\n",
    "  \n",
    "- **`range()` function with three arguments:** `range(a, b, s)` produces a sequence of consecutive integers from a up to, but not including b, incrementing by the value of s. \n",
    "\n",
    "  - If a < b, then s must be a positive number. The corresponding sequence progresses from a up to, but not including b, incrementing by s. \n",
    "  - If a > b, then s must be a negative number. The corresponding sequence progresses from a down to, but not including b, decrementing by s. \n",
    "  \n",
    "  Here are a few examples:\n",
    "  \n",
    "  \n",
    "  >**Example 3:**\n",
    "  >>```python\n",
    "  >>for i in range(2, 11, 3):\n",
    "  >>    print(i)\n",
    "  >>```\n",
    "  >\n",
    "  > yields\n",
    "  >>```python\n",
    "  >>2\n",
    "  >>5\n",
    "  >>8\n",
    "  >>```\n",
    "  \n",
    "  >**Example 4:**\n",
    "  >>```python\n",
    "  >>for i in range(20, 5, -4):\n",
    "  >>    print(i)\n",
    "  >>```\n",
    "  >\n",
    "  > yields\n",
    "  >>```python\n",
    "  >>20\n",
    "  >>16\n",
    "  >>12\n",
    "  >>8\n",
    "  >>```\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Practice problem:** Write a snippet that will accept 4 integer numbers from the user and determine if they are even or odd\n",
    "```python\n",
    "for count in range(4):\n",
    "    num = int(input(\"enter number\"))\n",
    "    if num % 2 == 0:\n",
    "        print(\"even\")\n",
    "    else:\n",
    "        print(\"odd\")\n",
    "```\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Nested loop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Augmented assignments\n",
    "\n",
    "Consider the following snippet that sums up all the odd values from 5 to 20.\n",
    "\n",
    ">```python\n",
    ">sum = 0  # initialize a sum variable to keep track of the sum. \n",
    ">for num in range(5, 20, 2):  # start from 5, go up by step size of 2\n",
    ">    sum = sum + num  # add odd values to the sum\n",
    ">print(sum)  # once done, print the sum\n",
    ">```\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "96\n"
     ]
    }
   ],
   "source": [
    "sum = 0  # initialize a sum variable to keep track of the sum.\n",
    "for i in range(\n",
    "    5, 20, 2\n",
    "):  # start from 5, go up by step size of 2 until 20 (not including 20)\n",
    "    sum = sum + i  # add odd values to the sum\n",
    "print(sum)  # once done, print the sum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>4</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   0  1\n",
       "0  1  2\n",
       "1  4  5"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "test = np.array([[1, 2], [4, 5]])\n",
    "test2 = pd.DataFrame(test)\n",
    "test2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}