006_Python_while_Loop.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": [
    "# Loops in Python\n",
    "\n",
    "Loops in Python programming function similar to loops in C, C++, Java or other languages. Python loops are used to repeatedly execute a block of statements until a given condition returns to be **`False`**. In Python, we have **two types of looping statements**, namely:\n",
    "<div>\n",
    "<img src=\"img/loop1.png\" width=\"200\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python `while` Loop\n",
    "\n",
    "Loops are used in programming to repeat a specific block of code. In this article, you will learn to create a **`while`** loop in Python. We use a **`while`** loop when we want to repeat a code block."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What is `while` loop in Python?\n",
    "\n",
    "The **`while`** loop in Python is used to iterate over a block of code as long as the  expression/condition is **`True`**. When the condition becomes **`False`**, execution comes out of the loop immediately, and the first statement after the **`while`** loop is executed.\n",
    "\n",
    "We generally use this loop when we don't know the number of times to iterate beforehand.\n",
    "\n",
    "Python interprets any non-zero value as **`True`**. **`None`** and **`0`** are interpreted as **`False`**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Why and When to use `while` loop in Python\n",
    "\n",
    "Now, the question might arise: when do we use a **`while`** loop, and why do we use it.\n",
    "\n",
    "* **Automate and repeat tasks:** As we know, **`while`** loops execute blocks of code over and over again until the condition is met it allows us to automate and repeat tasks in an efficient manner.\n",
    "* **Indefinite Iteration:**The **`while`** loop will run as often as necessary to complete a particular task. When the user doesn’t know the number of iterations before execution, **`while`** loop is used instead of a **[for loop](https://github.com/milaan9/03_Python_Flow_Control/blob/main/005_Python_for_Loop.ipynb)** loop\n",
    "* **Reduce complexity:** **`while`** loop is easy to write. using the loop, we don’t need to write the statements again and again. Instead, we can write statements we wanted to execute again and again inside the body of the loop thus, reducing the complexity of the code\n",
    "* **Infinite loop:** If the code inside the **`while`** loop doesn’t modify the variables being tested in the loop condition, the loop will run forever."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Syntax: \n",
    "\n",
    "```python\n",
    "while condition:\n",
    "    body of while loop\n",
    "```\n",
    "1. In the **`while`** loop, expression/condition is checked first.\n",
    "2. The body of the loop is entered only if the expression/condition evaluates to **`True`**.\n",
    "3. After one iteration, the expression/condition is checked again. This process continues until the test_expression evaluates to **`False`**.\n",
    "\n",
    "<div>\n",
    "<img src=\"img/wh0.png\" width=\"400\"/>\n",
    "</div>\n",
    "\n",
    ">**Note:** An infinite loop occurs when a program keeps executing within one loop, never leaving it. To exit out of infinite loops on the command line, press **CTRL + C**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:15:18.052046Z",
     "start_time": "2021-10-04T12:15:18.041303Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "# Example 1: Print numbers less than 5\n",
    "\n",
    "count = 1\n",
    "# run loop till count is less than 5\n",
    "while count < 5:\n",
    "    print(count)\n",
    "    count = count + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:15:18.175091Z",
     "start_time": "2021-10-04T12:15:18.059861Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sum of first 10 number is: 55\n"
     ]
    }
   ],
   "source": [
    "# Example 2:\n",
    "\n",
    "num = 10\n",
    "sum = 0\n",
    "i = 1\n",
    "while i <= num:\n",
    "    sum = sum + i\n",
    "    i = i + 1\n",
    "print(\"Sum of first 10 number is:\", sum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:15:18.297648Z",
     "start_time": "2021-10-04T12:15:18.178999Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Value of a is 10\n",
      "Value of a is 8\n",
      "Value of a is 6\n",
      "Value of a is 4\n",
      "Value of a is 2\n",
      "Loop is Completed\n"
     ]
    }
   ],
   "source": [
    "# Example 3:\n",
    "\n",
    "a=10        # 'a' is my variable\n",
    "\n",
    "while a>0:  # Enter the body of while loop because condition is TRUE\n",
    "    print ((\"Value of a is\"),a)\n",
    "    a=a-2\n",
    "print (\"Loop is Completed\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:15:18.406047Z",
     "start_time": "2021-10-04T12:15:18.307417Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9.999999999999998\n"
     ]
    }
   ],
   "source": [
    "# Example 4:\n",
    "\n",
    "n=153\n",
    "sum=0\n",
    "\n",
    "while n>0:\n",
    "    r=n%10   # r is the remainder of the division\n",
    "    sum+=r   # sum+=r is equal to sum = sum+r\n",
    "    n=n/10\n",
    "print (sum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:15:18.559855Z",
     "start_time": "2021-10-04T12:15:18.409468Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total iteration required 3\n"
     ]
    }
   ],
   "source": [
    "# Example 5: How many times a given number can be divided by 3 before it is less than or equal to 10.\n",
    "\n",
    "count = 0\n",
    "number = 180\n",
    "while number > 10:\n",
    "    # divide number by 3\n",
    "    number = number / 3\n",
    "    # increase count\n",
    "    count = count + 1\n",
    "print('Total iteration required', count)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:15:18.747846Z",
     "start_time": "2021-10-04T12:15:18.565720Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The sum is 55\n"
     ]
    }
   ],
   "source": [
    "# Example 6: Program to add natural numbers up to sum = 1+2+3+...+n\n",
    "\n",
    "# To take input from the user, \n",
    "# n = int(input(\"Enter n: \"))\n",
    "\n",
    "n = 10\n",
    "\n",
    "# initialize sum and counter\n",
    "sum = 0\n",
    "i = 1\n",
    "\n",
    "while i <= n:\n",
    "    sum = sum + i\n",
    "    i = i+1    # update counter, i.e., the value of i will change from 1 to 2 in next iteration...\n",
    "\n",
    "# print the sum\n",
    "print(\"The sum is\", sum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Explanation:**\n",
    "\n",
    "In the above program, the test expression will be **`True`** as long as our counter variable **`i`** is less than or equal to **`n`** (10 in our program).\n",
    "\n",
    "We need to increase the value of the counter variable in the body of the loop. This is very important (and mostly forgotten). Failing to do so will result in an infinite loop (never-ending loop).\n",
    "\n",
    "Finally, the result is displayed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:15:18.913373Z",
     "start_time": "2021-10-04T12:15:18.751753Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 \n"
     ]
    }
   ],
   "source": [
    "# Example 7: simple fibonacci series\n",
    "# the sum of two elements defines the next set\n",
    "\n",
    "a, b = 0, 1\n",
    "while b < 1000:\n",
    "    print(b, end = ' ', flush = True)\n",
    "    a, b = b, a + b\n",
    "\n",
    "print() # line ending"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `while` loop with `if-else`\n",
    "\n",
    "A **`while`** loop can have an optional **[if-else](https://github.com/milaan9/03_Python_Flow_Control/blob/main/002_Python_if_else_statement.ipynb)** block. We use **`if-else`** statement in the loop when conditional iteration is needed. i.e., If the condition is **`True`**, then the statements inside the if block will execute othwerwise, the else block will execute."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:15:26.656062Z",
     "start_time": "2021-10-04T12:15:18.916304Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please Enter Number 9\n",
      "9 is a odd number\n",
      "8 is a even number\n",
      "7 is a odd number\n",
      "6 is a even number\n",
      "5 is a odd number\n",
      "4 is a even number\n",
      "3 is a odd number\n",
      "2 is a even number\n",
      "1 is a odd number\n"
     ]
    }
   ],
   "source": [
    "# Example 1: Print even and odd numbers between 1 to the entered number.\n",
    "\n",
    "n = int(input('Please Enter Number '))\n",
    "while n > 0:\n",
    "    # check even and odd\n",
    "    if n % 2 == 0:\n",
    "        print(n, 'is a even number')\n",
    "    else:\n",
    "        print(n, 'is a odd number')\n",
    "    # decrease number by 1 in each iteration\n",
    "    n = n - 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:15:26.671686Z",
     "start_time": "2021-10-04T12:15:26.660944Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "9\n",
      "4\n",
      "25\n",
      "6\n",
      "49\n",
      "8\n",
      "81\n"
     ]
    }
   ],
   "source": [
    "# Example 2: printing the square of odd numbers less than n. \n",
    "\n",
    "n =10\n",
    "i = 1\n",
    "while i < n:\n",
    "    #if (i % 2 == 0): (for even numbers)\n",
    "    if (i % 2 != 0):\n",
    "        print(i ** 2)\n",
    "        i = i + 1\n",
    "    else:\n",
    "        print(i)\n",
    "        i = i + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:15:26.858208Z",
     "start_time": "2021-10-04T12:15:26.674614Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The sum is 30\n"
     ]
    }
   ],
   "source": [
    "# Example 3: Add all even numbers from 1 to 10 using while loop\n",
    "# 2+4+6+8+10\n",
    "\n",
    "# n = int(input(\"Please enter the maximum value: \"))\n",
    "n = 10\n",
    "\n",
    "sum = 0\n",
    "i = 1\n",
    "\n",
    "while i <= n:\n",
    "    if(i%2==0):\n",
    "        sum = sum + i\n",
    "#        sum += i\n",
    "    i = i+1\n",
    "    \n",
    "# print the sum\n",
    "print(\"The sum is\", sum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:15:26.980277Z",
     "start_time": "2021-10-04T12:15:26.866021Z"
    },
    "code_folding": [],
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "17\n",
      "19\n",
      "23\n",
      "29\n",
      "31\n",
      "37\n",
      "41\n",
      "43\n",
      "47\n",
      "53\n",
      "The total sum is 340\n"
     ]
    }
   ],
   "source": [
    "# Example 4: Write a code to add all the prime numbers between 17 to 53 using while loop\n",
    "# 17, 19, 23, 29, 31, 37, 41, 43, 47, 53\n",
    "\n",
    "'''Method 1'''\n",
    "\n",
    "sum=0\n",
    "for i in range(17,54):\n",
    "    k=2\n",
    "    if i>=2:\n",
    "        while i % k!=0:\n",
    "            k+=1\n",
    "        if i==k:\n",
    "            sum += i\n",
    "            print(i)\n",
    "print(\"The total sum is\",sum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `while` loop with `else`\n",
    "\n",
    "A **`while`** loop can have an optional **`else`** block as well. The **`else`** part is executed if the condition in the **`while`** loop evaluates to **`False`**.\n",
    "\n",
    "The **`else`** will be skipped/ignored when:\n",
    "\n",
    "* **`while`** loop terminates abruptly\n",
    "* The **[break statement](https://github.com/milaan9/03_Python_Flow_Control/blob/main/007_Python_break_continue_pass_statements.ipynb)** is used to break the **`while`** loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:15:27.086726Z",
     "start_time": "2021-10-04T12:15:26.983211Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "count = 0\n",
    "while count < 5:\n",
    "    print(count)\n",
    "    count = count + 1\n",
    "else:\n",
    "    print(count)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Explanation:**\n",
    "\n",
    "The above loop condition will be false when count is 5 and the loop stops, and execution starts the else statement. As a result 5 will be printed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:15:27.224424Z",
     "start_time": "2021-10-04T12:15:27.091608Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "Done. 'while loop' executed normally\n"
     ]
    }
   ],
   "source": [
    "# Example 1: Use while loop to print numbers from 1 to 6\n",
    "\n",
    "i = 1\n",
    "while i <= 6:\n",
    "    print(i)\n",
    "    i = i + 1\n",
    "else:\n",
    "    print(\"Done. 'while loop' executed normally\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:15:27.378230Z",
     "start_time": "2021-10-04T12:15:27.231258Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "# Example 2: Else block with break statement in a while loop.\n",
    "\n",
    "i = 1\n",
    "while i <= 6:\n",
    "    print(i)\n",
    "    if i == 3:\n",
    "        break\n",
    "    i = i + 1\n",
    "else:\n",
    "    print(\"Done. `while loop` executed normally\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:15:27.503719Z",
     "start_time": "2021-10-04T12:15:27.383113Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Inside while loop\n",
      "Inside while loop\n",
      "Inside while loop\n",
      "Inside else\n"
     ]
    }
   ],
   "source": [
    "# Example 3:\n",
    "'''Example to illustrate the use of else statement with the while loop'''\n",
    "\n",
    "counter = 0  # counter is my variable\n",
    "\n",
    "while counter < 3:\n",
    "    print(\"Inside while loop\")\n",
    "    counter = counter + 1  # increment the counter\n",
    "else:\n",
    "    print(\"Inside else\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Explanation:**\n",
    "\n",
    "Here, we use a **`counter`** variable to print the string **`Inside loop`** three times.\n",
    "\n",
    "On the fourth iteration, the condition in **`while`** becomes **`False`**. Hence, the **`else`** part is executed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:15:34.325991Z",
     "start_time": "2021-10-04T12:15:27.507624Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter any number between 100 and 600 555\n",
      "Given Number is correct 555\n"
     ]
    }
   ],
   "source": [
    "# Example 4: we want a user to enter any number between 100 and 600\n",
    "\n",
    "number = int(input('Enter any number between 100 and 600 '))\n",
    "# number greater than 100 and less than 600\n",
    "while number < 100 or number > 600:\n",
    "    print('Incorrect number, Please enter correct number:')\n",
    "    number = int(input('Enter a Number between 100 and 600 '))\n",
    "else:\n",
    "    print(\"Given Number is correct\", number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using Control Statement in `while` loops in Python\n",
    "\n",
    "**[Control statements](https://github.com/milaan9/03_Python_Flow_Control/blob/main/007_Python_break_continue_pass_statements.ipynb)** in Python like **`break`**, **`continue`**, etc can be used to control the execution flow of **`while`** loop in Python. Let us now understand how this can be done.\n",
    "\n",
    "It is used when you want to exit a loop or skip a part of the loop based on the given condition. It also knows as **transfer statements**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### a) `break` in `while` loop\n",
    "\n",
    "Using the **`break`** statement, we can exit from the **`while`** loop even if the condition is **`True`**. \n",
    "\n",
    "If the **`break`** statement is used inside a nested loop (loop inside another loop), it will terminate the innermost loop. For example,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:15:34.341618Z",
     "start_time": "2021-10-04T12:15:34.327947Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "# Example 1:\n",
    "\n",
    "count = 0\n",
    "while count < 5:\n",
    "    print(count)\n",
    "    count = count + 1\n",
    "    if count == 3:\n",
    "        break       "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Explanation**: \n",
    "\n",
    "Here, the **`while`** loop runs until the value of the variable **`i`** is less than 5. But because of the **`break`** statement, the loop gets terminated when the value of the variable **`i`** is 3 and it prints 0, 1, 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:15:34.485175Z",
     "start_time": "2021-10-04T12:15:34.343572Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "60\n",
      "HelloWorld\n",
      "90.45\n"
     ]
    }
   ],
   "source": [
    "# Example 2:\n",
    "\n",
    "list = [60, \"HelloWorld\", 90.45, 50, 67.23, \"Python\"]  # total 6 elements\n",
    "i = 0\n",
    "while(i < 6):\n",
    "    print(list[i])\n",
    "    i = i + 1\n",
    "    if(i == 3):\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Explanation**: \n",
    "\n",
    "Here, the **`while`** loop runs until the value of the variable **`i`** is less than 6. But because of the **`break`** statement, the loop gets terminated when the value of the variable **`i`** is 3."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:15:34.639958Z",
     "start_time": "2021-10-04T12:15:34.504703Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A l a n "
     ]
    }
   ],
   "source": [
    "# Example 3: Display each character from a string and if `a` character is number then stop the loop.\n",
    "\n",
    "name = 'Alan99White'\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 number\n",
    "    if name[i].isdecimal():\n",
    "        break;\n",
    "    # print current character\n",
    "    print(name[i], end=' ')\n",
    "    i = i + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### b) `continue` in while loop\n",
    "\n",
    "The **`continue`** statement is used to stop/skip the block of code in the loop for the current iteration only and continue with the next iteration. \n",
    "\n",
    "For example, let's say you want to print all the odd numbers less than a particular value. Here is how you can do it using **`continue`** keyword in Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:15:43.254714Z",
     "start_time": "2021-10-04T12:15:34.653630Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-20-7359b7dba965>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[1;32mwhile\u001b[0m \u001b[0mcount\u001b[0m \u001b[1;33m<\u001b[0m \u001b[1;36m5\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m     \u001b[1;32mif\u001b[0m \u001b[0mcount\u001b[0m \u001b[1;33m==\u001b[0m \u001b[1;36m3\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 6\u001b[1;33m         \u001b[1;32mcontinue\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      7\u001b[0m     \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      8\u001b[0m         \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mcount\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "# Example 1:\n",
    "\n",
    "count = 0\n",
    "while count < 5:\n",
    "    if count == 3:\n",
    "        continue        \n",
    "    else:\n",
    "        print(count)\n",
    "        count = count + 1        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Explanation:**\n",
    "\n",
    "The above **`while`** loop only prints 0, 1, 2 and 4 (skips 3)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:15:48.259605Z",
     "start_time": "2021-10-04T12:15:48.244468Z"
    },
    "code_folding": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n",
      "5\n",
      "7\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "# Example 2: printing odd numbers less than `n`\n",
    "\n",
    "n=10\n",
    "i = 1\n",
    "while (i < n):\n",
    "    if (i % 2 == 0):\n",
    "        i = i + 1\n",
    "        continue  # continue means skip the current loop\n",
    "    else:\n",
    "        print (i)\n",
    "        i = i + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Explanation:**\n",
    "\n",
    "Here, the **`continue`** statement gets executed when the value of the variable is an even number. This simply means, whenever it is an even number, we simply skip all other statements and execute the next iteration."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:15:49.635581Z",
     "start_time": "2021-10-04T12:15:49.620932Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A l a n W h i t e "
     ]
    }
   ],
   "source": [
    "# Example 3: Write a while loop to display only alphabets from a string.\n",
    "\n",
    "name = 'Alan99White'\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 while loop body if current character is not alphabet\n",
    "    if not name[i].isalpha():\n",
    "        continue\n",
    "    # print current character\n",
    "    print(name[i], end=' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### c) `pass` in `while` loop\n",
    "\n",
    "The **`pass`** statement is a null statement, i.e., nothing happens when the statement is executed. Primarily it is used in empty functions or classes. When the interpreter finds a pass statement in the program, it returns no operation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:15:50.622885Z",
     "start_time": "2021-10-04T12:15:50.610197Z"
    }
   },
   "outputs": [],
   "source": [
    "# Example 1:\n",
    "\n",
    "n = 4\n",
    "while n > 0:\n",
    "    n = n - 1\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reverse `while` loop\n",
    "\n",
    "A reverse loop means an iterating loop in the backward direction. A simple example includes:\n",
    "\n",
    "* Display numbers from 10 to 1.\n",
    "* Reverse a string or list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:15:52.550625Z",
     "start_time": "2021-10-04T12:15:52.539885Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 9 8 7 6 5 4 3 2 1 0 "
     ]
    }
   ],
   "source": [
    "# Example 1: Reverse a while loop to display numbers from 10 to 1\n",
    "\n",
    "# reverse while loop\n",
    "i = 10\n",
    "while i >= 0:\n",
    "    print(i, end=' ')\n",
    "    i = i - 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Nested `while` loops\n",
    "\n",
    "**Nested while loop** is a **`while`** loop inside another **`while`** a loop. \n",
    "\n",
    "In the nested **`while`** loop, the number of iterations will be equal to the number of iterations in the outer loop multiplied by the iterations in the inner loop. In each iteration of the outer loop inner loop execute all its iteration.\n",
    "\n",
    "**Syntax:**\n",
    "\n",
    "```python\n",
    "while expression:\n",
    "    while expression:\n",
    "        statement(s)\n",
    "    statement(s)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `while` loop inside `while` loop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Example: Nested `while` loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:15:53.847500Z",
     "start_time": "2021-10-04T12:15:53.826996Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12345678910\n",
      "12345678910\n",
      "12345678910\n"
     ]
    }
   ],
   "source": [
    "# Example: print the first 10 numbers on each line 5 times\n",
    "\n",
    "i = 1\n",
    "while i <= 3:\n",
    "    j = 1\n",
    "    while j <= 10:\n",
    "        print(j, end='')\n",
    "        j = j + 1\n",
    "    i = i + 1\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Example: Nested `while` loop to print the pattern\n",
    "\n",
    "```python\n",
    "*\n",
    "* *\n",
    "* * *\n",
    "* * * *\n",
    "* * * * *\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:15:54.568693Z",
     "start_time": "2021-10-04T12:15:54.547213Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "* \n",
      "* * \n",
      "* * * \n",
      "* * * * \n",
      "* * * * * \n"
     ]
    }
   ],
   "source": [
    "# Example 1: Method 1\n",
    "\n",
    "i = 1\n",
    "# outer while loop\n",
    "# 5 rows in pattern\n",
    "while i < 6:\n",
    "    j = 0\n",
    "    # nested while loop\n",
    "    while j < i:\n",
    "        print('*', end=' ')\n",
    "        j = j + 1\n",
    "    # end of nested while loop\n",
    "    # new line after each row\n",
    "    print('')\n",
    "    i = i + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `for` loop inside `while` loop\n",
    "\n",
    "We can also use **[for loop](https://github.com/milaan9/03_Python_Flow_Control/blob/main/005_Python_for_Loop.ipynb)** inside a **`while`** loop as a nested loop. For example, "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:15:55.309907Z",
     "start_time": "2021-10-04T12:15:55.290378Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "* \n",
      "* * \n",
      "* * * \n",
      "* * * * \n",
      "* * * * * \n"
     ]
    }
   ],
   "source": [
    "# Example 1: Method 2\n",
    "\n",
    "i = 1\n",
    "# outer while loop\n",
    "while i < 6:\n",
    "    # nested for loop\n",
    "    for j in range(1, i + 1):\n",
    "        print(\"*\", end=\" \")\n",
    "    print('')\n",
    "    i = i + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:15:55.725921Z",
     "start_time": "2021-10-04T12:15:55.702486Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "17\n",
      "19\n",
      "23\n",
      "29\n",
      "31\n",
      "37\n",
      "41\n",
      "43\n",
      "47\n",
      "53\n",
      "The total sum is 340\n"
     ]
    }
   ],
   "source": [
    "# Example 2: Write a code to add all the prime numbers between 17 to 53 using while loop\n",
    "# 17, 19, 23, 29, 31, 37, 41, 43, 47, 53\n",
    "\n",
    "'''Method 1'''\n",
    "\n",
    "n=17\n",
    "sum=0\n",
    "while n<=53:\n",
    "    for i in range(2,n):\n",
    "        if(n % i)== 0: \n",
    "            break\n",
    "        else:\n",
    "            i=i+1\n",
    "    else:\n",
    "        sum=sum+n\n",
    "        print(n)\n",
    "    n=n+1\n",
    "print(\"The total sum is\",sum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:15:56.062835Z",
     "start_time": "2021-10-04T12:15:56.043797Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Show Perfect number fom 1 to 100\n",
      "Perfect number: 6\n",
      "Perfect number: 28\n"
     ]
    }
   ],
   "source": [
    "# Example 3:\n",
    "\n",
    "print('Show Perfect number fom 1 to 100')\n",
    "n = 2\n",
    "\n",
    "while n <= 100:            # outer while loop\n",
    "    x_sum = 0    \n",
    "    for i in range(1, n):  # inner for loop\n",
    "        if n % i == 0:\n",
    "            x_sum += i\n",
    "    if x_sum == n:\n",
    "        print('Perfect number:', n)\n",
    "    n += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iterate String using `while` loop\n",
    "\n",
    "By looping through the **[string](https://github.com/milaan9/02_Python_Datatypes/blob/main/002_Python_String.ipynb)** using **`while`** loop, we can do lots of string operations. For example,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:15:56.695654Z",
     "start_time": "2021-10-04T12:15:56.675146Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A\n",
      "l\n",
      "a\n",
      "n\n"
     ]
    }
   ],
   "source": [
    "# Example 1: while loop to iterate string letter by letter\n",
    "\n",
    "name = \"Alan\"\n",
    "i = 0\n",
    "res = len(name) - 1\n",
    "while i <= res:\n",
    "    print(name[i])\n",
    "    i = i + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iterate List using `while` loop\n",
    "\n",
    "**[Python list](https://github.com/milaan9/02_Python_Datatypes/blob/main/003_Python_List.ipynb)**  is an ordered collection of items of different data types. It means Lists are ordered by index numbers starting from 0 to the total items-1. List items are enclosed in square **`[]`** brackets.\n",
    "\n",
    "Below are the few examples of Python list.\n",
    "\n",
    "```python\n",
    ">>> numers = [1,2,4,6,7]\n",
    ">>> players = [\"Messi\", \"Ronaldo\", \"Neymar\"]\n",
    "```\n",
    "Using a loop, we can perform various operations on the list. There are ways to iterate through elements in it. Here are some examples to help you understand better."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:15:57.403172Z",
     "start_time": "2021-10-04T12:15:57.389503Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "6\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "# Example 1: Use while loop to iterate over a list.\n",
    "\n",
    "numbers = [1, 2, 3, 6, 9]\n",
    "size = len(numbers)\n",
    "i = 0\n",
    "while i < size:\n",
    "    print(numbers[i])\n",
    "    i = i + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:15:58.048679Z",
     "start_time": "2021-10-04T12:15:58.029154Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "60\n",
      "HelloWorld\n"
     ]
    }
   ],
   "source": [
    "# Example 2: printing the first two elements of a list\n",
    "\n",
    "list = [60, \"HelloWorld\", 90.96]  # list with three elements\n",
    "i = 0\n",
    "while(i < 2):\n",
    "    print (list[i]) #printing the element in the index i\n",
    "    i = i + 1   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ">**Note**: When working with the **`while`** loop, it is important to declare the indexing variable **`i`** beforehand and to increment the indexing variable accordingly. Else it will result in an infinite loop."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iterate Numbers using `while` loop\n",
    "\n",
    "Now, consider a program where you want to print out the squares of all the **[numbers](https://github.com/milaan9/02_Python_Datatypes/blob/main/001_Python_Numbers.ipynb)** less a particular number. Let's see how this works with a while statement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:15:59.143411Z",
     "start_time": "2021-10-04T12:15:59.132670Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "4\n",
      "9\n",
      "16\n",
      "25\n",
      "36\n",
      "49\n",
      "64\n",
      "81\n",
      "100\n"
     ]
    }
   ],
   "source": [
    "# Example 1: printing the square of numbers less than `n`\n",
    "\n",
    "i = 1\n",
    "while (i <= 10):\n",
    "    print (i ** 2) #printing the element in the index i\n",
    "    i = i + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:15:59.452490Z",
     "start_time": "2021-10-04T12:15:59.431010Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "8\n",
      "27\n",
      "64\n",
      "125\n",
      "216\n",
      "343\n",
      "512\n",
      "729\n"
     ]
    }
   ],
   "source": [
    "# Example 2: Find the cube of number from 1 to 9.\n",
    "\n",
    "i = 1\n",
    "while(i<10):\n",
    "    print(i*i*i)\n",
    "#   print(i**3)\n",
    "    i=i+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:15:59.835791Z",
     "start_time": "2021-10-04T12:15:59.816265Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "4\n",
      "Loop over\n"
     ]
    }
   ],
   "source": [
    "# Example 3:\n",
    "\n",
    "i = 1\n",
    "while i < 3:\n",
    "    print(i ** 2)\n",
    "    i = i+1\n",
    "print('Loop over')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## While loop in Python FAQs\n",
    "\n",
    "\n",
    "1. A while loop in python is used for what type of iteration?\n",
    "> A while loop is ideal for iteration when the number of iterations is not known. Also, it is ideal to use a while loop when you have a condition that needs to be satisfied.\n",
    "\n",
    "\n",
    "2. Why does infinite while loop occur in Python?\n",
    "> A loop becomes an infinite loop if the while condition never becomes FALSE. Such a loop that never terminates is called an infinite loop.\n",
    "\n",
    "\n",
    "3. Is there a do...while loop in Python?\n",
    ">No. There is no do while loop in Python.\n",
    "\n",
    "\n",
    "4. How do you break a while loop in Python?\n",
    ">Usually, the control shifts out of the while loop when the while condition is no False. Or you can use various control statements like break, continue, etc to break out of the while loop or break of the particular iteration of the while loop.\n",
    "\n",
    "\n",
    "5. How to write an empty while function in Python?\n",
    ">You can write an empty while function in Python using the pass statements. Here is how you can write it.\n",
    "\n",
    "```python\n",
    "#empty while statement in python\n",
    ">>> i = 0\n",
    ">>> while (i < 10) :\n",
    ">>>     pass\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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
}