007_Python_break_continue_pass_statements.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<small><small><i>\n",
    "All the IPython Notebooks in **Python Flow Control Statements** lecture series by Dr. Milaan Parmar are available @ **[GitHub](https://github.com/milaan9/03_Python_Flow_Control)**\n",
    "</i></small></small>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Control Statements in Python\n",
    "\n",
    "As you may know, loops in Python are used to iterate repeatedly over a block of code. But at times, you might want to **shift the control once a particular condition is satisfied**. This is where control statements in Python come into the picture.\n",
    "\n",
    "Control statements in python are **used to control the flow of execution of the program based on the specified conditions**. Python supports **3 types of control statements**:\n",
    "\n",
    "|      | Statement | Description |\n",
    "|:----|:----| :--- |\n",
    "|1| **`break`** | Terminate the current loop. Use the **`break`** statement to come out of the loop instantly. |\n",
    "|2| **`continue`** | Skip the current iteration of a loop and move to the next iteration |\n",
    "|3| **`pass`** | Do nothing. Ignore the condition in which it occurred and proceed to run the program as usual |\n",
    "\n",
    "Loops iterate over a block of code until the test expression is **`False`**, but sometimes we wish to terminate the current iteration or even the whole loop without checking test expression.\n",
    "\n",
    "The **`break`** and **`continue`** statements are part of a control flow statements that helps you to understand the basics of Python.\n",
    "\n",
    "<div>\n",
    "<img src=\"img/ctrl1.png\" width=\"200\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. Python `break` statement\n",
    "\n",
    "In Python, the **`break`** statement provides you with the opportunity to **exit out** of a loop when an external condition is **triggered**, and the program control transfer to the next statement following the loop.\n",
    "\n",
    "If the **`break`** statement is inside a nested loop (loop inside another loop), the **`break`** statement will terminate the innermost loop.\n",
    "\n",
    "You’ll put the **`break`** statement within the block of code under your loop statement, usually after a conditional **[if statement](https://github.com/milaan9/03_Python_Flow_Control/blob/main/001_Python_if_statement.ipynb)**. This statement can only be used in **[for loop](https://github.com/milaan9/03_Python_Flow_Control/blob/main/005_Python_for_Loop.ipynb)** and **[while loop](https://github.com/milaan9/03_Python_Flow_Control/blob/main/006_Python_while_Loop.ipynb)**.\n",
    "\n",
    "<div>\n",
    "<img src=\"img/b1.png\" width=\"300\"/>\n",
    "</div>\n",
    "\n",
    "The working of **`break`** statement in **`for`** loop and **`while`**  loop is shown below.\n",
    "\n",
    "<div>\n",
    "<img src=\"img/b2.png\" width=\"700\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-12T16:08:12.834872Z",
     "start_time": "2021-06-12T16:08:12.824130Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "current number 10\n",
      "current number 30\n"
     ]
    }
   ],
   "source": [
    "# Example 1:\n",
    "\n",
    "numbers = [10, 30, 120, 330]\n",
    "for i in numbers:\n",
    "    if i > 100:\n",
    "        break\n",
    "    print('current number', i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-12T16:08:13.037991Z",
     "start_time": "2021-06-12T16:08:13.020416Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number is 1\n",
      "Number is 2\n",
      "Number is 3\n",
      "Number is 4\n",
      "Out of loop\n"
     ]
    }
   ],
   "source": [
    "# Example 2: Let’s look at an example that uses the break statement in a `for` loop\n",
    "\n",
    "number = 0\n",
    "for number in range(10):\n",
    "    number = number + 1\n",
    "    if number == 5:\n",
    "        break    # break here\n",
    "    print('Number is ' + str(number))\n",
    "print('Out of loop')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Explanation:**\n",
    "\n",
    "1. In this small program, the variable number is initialized at **`0`**. Then a **`for`** statement constructs the loop as long as the variable number is **less than 10**.\n",
    "\n",
    "2. Within the **`for`** loop, the number increases incrementally by **`1`** with each pass because of the line **number = number + 1**.\n",
    "\n",
    "3. Then, there is an **`if`** statement that presents the condition that if the variable number is **equivalent** to the integer **`5`**, then the loop will break.\n",
    "\n",
    "4. Within the loop is also a **[print()](https://github.com/milaan9/04_Python_Functions/blob/main/002_Python_Functions_Built_in/051_Python_print%28%29.ipynb)** statement that will execute with each iteration of the **`for`** loop until the loop breaks, since it is after the **`break`** statement.\n",
    "\n",
    "5. To see when we are out of the loop, we have included a final **`print()`** statement outside of the **`for`** loop.\n",
    "\n",
    "This shows that once the integer number is evaluated as equivalent to **`5`**, the loop breaks, as the program is told to do so with the **`break`** statement."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Nested `break` loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. `break` Statement in Nested Loop\n",
    "\n",
    "To terminate the nested loop, use a **`break`** statement inside the inner loop. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-12T16:08:13.736228Z",
     "start_time": "2021-06-12T16:08:13.719632Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0...1...2...3...4...5...6...7...8...9...10...completed.\n"
     ]
    }
   ],
   "source": [
    "# Example 1:\n",
    "\n",
    "for i in range(100):\n",
    "    print(i,end=\"...\")\n",
    "    if i>=10:\n",
    "        break\n",
    "print(\"completed.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-12T16:08:13.954002Z",
     "start_time": "2021-06-12T16:08:13.938378Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "s\n",
      "t\n",
      "r\n",
      "The end\n"
     ]
    }
   ],
   "source": [
    "# Example 2: Use of break statement inside the loop\n",
    "\n",
    "for val in \"string\":\n",
    "    if val == \"i\":\n",
    "        break\n",
    "    print(val)\n",
    "print(\"The end\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Explanation:**\n",
    "\n",
    "In this program, we iterate through the \"**`string`**\" sequence. We check if the letter is **`i`**, upon which we break from the loop. Hence, we see in our output that all the letters up till **`i`** gets printed. After that, the loop terminates."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Print the letters in \"HELLOWORLD\" one by one untill the letter R is reached using break statement in Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-12T16:08:14.842176Z",
     "start_time": "2021-06-12T16:08:14.824110Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "H\n",
      "E\n",
      "L\n",
      "L\n",
      "O\n",
      "W\n",
      "O\n",
      "untill letter R printed\n"
     ]
    }
   ],
   "source": [
    "# Example 3: \n",
    "\n",
    "for letter in \"HELLOWORLD\":   # letter is a variable which could have been with any name. each iteration the letter is advanced in the string \"FACEPREP\" and stored in variable letter.\n",
    "    if letter == \"R\":        #check for condition\n",
    "        break               # if condition true, then break out of the loop and print the final print statement.\n",
    "    print(letter)       # if condition false, then print that letter.\n",
    "print('untill letter R printed')    #once the for loop is terminated, print this. \n",
    "\n",
    "# Note: observe the indentations carefully"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-12T16:08:22.314280Z",
     "start_time": "2021-06-12T16:08:15.161023Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a word: Happy\n",
      "A not found\n"
     ]
    }
   ],
   "source": [
    "# Example 4: program to check if letter 'A' is present in the input\n",
    "\n",
    "a = input (\"Enter a word: \")\n",
    "for i in a:\n",
    "    if (i == 'A'):\n",
    "        print (\"A is found\")\n",
    "        break \n",
    "else:\n",
    "    print (\"A not found\")\n",
    "    \n",
    "# Note: Python is case-sensitive language."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-12T16:08:22.376783Z",
     "start_time": "2021-06-12T16:08:22.364087Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A l a n 9 9 "
     ]
    }
   ],
   "source": [
    "# Example 5: bested `while` loop with `break`\n",
    "\n",
    "name = 'Alan99 White'\n",
    "\n",
    "size = len(name)\n",
    "i = 0\n",
    "# iterate loop till the last character\n",
    "while i < size:\n",
    "    # break loop if current character is space\n",
    "    if name[i].isspace():\n",
    "        break\n",
    "    # print current character\n",
    "    print(name[i], end=' ')\n",
    "    i = i + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-12T16:08:27.087188Z",
     "start_time": "2021-06-12T16:08:27.056921Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Multiplication table of 1\n",
      "1 2 3 4 5 6 7 8 9 10 \n",
      "Multiplication table of 2\n",
      "2 4 6 8 10 12 14 16 18 20 \n",
      "Multiplication table of 3\n",
      "3 6 9 12 15 18 21 24 27 30 \n",
      "Multiplication table of 4\n",
      "4 8 12 16 20 24 28 32 36 40 \n",
      "Multiplication table of 5\n",
      "5 10 15 20 25 30 35 40 45 50 \n",
      "Multiplication table of 6\n",
      "6 12 18 24 30 \n",
      "Multiplication table of 7\n",
      "7 14 21 28 35 \n",
      "Multiplication table of 8\n",
      "8 16 24 32 40 \n",
      "Multiplication table of 9\n",
      "9 18 27 36 45 \n",
      "Multiplication table of 10\n",
      "10 20 30 40 50 \n"
     ]
    }
   ],
   "source": [
    "# Example 6:\n",
    "\n",
    "for i in range(1, 11):\n",
    "    print('Multiplication table of', i)\n",
    "    for j in range(1, 11):\n",
    "        # condition to break inner loop\n",
    "        if i > 5 and j > 5:\n",
    "            break\n",
    "        print(i * j, end=' ')\n",
    "    print('')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Explanation:**\n",
    "\n",
    "We have two loops, the outer loop, and the inner loop. The outer for loop iterates the first 10 numbers using the **[range()](https://github.com/milaan9/04_Python_Functions/blob/main/002_Python_Functions_Built_in/053_Python_range%28%29.ipynb)** function, and the internal loop prints the multiplication table of each number.\n",
    "\n",
    "But if the current number of both the outer loop and the inner loop is greater than 5 then terminate the inner loop using the **`break`** statement."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. `break` Statement in Outer Loop\n",
    "\n",
    "To terminate the outside loop, use a **`break`** statement inside the outer loop. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-12T16:08:29.111587Z",
     "start_time": "2021-06-12T16:08:29.095964Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Multiplication table of 1\n",
      "1 2 3 4 5 6 7 8 9 10 \n",
      "Multiplication table of 2\n",
      "2 4 6 8 10 12 14 16 18 20 \n",
      "Multiplication table of 3\n",
      "3 6 9 12 15 18 21 24 27 30 \n",
      "Multiplication table of 4\n",
      "4 8 12 16 20 24 28 32 36 40 \n",
      "Multiplication table of 5\n",
      "5 10 15 20 25 30 35 40 45 50 \n"
     ]
    }
   ],
   "source": [
    "# Example 1: Break nested loop\n",
    "\n",
    "for i in range(1, 11):\n",
    "    # condition to break outer loop\n",
    "    if i > 5:\n",
    "        break\n",
    "    print('Multiplication table of', i)\n",
    "    for j in range(1, 11):\n",
    "        print(i * j, end=' ')\n",
    "    print('')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Explanation:**\n",
    "\n",
    "We have two loops, the outer loop, and the inner loop. The outer loop iterates the first 10 numbers, and the internal loop prints the multiplication table of each number.\n",
    "\n",
    "But if the current number of the outer loop is greater than 5 then terminate the outer loop using the **`break`** statement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-12T16:08:30.062754Z",
     "start_time": "2021-06-12T16:08:30.048105Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Current Number is: 3\n",
      "Square of a current number is: 9\n",
      "Current Number is: 6\n",
      "Square of a current number is: 36\n",
      "Current Number is: 12\n",
      "Current Number is: 9\n",
      "Square of a current number is: 81\n"
     ]
    }
   ],
   "source": [
    "# Example 2:\n",
    "\n",
    "numbers = [3, 6, 12, 9]\n",
    "for i in numbers:\n",
    "    print('Current Number is:', i)\n",
    "    # skip below statement if number is greater than 10\n",
    "    if i > 10:\n",
    "        continue\n",
    "    square = i * i\n",
    "    print('Square of a current number is:', square)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-12T16:08:30.717046Z",
     "start_time": "2021-06-12T16:08:30.705325Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n",
      "5\n",
      "End of Loop\n"
     ]
    }
   ],
   "source": [
    "# Example 3: Python Continue Statement Example:\n",
    "\n",
    "a=0\n",
    "\n",
    "while a<=5:\n",
    "    a=a+1\n",
    "    if a%2==0: \n",
    "        continue\n",
    "    print (a)\n",
    "print (\"End of Loop\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Explanation:**\n",
    "\n",
    "You can use the **`continue`** statement to avoid deeply nested conditional code, or to optimize a loop by eliminating frequently occurring cases that you would like to reject.\n",
    "\n",
    "The **`continue`** statement causes a program to skip certain factors that come up within a loop, but then continue through the rest of the loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-12T16:08:32.292716Z",
     "start_time": "2021-06-12T16:08:32.273183Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "s\n",
      "t\n",
      "r\n",
      "n\n",
      "g\n",
      "The end\n"
     ]
    }
   ],
   "source": [
    "# Example 4: Program to show the use of continue statement inside loops\n",
    "\n",
    "for val in \"string\":\n",
    "    if val == \"i\":\n",
    "        continue\n",
    "    print(val)\n",
    "\n",
    "print(\"The end\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Explanation**:\n",
    "\n",
    "This program is same as the above example except the **`break`** statement has been replaced with **`continue`**.\n",
    "\n",
    "We continue with the loop, if the string is **`i`**, not executing the rest of the block. Hence, we see in our output that all the letters except **`i`** gets printed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-12T16:08:33.883035Z",
     "start_time": "2021-06-12T16:08:33.872290Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Processed 0\n",
      "Processed 1\n",
      "Processed 2\n",
      "Processed 3\n",
      "Processed 4\n",
      "Ignored 5\n",
      "Ignored 6\n",
      "Ignored 7\n",
      "Ignored 8\n",
      "Ignored 9\n"
     ]
    }
   ],
   "source": [
    "# Example 5:\n",
    "\n",
    "for i in range(10):\n",
    "    if i>4:\n",
    "        print(\"Ignored\",i)\n",
    "        continue\n",
    "    # this statement is not reach if i > 4\n",
    "    print(\"Processed\",i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a program to skip all \"O\"s in a given string \"HELLOWORLD\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-12T16:08:34.880584Z",
     "start_time": "2021-06-12T16:08:34.863981Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "H\n",
      "e\n",
      "l\n",
      "l\n",
      "o\n",
      "W\n",
      "o\n",
      "r\n",
      "l\n",
      "d\n",
      "The End\n"
     ]
    }
   ],
   "source": [
    "# Example 6:\n",
    "\n",
    "for letters in \"HelloWorld\":  # for every letter in FACEPREP\n",
    "    if letters == \"O\":      # if letter is E, then skip printing the letter and go to the next iteration with the next alphabet\n",
    "        continue            # Remember that loop is not terminated like break statement.\n",
    "    print(letters)\n",
    "print(\"The End\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. Python `continue` statement\n",
    "\n",
    "In Python, the **`continue`** statement is a **jump statement** which is used to skip execution of current iteration. After **skipping**, loop **`continue`** with next iteration. We can use **`continue`** statement **only** with **[for loop](https://github.com/milaan9/03_Python_Flow_Control/blob/main/005_Python_for_Loop.ipynb)** as well as **[while loop](https://github.com/milaan9/03_Python_Flow_Control/blob/main/006_Python_while_Loop.ipynb)** in Python. It is typically **only** used within an **[if statement](https://github.com/milaan9/03_Python_Flow_Control/blob/main/001_Python_if_statement.ipynb)** (otherwise the remainder of the loop would never be executed).\n",
    "\n",
    "<div>\n",
    "<img src=\"img/con1.png\" width=\"300\"/>\n",
    "</div>\n",
    "\n",
    "The working of **`continue`** statement in **`for`** loop and **`while`** loop is shown below.\n",
    "\n",
    "<div>\n",
    "<img src=\"img/con2.png\" width=\"700\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `continue` statement in `while` loop\n",
    "\n",
    "We can also use the **`continue`** statement inside a **`while`** loop. For example:\n",
    "\n",
    "Write a **[while loop](https://github.com/milaan9/03_Python_Flow_Control/blob/main/006_Python_while_Loop.ipynb)** to display each character from a string and if a character is a space, then don’t display it and move to the next character.\n",
    "\n",
    "Use the if condition with the **`continue`** statement to jump to the next iteration. If the current character is space, then the condition evaluates to true, then the **`continue`** statement will execute, and the loop will move to the next iteration by skipping the remeaning body."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-12T16:08:38.606624Z",
     "start_time": "2021-06-12T16:08:38.592955Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A r t h u r "
     ]
    }
   ],
   "source": [
    "# Example 1: use the `continue` statement inside a `while` loop\n",
    "\n",
    "name = 'Art hu r'\n",
    "\n",
    "size = len(name)\n",
    "i = -1\n",
    "# iterate loop till the last character\n",
    "while i < size - 1:\n",
    "    i = i + 1\n",
    "    # skip loop body if current character is space\n",
    "    if name[i].isspace():\n",
    "        continue\n",
    "    # print current character\n",
    "    print(name[i], end=' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `continue` statement with `else` statements\n",
    "\n",
    "Sometimes we want to know if a loop exited 'normally' or via a **`break`** statement. This can be achieved with an **`else:`** statement in a loop which only executes if there was no **`break`** statement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-12T16:08:51.357492Z",
     "start_time": "2021-06-12T16:08:39.913255Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a word: Honey is sweet\n"
     ]
    }
   ],
   "source": [
    "# Example 1: program to check if letter 'A' is present in the input\n",
    "\n",
    "a = input (\"Enter a word: \")\n",
    "for i in a:\n",
    "    if(i != 'A'):        \n",
    "        continue        \n",
    "    else:\n",
    "        print(\"A is found\")\n",
    "        break\n",
    "    print(\"A is not found\")\n",
    "    \n",
    "# Enter a word: Honey is sweet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-12T16:09:00.030274Z",
     "start_time": "2021-06-12T16:08:53.753959Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a word: Honey is sweet\n",
      "A is not found\n"
     ]
    }
   ],
   "source": [
    "# Example 1 :without using continue\n",
    "\n",
    "a = input (\"Enter a word: \")\n",
    "for i in a:\n",
    "    if (i == 'A'):\n",
    "        print(\"A is found\")\n",
    "        break\n",
    "else:\n",
    "    print (\"A is not found\")\n",
    "    \n",
    "# Enter a word: Honey is sweet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-12T16:09:06.199166Z",
     "start_time": "2021-06-12T16:09:06.188425Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "count = 1\n",
      "count = 5\n",
      "count = 9\n",
      "Normal exit with 12\n"
     ]
    }
   ],
   "source": [
    "# Example 2:\n",
    "\n",
    "count = 0\n",
    "while count < 10:\n",
    "    count += 1\n",
    "    if count % 2 == 0: # even number\n",
    "        count += 2\n",
    "        continue\n",
    "    elif 5 < count < 9:\n",
    "        break # abnormal exit if we get here!\n",
    "    print(\"count =\",count)\n",
    "else: # while-else\n",
    "    print(\"Normal exit with\",count)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Nested `continue` loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. `continue` Statement in Nested Loop\n",
    "\n",
    "To skip the current iteration of the nested loop, use the **`continue`** statement inside the body of the inner loop. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-12T16:09:08.793873Z",
     "start_time": "2021-06-12T16:09:08.770437Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Multiplication table of 1\n",
      "1 2 3 4 6 7 8 9 10 \n",
      "Multiplication table of 2\n",
      "2 4 6 8 12 14 16 18 20 \n",
      "Multiplication table of 3\n",
      "3 6 9 12 18 21 24 27 30 \n",
      "Multiplication table of 4\n",
      "4 8 12 16 24 28 32 36 40 \n",
      "Multiplication table of 5\n",
      "5 10 15 20 30 35 40 45 50 \n",
      "Multiplication table of 6\n",
      "6 12 18 24 36 42 48 54 60 \n",
      "Multiplication table of 7\n",
      "7 14 21 28 42 49 56 63 70 \n",
      "Multiplication table of 8\n",
      "8 16 24 32 48 56 64 72 80 \n",
      "Multiplication table of 9\n",
      "9 18 27 36 54 63 72 81 90 \n",
      "Multiplication table of 10\n",
      "10 20 30 40 60 70 80 90 100 \n"
     ]
    }
   ],
   "source": [
    "# Example 1: `continue` statement in nested loop\n",
    "\n",
    "for i in range(1, 11):\n",
    "    print('Multiplication table of', i)\n",
    "    for j in range(1, 11):\n",
    "        # condition to skip current iteration\n",
    "        if j == 5:\n",
    "            continue\n",
    "        print(i * j, end=' ')\n",
    "    print('')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Explanation:**\n",
    "\n",
    "We have the outer loop and the inner loop. The outer loop iterates the first 10 numbers, and the internal loop prints the multiplication table of each number.\n",
    "\n",
    "But if the current number of the inner loop is equal to 5, then skip the current iteration and move to the next iteration of the inner loop using the **`continue`** statement."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. `continue` Statement in Outer Loop\n",
    "\n",
    "To skip the current iteration of an outside loop, use the **`continue`** statement inside the outer loop. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-12T16:09:11.154202Z",
     "start_time": "2021-06-12T16:09:11.131744Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Multiplication table of 1\n",
      "1 2 3 4 5 6 7 8 9 10 \n",
      "Multiplication table of 3\n",
      "3 6 9 12 15 18 21 24 27 30 \n",
      "Multiplication table of 5\n",
      "5 10 15 20 25 30 35 40 45 50 \n",
      "Multiplication table of 7\n",
      "7 14 21 28 35 42 49 56 63 70 \n",
      "Multiplication table of 9\n",
      "9 18 27 36 45 54 63 72 81 90 \n"
     ]
    }
   ],
   "source": [
    "# Example 1: `continue` statement in outer loop\n",
    "\n",
    "for i in range(1, 11):\n",
    "    # condition to skip iteration\n",
    "    # Don't print multiplication table of even numbers\n",
    "    if i % 2 == 0:\n",
    "        continue\n",
    "    print('Multiplication table of', i)\n",
    "    for j in range(1, 11):\n",
    "        print(i * j, end=' ')\n",
    "    print('')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Explanation:**\n",
    "\n",
    "The outer loop iterates the first 10 numbers, and the internal loop prints the multiplication table of each number.\n",
    "\n",
    "But if the current number of the outer loop is even, then skip the current iteration of the outer loop and move to the next iteration.\n",
    "\n",
    ">**Note:** If we skip the current iteration of an outer loop, the inner loop will not be executed for that iteration because the inner loop is part of the body of an outer loop."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Catching exceptions with `continue` statement\n",
    "\n",
    "Sometimes it is desirable to deal with errors without stopping the whole program. This can be achieved using a **try** statement. Appart from dealing with with system errors, it also alows aborting from somewhere deep down in nested execution. It is possible to attach multiple error handlers depending on the type of the exception\n",
    "\n",
    "```python\n",
    "try:\n",
    "    code\n",
    "except <Exception Type> as <variable name>:\n",
    "    # deal with error of this type\n",
    "except:\n",
    "    # deal with any error\n",
    "finally:\n",
    "    # execute irrespective of whether an exception occured or not\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-12T16:09:14.039436Z",
     "start_time": "2021-06-12T16:09:14.025766Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Looping\n",
      "Looping\n",
      "Looping\n",
      "Looping\n",
      "Caught exception: abort\n",
      "All done\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    count=0\n",
    "    while True:\n",
    "        while True:\n",
    "            while True:\n",
    "                print(\"Looping\")\n",
    "                count = count + 1\n",
    "                if count > 3:\n",
    "                    raise Exception(\"abort\") # exit every loop or function\n",
    "                if count > 4:\n",
    "                    raise StopIteration(\"I'm bored\") # built in exception type\n",
    "except StopIteration as e:\n",
    "    print(\"Stopped iteration:\",e)\n",
    "except Exception as e: # this is where we go when an exception is raised\n",
    "    print(\"Caught exception:\",e)\n",
    "finally:\n",
    "    print(\"All done\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This can also be useful to handle unexpected system errors more gracefully:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-12T16:09:14.897340Z",
     "start_time": "2021-06-12T16:09:14.890500Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cannot calculate inverse because: float division by zero\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    for i in [2,1.5,0.0,3]:\n",
    "        inverse = 1.0/i\n",
    "except Exception as e: # no matter what exception\n",
    "    print(\"Cannot calculate inverse because:\", e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. Python `pass` statement\n",
    "\n",
    "In Python, **`pass`** keyword is used to execute **nothing**; it means, when we don't want to execute code, the pass can be used to execute empty. It is same as the name refers to. It just makes the control to pass by without executing any code. If we want to bypass any code pass statement can be used.\n",
    "\n",
    "It is used as a placeholder for future implementation of functions, loops, etc.\n",
    "\n",
    "Suppose we have a loop or a function that is not implemented yet, but we want to implement it in the future. They cannot have an empty body. The interpreter would give an error. So, we use the **`pass`** statement to construct a body that does nothing.\n",
    "\n",
    "### Example:\n",
    "\n",
    "```python\n",
    "'''pass is just a placeholder for\n",
    "functionality to be added later.'''\n",
    ">>> sequence = {'p', 'a', 's', 's'}\n",
    ">>> for val in sequence:\n",
    ">>>     pass\n",
    "```\n",
    "\n",
    "We can do the same thing in an empty **function** or **class** as well.\n",
    "\n",
    "```python\n",
    ">>> def function(args):\n",
    ">>>     pass\n",
    "```\n",
    "or\n",
    "```python\n",
    ">>> class Example:\n",
    ">>>    pass\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-12T16:09:17.500828Z",
     "start_time": "2021-06-12T16:09:17.481302Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['January', 'June', 'March', 'April']\n"
     ]
    }
   ],
   "source": [
    "# Example 1:\n",
    "\n",
    "months = ['January', 'June', 'March', 'April']\n",
    "for mon in months:\n",
    "    pass\n",
    "print(months)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-12T16:09:18.217623Z",
     "start_time": "2021-06-12T16:09:18.195650Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number is 1\n",
      "Number is 2\n",
      "Number is 3\n",
      "Number is 4\n",
      "Number is 5\n",
      "Number is 6\n",
      "Number is 7\n",
      "Number is 8\n",
      "Number is 9\n",
      "Number is 10\n",
      "Out of loop\n"
     ]
    }
   ],
   "source": [
    "# Example 2: Python Pass Statement\n",
    "\n",
    "number = 0\n",
    "\n",
    "for number in range(10):\n",
    "    number = number + 1\n",
    "    if number == 5:\n",
    "        pass   # pass here\n",
    "    print('Number is ' + str(number))\n",
    "print('Out of loop')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Explanation**:\n",
    "\n",
    "By using the **`pass`** statement in this program, we notice that the program runs exactly as it would if there were no conditional statement in the program. The **`pass`** statement tells the program to **disregard that condition** and **continue to run** the program as usual."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Control Statements in Python FAQs\n",
    "\n",
    "1. How many control statements are present in Python?\n",
    "> In Python, there are 3 types of control statements. Namely, break, continue and pass statements.\n",
    "\n",
    "2. How to break from a loop in Python?\n",
    ">The keyword break is used to break or terminate from the current loop. The control shifts to the next statement outside the loop.\n",
    "\n",
    "3. What is the difference between break and continue statements in Python?\n",
    ">Break statement exits out of the loop, but the continue statement shifts the control to the next iteration and doesn’t exit out of the loop.\n",
    "\n",
    "4. Can we use continue in if statement in Python?\n",
    ">Yes. Continue statements can be used within an if statement.\n",
    "\n",
    "5. What is the use of pass keyword in Python?\n",
    ">Pass keyword helps in avoiding errors that result due to an empty loop."
   ]
  }
 ],
 "metadata": {
  "hide_input": false,
  "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.8"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "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": 2
}