4.Control Flow.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "L9dZZUB4drt_"
   },
   "source": [
    "<img src=\"https://d24cdstip7q8pz.cloudfront.net/t/ineuron1/content/common/images/final%20logo.png\" height=50 alt-text=\"iNeuron.ai logo\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "6_RS7yJf0mG8"
   },
   "source": [
    "# 4) Control Flow\n",
    "   **Here, we are going to review and learn the most fundamentals of Python control flow: Decision making statement and loops.**\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "O0-HJUJu6Tce"
   },
   "source": [
    "## 4.1 Decision Making Statement\n",
    "   * It is kind of making decision during occurred situation of program execution and action can be taken according to specified conditions.\n",
    "   * Structure of decision making evaluate several expressions that provide True or False as a result.\n",
    "   * It is up to you to decide which type of action want to take and execute the statements based upon True and False.\n",
    "   \n",
    "**These are several topics of decision making which going to be discussed below:**\n",
    "   1. **if**\n",
    "   2. **if else** \n",
    "   3. **if elif else**\n",
    "   4. **Nested if**\n",
    "   5. **Single Statement Suites**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "cBDBiRPp0mG_"
   },
   "source": [
    "### 4.1.1 If statement\n",
    "   - In python `if` statement is same as other languages.\n",
    "   - It is having a logical expression where data is getting compared and based upon comparison result a decision is made.\n",
    "   \n",
    "**Examples**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndentationError",
     "evalue": "expected an indented block (<ipython-input-12-59a943d243b3>, line 4)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-12-59a943d243b3>\"\u001b[1;36m, line \u001b[1;32m4\u001b[0m\n\u001b[1;33m    print(\"a is greater than b\")\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": [
    "a=10\n",
    "b=20\n",
    "if a<b:\n",
    "    print(\"a is greater than b\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Sv1jYDn-0mHA",
    "outputId": "fa8fb79c-e047-4c8c-a8aa-140661d99752"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Value\n",
      "84\n"
     ]
    }
   ],
   "source": [
    "'''Its a simple if statement, \n",
    "if the value is defined then it \n",
    "display the print statements'''\n",
    "\n",
    "val=84\n",
    "if val:\n",
    "    print(\"Value\")\n",
    "    print(val)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "wkf4VVd90mHM"
   },
   "source": [
    "**Exercise**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "jbRPIZAb0mHN"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "jRlk740R0mHV"
   },
   "source": [
    "### 4.1.2 If-else statement\n",
    "\n",
    "   - With `if` statement an `else` statement is combined.\n",
    "   - `if-else` statement have a block of code, where `if` is executed when it is `1` or `True` and `else` when `if` is `0` or `False` \n",
    "   >**Note:** The `else` statement is consider to be an optional statement, so there could be only one `else` statement in block of code.\n",
    "   \n",
    "**Examples**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "kikHDZdN0mHX",
    "outputId": "b53cd865-4cc1-4899-cc08-b6daea1ca8b4"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Discount Rupess: 54.2\n",
      "Net payable Amount:  487.8\n"
     ]
    }
   ],
   "source": [
    "'''Its a good example to get \n",
    "the Net payable amount by setting up \n",
    "discount at specific price range by using if-else statement'''\n",
    "\n",
    "Total_Price=int(input(\"Price: \"))\n",
    "if Total_Price<100:\n",
    "    discount=Total_Price*0.04\n",
    "    print (\"Discount Rupess: \"+str(discount))\n",
    "else:\n",
    "    discount=Total_Price*0.1\n",
    "    print (\"Discount Rupess: \"+str(discount))\n",
    "print (\"Net payable Amount: \",Total_Price-discount)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "2lXCUeYa0mHc"
   },
   "source": [
    "**Exercise**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "qcJiI5i30mHe"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "vTC_imVx0mHl"
   },
   "source": [
    "### 4.1.3 If-elif-else statement\n",
    "\n",
    "   - The `elif` statement is used to check for the multiple `True` expressions and so on if the condition is `True` it execute a block of code.\n",
    "   - Similar `elif` statement is consider to be an optional like `else` statement. \n",
    "   - Though, we can use `elif` statement multiple times in a block of code, but `else` statement can be used only ones\n",
    "   \n",
    "**Examples**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "IDmWlyuL0mHm",
    "outputId": "aba0d758-4676-4dae-f954-c5e6afb9ded6"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Discount Rupess: 33.68\n",
      "Net payable Amount:  387.32\n"
     ]
    }
   ],
   "source": [
    "'''Its very good example to get \n",
    "the Net payable amount by setting up some \n",
    "discount at specific price range by using if-elif-else statement'''\n",
    "\n",
    "Total_Price=int(input(\"Price: \"))\n",
    "if Total_Price<100:\n",
    "    discount=Total_Price*0.04\n",
    "    print (\"Discount Rupess: \"+str(discount))\n",
    "elif Total_Price<500:\n",
    "    discount=Total_Price*0.08\n",
    "    print (\"Discount Rupess: \"+str(discount))\n",
    "else:\n",
    "    discount=Total_Price*0.1\n",
    "    print (\"Discount Rupess: \"+str(discount))\n",
    "print (\"Net payable Amount: \",Total_Price-discount)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "srMIw6Tp0mHt"
   },
   "source": [
    "**Exercise**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "AKXxscJU0mHu"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "L_eG2cDA0mH-"
   },
   "source": [
    "### 4.1.4 Nested If statement\n",
    "\n",
    "   - In some of the cases, it is required to have other check condition inside a check condition (when it `True`)\n",
    "   - Such type of scenarios required to have a nested arrangement.\n",
    "   - Under a nested if arrangement, an `if-elif-else` can be construct inside an another `if-elif-else` construct.\n",
    "   \n",
    "**Examples**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "qwhCrIt80mIA",
    "outputId": "58e4c9ae-8b50-423f-efaf-3dfd82f8b0ce"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number: 0\n",
      "Zero\n"
     ]
    }
   ],
   "source": [
    "'''Its a simple example to check whether \n",
    "a number is zero or positive or negative \n",
    "using nested if-else statement'''\n",
    "\n",
    "val = float(input(\"Enter a number: \"))\n",
    "if val >= 0:\n",
    "    if val == 0:\n",
    "        print(\"Zero\")\n",
    "    else:\n",
    "        print(\"Entered number is Positive\")\n",
    "else:\n",
    "    print(\"Entered number is Negative\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Jl3ydiJg0mII"
   },
   "source": [
    "**Exercise**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "0eKa2q2V0mIK"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "V85eLfOq0mIP"
   },
   "source": [
    "### 4.1.5 Single Statement Suites\n",
    "\n",
    "   - If the suite of `if` section have only a single line, then the header statement may go at same line.\n",
    "\n",
    "**Examples**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "L49IfEMm0mIR",
    "outputId": "3759dd47-f7fb-49f5-aa8c-cccdf9e88f8f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Value is less than equal to 999\n",
      "Good bye!\n"
     ]
    }
   ],
   "source": [
    "'''Its a simple example to check whether a value is less than equal to 999'''\n",
    "\n",
    "val = int(input(\"Enter a number: \"))\n",
    "if (val <= 999 ): print (\"Value is less than equal to 999\")\n",
    "print (\"Good bye!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "gDh-_Qws0mIW"
   },
   "source": [
    "**Exercise**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "vgoL_R_w0mIY"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "0WfQoKMZ6bjo"
   },
   "source": [
    "## 4.2 Loops Statements \n",
    "   * In loop, the statements are sequentially executed, execution of first function statement is done first, then second and so on.\n",
    "   * In situation where you need to perform a block of code many times then loop statement will come in to picture. \n",
    "   * It allows to execute/run group of statements or a statement multiple time.\n",
    "   \n",
    "**These are several topics of loop statements which going to be discussed below:**\n",
    "   1. **while Loop** \n",
    "   2. **for Loop**\n",
    "   3. **Nested loops**\n",
    "   4. **Loop Control**\n",
    "      * **break**\n",
    "      * **continue**\n",
    "      * **pass**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "HChDjhwK0mId"
   },
   "source": [
    "### 4.2.1 While Loop\n",
    "\n",
    "   * It repeats a statement or multiple statements when a provided condition is `True`.\n",
    "   * Before performing a loop body it check for a condition\n",
    "   \n",
    "**Examples**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### print a natural number upto 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "i=1\n",
    "while i<=10:\n",
    "    print(i)\n",
    "    i=i+1\n",
    "    if i==5:\n",
    "        continue"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "please enter a number:16\n"
     ]
    }
   ],
   "source": [
    "a=int(input(\"please enter a number:\"))\n",
    "      \n",
    "if a>10:\n",
    "      pass\n",
    "else:\n",
    "      print(\"no\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "database "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "for i in [1,2,3,4,5,6,7,8,9,10]:\n",
    "    print(i)\n",
    "    if i==8:\n",
    "        break\n",
    "    \n",
    "else:\n",
    "    print(\"bye\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the number: 10\n",
      "The natural number is 0\n",
      "The natural number is 1\n",
      "The natural number is 2\n",
      "The natural number is 3\n",
      "The natural number is 4\n",
      "The natural number is 5\n",
      "The natural number is 6\n",
      "The natural number is 7\n",
      "The natural number is 8\n",
      "The natural number is 9\n",
      "The natural number is 10\n",
      "All the natural number are  printed. ....\n"
     ]
    }
   ],
   "source": [
    "num  = int(input(\"Enter the number: \"))\n",
    "i = 0\n",
    "while(i<=num):\n",
    "    print(\"The natural number is\", i)\n",
    "    i = i+1\n",
    "    #if i == 8:\n",
    "        #break\n",
    "else:\n",
    "    print(\"All the natural number are  printed. ....\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "s\n",
      "u\n",
      "n\n",
      "n\n",
      "y\n"
     ]
    }
   ],
   "source": [
    "s='sunny'\n",
    "i=0\n",
    "while i<len(s):\n",
    "    print(s[i])\n",
    "    i=i+1  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n",
      "hello\n",
      "hello\n",
      "hello\n",
      "hello\n"
     ]
    }
   ],
   "source": [
    "i=1\n",
    "while i<=5:\n",
    "    print(\"hello\")\n",
    "    i=i+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "wamQNLwF0mIe",
    "outputId": "a570f6f8-e3dd-4a1c-b15f-b9acbdaf3660"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "Total Money:  50 Rupees\n"
     ]
    }
   ],
   "source": [
    "''' A child is learning to count number of 10 rupess in his hand \n",
    "and here we have given 5 notes of 10 rupess. \n",
    "Output will display the counting of notes and total amount'''\n",
    "\n",
    "notes = 5\n",
    "i=1 # starting number intialize\n",
    "while i<=notes:\n",
    "    print(i)\n",
    "    i += 1\n",
    "print('Total Money: ',notes*10,'Rupees')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "oc-WbL750mIi",
    "outputId": "d1ff7961-ba25-4a49-f097-dd117c37d531"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "No 10 rupees note left\n",
      "Total Money:  50 Rupees\n"
     ]
    }
   ],
   "source": [
    "'''Continuing with same example, \n",
    "here we using else statement'''\n",
    "\n",
    "notes = 5\n",
    "i=1 # starting number intialize\n",
    "while i<=notes:\n",
    "    print(i)\n",
    "    i += 1\n",
    "else:\n",
    "    print(\"No 10 rupees note left\")\n",
    "print('Total Money: ',notes*10,'Rupees')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "S4OLsxYL0mIo"
   },
   "source": [
    "**Exercise**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "rPfBG12n0mIp"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "UHyodZzR0mIv"
   },
   "source": [
    "### 4.2.2 For Loop\n",
    "\n",
    "   * Here `for` loop statement is used to iterates over an item at any order, items can be a `string` or a `list`.\n",
    "   \n",
    "**Examples**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "v654KZLA0mIw",
    "outputId": "d907bba2-ed5b-49f9-ffa7-90db21b19898"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mango\n",
      "Cherry\n",
      "Apple\n",
      "Papaya\n",
      "Banana\n"
     ]
    }
   ],
   "source": [
    "''' A simple example has taken where \n",
    "we have several fruits in a list and we display \n",
    "this fruit as per the arrangement in list'''\n",
    "\n",
    "fruits_list = [\"Mango\",\"Cherry\",\"Apple\",\"Papaya\",\"Banana\"] ## List containing friuts name\n",
    "for x in fruits_list:\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "xgFQ7GJm0mIz",
    "outputId": "bb5cf517-a3a3-4996-cf15-6b09e1c35039"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mango\n",
      "Cherry\n",
      "Apple\n",
      "Papaya\n",
      "Banana\n",
      "List has no fruit left!\n"
     ]
    }
   ],
   "source": [
    "'''Continuing the previous example with using else statement'''\n",
    "\n",
    "fruits_list = [\"Mango\",\"Cherry\",\"Apple\",\"Papaya\",\"Banana\"] ## List containing friuts name\n",
    "for x in fruits_list:\n",
    "    print(x)\n",
    "else:\n",
    "    print(\"List has no fruit left!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "vO-FnkqK0mI7",
    "outputId": "09bde70f-33f3-40a4-98d8-920afd3b55c3"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "M\n",
      "a\n",
      "n\n",
      "g\n",
      "o\n"
     ]
    }
   ],
   "source": [
    "'''An iterative example of string is shown here'''\n",
    "\n",
    "f_name = \"Mango\" ## string as input\n",
    "for x in f_name:\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "qhSWpvHL0mJC"
   },
   "source": [
    "**Exercise**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Take this fruit list print this fruit name and along with the fruit name try to print individual character as well"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "for example:\n",
    "    \n",
    "mango\n",
    "\n",
    "m\n",
    "\n",
    "a\n",
    "\n",
    "n\n",
    "\n",
    "g\n",
    "\n",
    "o\n",
    "\n",
    "like this"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "LQ0BcW150mJD"
   },
   "outputs": [],
   "source": [
    "fruits_list = [\"Mango\",\"Cherry\",\"Apple\",\"Papaya\",\"Banana\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mango\n",
      "M\n",
      "a\n",
      "n\n",
      "g\n",
      "o\n",
      "Cherry\n",
      "C\n",
      "h\n",
      "e\n",
      "r\n",
      "r\n",
      "y\n",
      "Apple\n",
      "A\n",
      "p\n",
      "p\n",
      "l\n",
      "e\n",
      "Papaya\n",
      "P\n",
      "a\n",
      "p\n",
      "a\n",
      "y\n",
      "a\n",
      "Banana\n",
      "B\n",
      "a\n",
      "n\n",
      "a\n",
      "n\n",
      "a\n"
     ]
    }
   ],
   "source": [
    "for i in fruits_list:\n",
    "    print(i)\n",
    "    for j in i:\n",
    "        print(j)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "qYDgjZMx0mJK"
   },
   "source": [
    "### 4.2.3 Nested Loops\n",
    "\n",
    "   * Nested loops is used to create one and more number of loop inside an existing `for` or `while` loop.\n",
    "   \n",
    "**Examples**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "pf-WVwM70mJL",
    "outputId": "a15a1601-8a7c-4115-bceb-a9a274a2d5d4"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "* \n",
      "* * \n",
      "* * * \n",
      "* * * * \n",
      "* * * * * \n",
      "* * * * * * \n",
      "* * * * * * * \n"
     ]
    }
   ],
   "source": [
    "'''Here we use nested for loop to create a triangle'''\n",
    "\n",
    "n=7 #n is length and width of triangle\n",
    "for i in range(0, n): #loop to handle the rows \n",
    "\n",
    "    for j in range(0, i+1): #loop to handle the columns \n",
    "\n",
    "        print(\"* \",end=\"\") #printing the stars \n",
    "\n",
    "    print(\"\\r\") #after each row line will end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "NQG0ZUsA0mJR",
    "outputId": "66e18af1-e59b-4db2-9823-c6cfb018c2b3"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    *\n",
      "   ***\n",
      "  *****\n",
      " *******\n",
      "*********\n"
     ]
    }
   ],
   "source": [
    "''' This exaple shows the use of nested while loop to\n",
    "create a pyramid like structure'''\n",
    "\n",
    "num_rows = int(input(\"Enter the number of rows: \"))\n",
    "row = 0 #row intialize\n",
    "while(row < num_rows):\n",
    "    row += 1 #Rows count increase\n",
    "    s = num_rows - row #Spaces\n",
    "\n",
    "    sc = 0 #Space counter intialize\n",
    "    while(sc < s):\n",
    "        print(\" \", end='')\n",
    "        sc += 1\n",
    "\n",
    "    stars = 2*row-1 #Number of stars\n",
    "    while(stars > 0):\n",
    "        print(\"*\", end='')\n",
    "        stars -= 1\n",
    "\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "umRv9wvn0mJX"
   },
   "source": [
    "**Exercise**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "i=1\n",
    "j=2\n",
    "k=3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "JtKTwa87qF8Z"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 2 3\n"
     ]
    }
   ],
   "source": [
    "if i<j:\n",
    "    if j<k:\n",
    "        i=j\n",
    "    else:\n",
    "        j=k\n",
    "else:\n",
    "    if j>k:\n",
    "        j=i\n",
    "    else:\n",
    "        i=k\n",
    "print(i,j,k)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "9KP_6Wib0mJd"
   },
   "source": [
    "### 4.2.4 Loop Control\n",
    "The loop control is used to change its preceding sequence to different form.\n",
    "\n",
    "**break statement -** This statement used for a premature terminates of current loop immediately and executes the further statement, just like `break` statement in `C` language.\n",
    "\n",
    "**continue statement -** When `continue` statement is encountered during an iteration, it directly goes to next iteration without performing remaining statements in present iteration. It returns execution to the starting point of current loop and start further iteration.\n",
    "\n",
    "   >**Note:** `break` and `continue` can be used in both `while` and `for` loop.\n",
    "\n",
    "**pass statement -** The `pass` statement is considered as a `null` operation. It is useful when a code (i.e., code required in future) has not written till now, but your code will go eventually.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "KvbDIrLP0mJd"
   },
   "source": [
    "#### Break statement\n",
    "**Examples**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "i=1\n",
    "while i<=5:\n",
    "    print(i)\n",
    "    if i==4:\n",
    "        break\n",
    "    i=i+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "gT_Erwb40mJe",
    "outputId": "c7c5a4df-f023-48b6-e168-b9c350e6a680"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "'''It is a simple example of break, \n",
    "where it immediatly terminate an operation of \n",
    "statement body when x is equal to 4'''\n",
    "\n",
    "x = 1\n",
    "while x < 7:\n",
    "    print(x)\n",
    "    if x == 4:\n",
    "        break\n",
    "    x += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "tHSVL21H0mJk",
    "outputId": "c4815d21-964c-44df-fc72-b34b98017903"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mango\n",
      "Cherry\n",
      "Apple\n"
     ]
    }
   ],
   "source": [
    "'''Here it terminates the \n",
    "operational body when fruit name is Papaya'''\n",
    "\n",
    "fruits_list = [\"Mango\",\"Cherry\",\"Apple\",\"Papaya\",\"Banana\"] ## List containing friuts name\n",
    "for x in fruits_list:\n",
    "    if x == \"Papaya\":\n",
    "        break\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "LMLFlARC0mJs"
   },
   "source": [
    "**Exercise**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "dmyhc1nS0mJu"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "dIdEC_Kk0mJy"
   },
   "source": [
    "#### Continue statement\n",
    "**Examples**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "T09xJKjL0mJz",
    "outputId": "c97264da-877b-43dd-fed3-7280e84f0a42"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "5\n",
      "6\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "'''It is a simple example of continue, \n",
    "where it simply terminate an current iteration \n",
    "when x is equal to 4 and \n",
    "continues with next iteration'''\n",
    "\n",
    "x = 0\n",
    "while x < 7:\n",
    "    x += 1\n",
    "    if x == 4:\n",
    "        continue\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "oefLv2YD0mJ3",
    "outputId": "ccc51ded-4e48-4b50-d531-0bd558369afd"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mango\n",
      "Cherry\n",
      "Apple\n",
      "Banana\n"
     ]
    }
   ],
   "source": [
    "'''In this example it simply terminate \n",
    "an current iteration when fruit name is Papaya and \n",
    "continues with next iteration'''\n",
    "\n",
    "fruits_list = [\"Mango\",\"Cherry\",\"Apple\",\"Papaya\",\"Banana\"] ## List containing friuts name\n",
    "for x in fruits_list:\n",
    "    if x == \"Papaya\":\n",
    "        continue\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ibtfDQzv0mKA"
   },
   "source": [
    "**Exercise**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "mGL-is_k0mKB"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "HruE8jjF0mKI"
   },
   "source": [
    "#### Pass statement\n",
    "**Examples**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "hn1HD60h0mKK"
   },
   "outputs": [],
   "source": [
    "'''A simple example of pass, \n",
    "where it is not decided what to do with i'''\n",
    "\n",
    "for i in [10, 100, 200]:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "K3sFnq0a0mKO",
    "outputId": "7fa328a2-e81b-428c-c4f1-34b14efdadce"
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "unexpected EOF while parsing (<ipython-input-35-04f54b39379d>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-35-04f54b39379d>\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    for i in [10, 100, 200]:\u001b[0m\n\u001b[1;37m                            ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m unexpected EOF while parsing\n"
     ]
    }
   ],
   "source": [
    "'''Continuing with same above example \n",
    "if for loop body left simply, then it will throw an error'''\n",
    "\n",
    "for i in [10, 100, 200]:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "LVPiMKU20mKR"
   },
   "source": [
    "**Exercise**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "tQCuBwjRqF8u"
   },
   "source": [
    "### Write a program to check whether the last digit of a number( entered by user ) is divisible by 3 or not."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Write a program to accept the cost price of a bike and display the road tax to be paid according to the following criteria :\n",
    "    \n",
    "        Cost price (in Rs)                                       Tax\n",
    "        > 100000                                                  15 %\n",
    "        > 50000 and <= 100000                                     10%\n",
    "        <= 50000                                                  5%"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A company decided to give bonus to employee according to following criteria:\n",
    "\n",
    "    Time period of Service                Bonus\n",
    "\n",
    "    More than 10 years                    10%\n",
    "\n",
    "    >=6 and <=10                           8%\n",
    "\n",
    "    Less than 6 years                      5%\n",
    "\n",
    "    Ask user for their salary and years of service and print the net bonus amount."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Write a Python program to guess a number between 1 to 9.\n",
    "\n",
    "Note : User is prompted to enter a guess. If the user guesses wrong then the prompt appears again until the guess is correct, on successful guess, user will get a \"Well guessed!\" message, and the program will exit."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Write a program to accept a string from the user and display it vertically but don’t display the vowels in it.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hi 2 hi 4 "
     ]
    }
   ],
   "source": [
    "i=0\n",
    "while i<4:\n",
    "    i=i+1\n",
    "    if(i%2!=0):\n",
    "        pass\n",
    "        print(\"hi\",end=\" \")\n",
    "    else:\n",
    "        print(i,end=\" \")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "m, y,  , n, a, m, e,  , i, s,  , s, a, c, h, i, n, "
     ]
    }
   ],
   "source": [
    "text = \"my name is sachin\"\n",
    "for i in text:\n",
    "    print (i, end=\", \")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = int(input('Enter a number: '))\n",
    "while x != 0:\n",
    "    for y in range (1, x+1):\n",
    "        print (y)\n",
    "        y+=1\n",
    "    x = int(input('Enter a number: '))\n"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "4.Control Flow.ipynb",
   "provenance": [],
   "toc_visible": true
  },
  "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}