005_Python_for_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 `for` Loop\n",
    "\n",
    "In this class, you'll learn to iterate over a sequence of elements using the different variations of **`for`** loop. We use a **`for`** loop when we want to repeat a code block for a **fixed number of times**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What is `for` loop in Python? \n",
    "\n",
    "The for loop in Python is used to iterate over a sequence (**[string](https://github.com/milaan9/02_Python_Datatypes/blob/main/002_Python_String.ipynb)**, **[list](https://github.com/milaan9/02_Python_Datatypes/blob/main/003_Python_List.ipynb)**, **[dictionary](https://github.com/milaan9/02_Python_Datatypes/blob/main/005_Python_Dictionary.ipynb)**, **[set](https://github.com/milaan9/02_Python_Datatypes/blob/main/006_Python_Sets.ipynb)**, or **[tuple](https://github.com/milaan9/02_Python_Datatypes/blob/main/004_Python_Tuple.ipynb)**). Iterating over a sequence is called traversal."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Why use `for` loop?\n",
    "\n",
    "Let’s see the use **`for`** loop in Python.\n",
    "\n",
    "* **Definite Iteration:** When we know how many times we wanted to run a loop, then we use count-controlled loops such as **`for`** loops. It is also known as definite iteration. For example, Calculate the percentage of 50 students. here we know we need to iterate a loop 50 times (1 iteration for each student).\n",
    "* **Reduces the code’s complexity:** Loop repeats a specific block of code a fixed number of times. It reduces the repetition of lines of code, thus reducing the complexity of the code. Using **`for`** loops and while loops we can automate and repeat tasks in an efficient manner.\n",
    "* **Loop through sequences:** used for iterating over lists, strings, tuples, dictionaries, etc., and perform various operations on it, based on the conditions specified by the user."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Syntax :\n",
    "\n",
    "```python  \n",
    "for element in sequence:\n",
    "    body of for loop \n",
    "```\n",
    "\n",
    "1. First, **`element`** is the variable that takes the value of the item inside the sequence on each iteration.\n",
    "\n",
    "2. Second, all the **`statements`** in the body of the for loop are executed with the same value. The body of for loop is separated from the rest of the code using indentation.\n",
    "\n",
    "3. Finally, loop continues until we reach the last item in the **`sequence`**. The body of for loop is separated from the rest of the code using indentation.\n",
    "\n",
    "<div>\n",
    "<img src=\"img/for0.png\" width=\"400\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:09:49.251313Z",
     "start_time": "2021-10-04T12:09:49.240575Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "one\n",
      "two\n",
      "three\n",
      "four\n",
      "five\n"
     ]
    }
   ],
   "source": [
    "# Example 1: For loop \n",
    "\n",
    "words = ['one', 'two', 'three', 'four', 'five']\n",
    "\n",
    "for i in words:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:09:49.282564Z",
     "start_time": "2021-10-04T12:09:49.259620Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30.0\n"
     ]
    }
   ],
   "source": [
    "# Example 2: Calculate the average of list of numbers\n",
    "\n",
    "numbers = [10, 20, 30, 40, 50]\n",
    "\n",
    "# definite iteration\n",
    "# run loop 5 times because list contains 5 items\n",
    "sum = 0\n",
    "for i in numbers:\n",
    "    sum = sum + i\n",
    "list_size = len(numbers)\n",
    "average = sum / list_size\n",
    "print(average)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `for` loop with `range()` function\n",
    "\n",
    "The **[range()](https://github.com/milaan9/04_Python_Functions/blob/main/002_Python_Functions_Built_in/053_Python_range%28%29.ipynb)** function returns a sequence of numbers starting from 0 (by default) if the initial limit is not specified and it increments by 1 (by default) until a final limit is reached.\n",
    "\n",
    "The **`range()`** function is used with a loop to specify the range (how many times) the code block will be executed. Let us see with an example.\n",
    "\n",
    "We can generate a sequence of numbers using **`range()`** function. **`range(5)`** will generate numbers from 0 to 4 (5 numbers). \n",
    "\n",
    "<div>\n",
    "<img src=\"img/forrange.png\" width=\"600\"/>\n",
    "</div>\n",
    "\n",
    "The **`range()`** function is \"lazy\" in a sense because it doesn't generate every number that it \"contains\" when we create it. However, it is not an iterator since it supports **[len()](https://github.com/milaan9/04_Python_Functions/blob/main/002_Python_Functions_Built_in/040_Python_len%28%29.ipynb)** and **`__getitem__`** operations.\n",
    "\n",
    "This **`range()`** function does not store all the values in memory; it would be inefficient. So it remembers the start, stop, step size and generates the next number on the go.\n",
    "\n",
    "We can also define the start, stop and step size as **`range(start, stop,step_size)`**. **`step_size`** defaults to 1 if not provided."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:09:49.435886Z",
     "start_time": "2021-10-04T12:09:49.292334Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n",
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "[1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "# Example 1: How range works in Python?\n",
    "\n",
    "# empty range\n",
    "print(list(range(0)))\n",
    "\n",
    "# using range(stop)\n",
    "print(list(range(10)))\n",
    "\n",
    "# using range(start, stop)\n",
    "print(list(range(1, 10)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:09:49.633639Z",
     "start_time": "2021-10-04T12:09:49.439794Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "# Example 2:\n",
    "\n",
    "for num in range(10):\n",
    "    print(num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:09:49.908542Z",
     "start_time": "2021-10-04T12:09:49.640473Z"
    },
    "scrolled": false
   },
   "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": [
    "# Example 3:\n",
    "\n",
    "for i in range(1, 11):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:09:50.137547Z",
     "start_time": "2021-10-04T12:09:49.913425Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "4\n",
      "6\n",
      "8\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "# Example 4:\n",
    "\n",
    "for i in range (2, 12, 2):  # beginning 2 with distance of 2 and stop before 12\n",
    "    print (i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:09:50.259614Z",
     "start_time": "2021-10-04T12:09:50.141453Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "4\n",
      "6\n",
      "8\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "# Example 5:\n",
    "\n",
    "num=2\n",
    "\n",
    "for a in range (1,6):  # range (1,6) means numbers from 1 to 5, i.e., (1,2,3,4,5)\n",
    "    print (num * a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:09:50.396821Z",
     "start_time": "2021-10-04T12:09:50.262548Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n",
      "6\n",
      "10\n",
      "15\n",
      "21\n",
      "28\n",
      "36\n",
      "45\n",
      "55\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'\\n0+1 = 1\\n1+2 = 3\\n3+3 = 6\\n6+4 = 10\\n10+5 =15\\n21\\n28\\n36\\n45\\n45+10 = 55\\n'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Example 6: Find Sum of 10 Numbers\n",
    "\n",
    "sum=0\n",
    "for n in range(1,11):  # range (1,11) means numbers from 1 to 5, i.e., (1,2,3,4,5,6,7,8,9,10)\n",
    "    sum+=n  \n",
    "    print (sum)\n",
    "    \n",
    "'''\n",
    "0+1 = 1\n",
    "1+2 = 3\n",
    "3+3 = 6\n",
    "6+4 = 10\n",
    "10+5 =15\n",
    "21\n",
    "28\n",
    "36\n",
    "45\n",
    "45+10 = 55\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:09:50.534518Z",
     "start_time": "2021-10-04T12:09:50.399756Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Case 1:\n",
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "Case 2:\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "Case 3:\n",
      "5\n",
      "7\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "# Example 7: printing a series of numbers using for and range\n",
    "\n",
    "print(\"Case 1:\")\n",
    "for i in range(5):  # Print numbers from 0 to 4\n",
    "    print (i)\n",
    "\n",
    "print(\"Case 2:\")  \n",
    "for i in range(5, 10):  # Print numbers from 5 to 9\n",
    "    print (i)\n",
    "\n",
    "print(\"Case 3:\")\n",
    "for i in range(5, 10, 2):  # Print numbers from 5 with distace 2 and stop before 10\n",
    "    print (i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `for` loop with `if-else`\n",
    "\n",
    "A **`for`** loop can have an optional **[if-else](https://github.com/milaan9/03_Python_Flow_Control/blob/main/002_Python_if_else_statement.ipynb)** block. The **`if-else`** checks the condition and if the condition is **`True`** it executes the block of code present inside the **`if`** block and if the condition is **`False`**, it will execute the block of code present inside the **`else`** block."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:09:50.657566Z",
     "start_time": "2021-10-04T12:09:50.539403Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Odd Number: 1\n",
      "Even Number: 2\n",
      "Odd Number: 3\n",
      "Even Number: 4\n",
      "Odd Number: 5\n",
      "Even Number: 6\n",
      "Odd Number: 7\n",
      "Even Number: 8\n",
      "Odd Number: 9\n",
      "Even Number: 10\n"
     ]
    }
   ],
   "source": [
    "# Example 1: Print all even and odd numbers\n",
    "\n",
    "for i in range(1, 11):\n",
    "    if i % 2 == 0:\n",
    "        print('Even Number:', i)\n",
    "    else:\n",
    "        print('Odd Number:', i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `for` loop with `else`\n",
    "\n",
    "A **`for`** loop can have an optional **`else`** block as well. The **`else`** part is executed if the items in the sequence used in for loop exhausts.\n",
    "\n",
    "**`else`** block will be skipped/ignored when:\n",
    "\n",
    "* **`for`** loop terminate 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 **`for`** loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:09:50.793310Z",
     "start_time": "2021-10-04T12:09:50.666842Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "5\n",
      "No items left.\n"
     ]
    }
   ],
   "source": [
    "# Example 1:\n",
    "\n",
    "digits = [0, 1, 5]\n",
    "\n",
    "for i in digits:\n",
    "    print(i)\n",
    "else:\n",
    "    print(\"No items left.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Explanation:**\n",
    "\n",
    "Here, the for loop prints items of the list until the loop exhausts. When the for loop exhausts, it executes the block of code in the **`else`** and prints **`No items left`**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:09:50.991550Z",
     "start_time": "2021-10-04T12:09:50.796727Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n",
      "The loop stops at 10\n"
     ]
    }
   ],
   "source": [
    "# Example 2:\n",
    "\n",
    "for number in range(11):\n",
    "    print(number)   # prints 0 to 10, not including 11\n",
    "else:\n",
    "    print('The loop stops at', number)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:09:51.159520Z",
     "start_time": "2021-10-04T12:09:50.996435Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "Done\n"
     ]
    }
   ],
   "source": [
    "# Example 3: Else block in for loop\n",
    "\n",
    "for i in range(1, 6):\n",
    "    print(i)\n",
    "else:\n",
    "    print(\"Done\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This **`for-else`** statement can be used with the **`break`** keyword to run the **`else`** block only when the **`break`** keyword was not executed. Let's take an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:09:51.312349Z",
     "start_time": "2021-10-04T12:09:51.162449Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No entry with that name found.\n"
     ]
    }
   ],
   "source": [
    "# Example 4:\n",
    "\n",
    "student_name = 'Arthur'\n",
    "\n",
    "marks = {'Alan': 99, 'Bill': 55, 'Cory': 77}\n",
    "\n",
    "for student in marks:\n",
    "    if student == student_name:\n",
    "        print(marks[student])\n",
    "        break\n",
    "else:\n",
    "    print('No entry with that name found.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:09:51.403663Z",
     "start_time": "2021-10-04T12:09:51.315770Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "# Example 5:\n",
    "\n",
    "count = 0\n",
    "for i in range(1, 6):\n",
    "    count = count + 1\n",
    "    if count > 2:\n",
    "        break\n",
    "    else:\n",
    "        print(i)\n",
    "else:\n",
    "    print(\"Done\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using Control Statement in `for` 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 **`for`** 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 `for` loop\n",
    "\n",
    "Using the **`break`** statement, we can exit from the **`for`** loop before it has looped through all the elements in the sequence as shown below. As soon as it breaks out of the **`for`** loop, the control shifts to the immediate next line of code. For example,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:09:51.556493Z",
     "start_time": "2021-10-04T12:09:51.407569Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "# Example 1:\n",
    "\n",
    "numbers = (0,1,2,3,4,5)\n",
    "for number in numbers:\n",
    "    print(number)\n",
    "    if number == 3:\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Explanation:**\n",
    "\n",
    "In the above example, the loop stops when it reaches 3."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:09:51.709323Z",
     "start_time": "2021-10-04T12:09:51.561377Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pink\n"
     ]
    }
   ],
   "source": [
    "# Example 2:\n",
    "\n",
    "color = ['Green', 'Pink', 'Blue']\n",
    "for i in color:\n",
    "    if(i == 'Pink'):\n",
    "        break\n",
    "print (i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Explanation:**\n",
    "\n",
    "Here, in the second iteration, the **`if`** condition becomes **`True`**. Hence the loop beaks out of the for loop and the immediate next line of code i.e **`print (i)`** is executed and as a result, pink is outputted."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:09:51.861668Z",
     "start_time": "2021-10-04T12:09:51.712254Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "4\n",
      "7\n",
      "8\n",
      "15\n"
     ]
    }
   ],
   "source": [
    "# Example 3:\n",
    "\n",
    "numbers = [1, 4, 7, 8, 15, 20, 35, 45, 55]\n",
    "for i in numbers:\n",
    "    if i > 15:\n",
    "        # break the loop\n",
    "        break\n",
    "    else:\n",
    "        print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:09:52.014500Z",
     "start_time": "2021-10-04T12:09:51.870458Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 0\n",
      "2 0\n",
      "2 1\n",
      "3 0\n",
      "3 1\n",
      "3 2\n",
      "4 0\n",
      "4 1\n",
      "4 2\n",
      "4 3\n"
     ]
    }
   ],
   "source": [
    "# Example 4:\n",
    "\n",
    "for i in range(5):\n",
    "    for j in range(5):\n",
    "        if j == i:\n",
    "            break\n",
    "        print(i, j)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Explanation:**\n",
    "\n",
    "We have two loops. The outer **`for`** loop iterates the first four 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 inner **`for`** loop also iterates the first four numbers. If the outer number and a current number of the inner loop are the same, then break the inner (nested) loop."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### b) `continue` in `for` 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. For example,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:09:52.152683Z",
     "start_time": "2021-10-04T12:09:52.017432Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Blue\n"
     ]
    }
   ],
   "source": [
    "# Example 1:\n",
    "\n",
    "color = ['Green', 'Pink', 'Blue']\n",
    "for i in color:\n",
    "    if(i == 'Pink'):\n",
    "        continue\n",
    "print (i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Explanation:**\n",
    "\n",
    "Here, in the second iteration, the condition becomes **`True`**. Hence the interpreter skips the **`print (i)`** statement and immediately executes the next iteration."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:09:52.274755Z",
     "start_time": "2021-10-04T12:09:52.155615Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "Next number should be  1\n",
      "1\n",
      "Next number should be  2\n",
      "2\n",
      "Next number should be  3\n",
      "3\n",
      "4\n",
      "Next number should be  5\n",
      "5\n",
      "loop's end\n",
      "outside the loop\n"
     ]
    }
   ],
   "source": [
    "# Example 2:\n",
    "\n",
    "numbers = (0,1,2,3,4,5)\n",
    "for number in numbers:\n",
    "    print(number)\n",
    "    if number == 3:\n",
    "        continue\n",
    "    print('Next number should be ', number + 1) if number != 5 else print(\"loop's end\") # for short hand conditions need both if and else statements\n",
    "print('outside the loop')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Explanation:**\n",
    "\n",
    "In the example above, if the number equals 3, the step **after** the condition (but inside the loop) is skipped and the execution of the loop continues if there are any iterations left."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:09:52.366553Z",
     "start_time": "2021-10-04T12:09:52.277686Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 * 6 =  18\n",
      "3 * 9 =  27\n",
      "6 * 3 =  18\n",
      "6 * 9 =  54\n",
      "9 * 3 =  27\n",
      "9 * 6 =  54\n"
     ]
    }
   ],
   "source": [
    "# Example 3:\n",
    "\n",
    "first = [3, 6, 9]\n",
    "second = [3, 6, 9]\n",
    "for i in first:\n",
    "    for j in second:\n",
    "        if i == j:\n",
    "            continue\n",
    "        print(i, '*', j, '= ', i * j)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Explanation:**\n",
    "\n",
    "We have two loops. The outer for loop iterates the first list, and the inner loop also iterates the second list of numbers. If the outer number and the inner loop’s current number are the same, then move to the next iteration of an inner loop.\n",
    "\n",
    "As you can see in the output, no same numbers multiplying to each other."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:09:52.488622Z",
     "start_time": "2021-10-04T12:09:52.369485Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total number of m is: 2\n"
     ]
    }
   ],
   "source": [
    "# Example 4:\n",
    "\n",
    "name = \"mariya mennen\"\n",
    "count = 0\n",
    "for char in name:\n",
    "    if char != 'm':\n",
    "        continue\n",
    "    else:\n",
    "        count = count + 1\n",
    "\n",
    "print('Total number of m is:', count)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### c) `pass` in `for` 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": 24,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:09:52.625830Z",
     "start_time": "2021-10-04T12:09:52.493506Z"
    }
   },
   "outputs": [],
   "source": [
    "# Example 1:\n",
    "\n",
    "for number in range(6):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:09:52.747899Z",
     "start_time": "2021-10-04T12:09:52.633640Z"
    }
   },
   "outputs": [],
   "source": [
    "# Example 2:\n",
    "\n",
    "num = [1, 4, 5, 3, 7, 8]\n",
    "for i in num:\n",
    "    # calculate multiplication in future if required\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reverse for loop\n",
    "\n",
    "Till now, we have learned about forward looping in **`for`** loop with various examples. Now we will learn about the backward iteration of a loop.\n",
    "\n",
    "Sometimes we require to do reverse looping, which is quite useful. For example, to reverse a list.\n",
    "\n",
    "There are three ways to iterating the **`for`** loop backward:\n",
    "\n",
    "* Reverse **`for`** loop using **[range()](https://github.com/milaan9/04_Python_Functions/blob/main/002_Python_Functions_Built_in/053_Python_range%28%29.ipynb)** function\n",
    "* Reverse **`for`** loop using the **[reversed()](https://github.com/milaan9/04_Python_Functions/blob/main/002_Python_Functions_Built_in/055_Python_reversed%28%29.ipynb)** function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Backward Iteration using the `reversed()` function\n",
    "\n",
    "We can use the built-in function **[reversed()](https://github.com/milaan9/04_Python_Functions/blob/main/002_Python_Functions_Built_in/055_Python_reversed%28%29.ipynb)** with **`for`** loop to change the order of elements, and this is the simplest way to perform a reverse looping."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:09:52.871924Z",
     "start_time": "2021-10-04T12:09:52.752784Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "40\n",
      "30\n",
      "20\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "# Example 1: Reversed numbers using `reversed()` function\n",
    "\n",
    "list1 = [10, 20, 30, 40]\n",
    "for num in reversed(list1):\n",
    "    print(num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reverse for loop using `range()`\n",
    "\n",
    "We can use the built-in **[range()](https://github.com/milaan9/04_Python_Functions/blob/main/002_Python_Functions_Built_in/053_Python_range%28%29.ipynb)** function with the **`for`** loop to reverse the elements order. The **`range()`** generates the integer numbers between the given start integer to the stop integer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:09:53.008641Z",
     "start_time": "2021-10-04T12:09:52.875832Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reverse numbers using for loop\n",
      "5\n",
      "4\n",
      "3\n",
      "2\n",
      "1\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "# Example 1:\n",
    "\n",
    "print(\"Reverse numbers using for loop\")\n",
    "num = 5\n",
    "# start = 5\n",
    "# stop = -1\n",
    "# step = -1\n",
    "for num in (range(num, -1, -1)):\n",
    "    print(num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are many helper functions that make **`for`** loops even more powerful and easy to use. For example **[enumerate()](https://github.com/milaan9/04_Python_Functions/blob/main/002_Python_Functions_Built_in/018_Python_enumerate%28%29.ipynb)**, **[zip()](https://github.com/milaan9/04_Python_Functions/blob/main/002_Python_Functions_Built_in/066_Python_zip%28%29.ipynb)**, **[sorted()](https://github.com/milaan9/04_Python_Functions/blob/main/002_Python_Functions_Built_in/060_Python_sorted%28%29.ipynb)**, **[reversed()](https://github.com/milaan9/04_Python_Functions/blob/main/002_Python_Functions_Built_in/055_Python_reversed%28%29.ipynb)**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:09:53.129735Z",
     "start_time": "2021-10-04T12:09:53.015969Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "reversed: \tc;b;a;\n",
      "enuemerated:\t0 = a; 1 = b; 2 = c; \n",
      "zip'ed: \n",
      "a : x\n",
      "b : y\n",
      "c : z\n"
     ]
    }
   ],
   "source": [
    "# Example 2:\n",
    "\n",
    "print(\"reversed: \\t\",end=\"\")\n",
    "for ch in reversed(\"abc\"):\n",
    "    print(ch,end=\";\")\n",
    "\n",
    "print(\"\\nenuemerated:\\t\",end=\"\")\n",
    "for i,ch in enumerate(\"abc\"):\n",
    "    print(i,\"=\",ch,end=\"; \")\n",
    "    \n",
    "print(\"\\nzip'ed: \")\n",
    "for a,x in zip(\"abc\",\"xyz\"):\n",
    "    print(a,\":\",x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Nested `for` loops\n",
    "\n",
    "**Nested `for` loop** is a **`for`** loop inside another **`for`** a loop. \n",
    "\n",
    "A nested loop has one loop inside of another. In Python, you can use any loop inside any other loop. For instance, a **`for`** loop inside a **[while loop](https://github.com/milaan9/03_Python_Flow_Control/blob/main/006_Python_while_Loop.ipynb)**, a **`while`** inside **`for`** in and so on. It is mainly used with two-dimensional arrays.\n",
    "\n",
    "In nested loops, the inner loop finishes all of its iteration for each iteration of the outer loop. i.e., For each iteration of the outer loop inner loop restart and completes all its iterations, then the next iteration of the outer loop begins.\n",
    "\n",
    "**Syntax:**\n",
    "\n",
    "```python\n",
    "# outer for loop\n",
    "for element in sequence \n",
    "   # inner for loop\n",
    "    for element in sequence:\n",
    "        body of inner for loop\n",
    "    body of outer for loop\n",
    "other statements\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `for` loop inside `for` loop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Example: Nested `for` loop \n",
    "\n",
    "In this example, we are using a **`for`** loop inside a **`for`** loop. In this example, we are printing a multiplication table of the first ten numbers.\n",
    "\n",
    "<div>\n",
    "<img src=\"img/nforloop1.png\" width=\"600\"/>\n",
    "</div>\n",
    "\n",
    "1. The outer **`for`** loop uses the **[range()](https://github.com/milaan9/04_Python_Functions/blob/main/002_Python_Functions_Built_in/053_Python_range%28%29.ipynb)** function to iterate over the first ten numbers\n",
    "2. The inner **`for`** loop will execute ten times for each outer number\n",
    "3. In the body of the inner loop, we will print the multiplication of the outer number and current number\n",
    "4. The inner loop is nothing but a body of an outer loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:09:53.208838Z",
     "start_time": "2021-10-04T12:09:53.132667Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 5 6 7 8 9 10 \n",
      "2 4 6 8 10 12 14 16 18 20 \n",
      "3 6 9 12 15 18 21 24 27 30 \n",
      "4 8 12 16 20 24 28 32 36 40 \n",
      "5 10 15 20 25 30 35 40 45 50 \n",
      "6 12 18 24 30 36 42 48 54 60 \n",
      "7 14 21 28 35 42 49 56 63 70 \n",
      "8 16 24 32 40 48 56 64 72 80 \n",
      "9 18 27 36 45 54 63 72 81 90 \n",
      "10 20 30 40 50 60 70 80 90 100 \n"
     ]
    }
   ],
   "source": [
    "# Example 1: printing a multiplication table of the first ten numbers\n",
    "\n",
    "# outer loop\n",
    "for i in range(1, 11):\n",
    "    # nested loop   \n",
    "    for j in range(1, 11):   # to iterate from 1 to 10        \n",
    "        print(i * j, end=' ')    # print multiplication\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Explanation:**\n",
    "\n",
    "* In this program, the outer **`for`** loop is iterate numbers from 1 to 10. The **`range()`** return 10 numbers. So total number of iteration of the outer loop is 10.\n",
    "* In the first iteration of the nested loop, the number is 1. In the next, it 2. and so on till 10.\n",
    "* Next, the inner loop will also execute ten times because we rea printing multiplication table up to ten. For each iteration of the outer loop, the inner loop will execute ten times.\n",
    "* In each iteration of an inner loop, we calculated the multiplication of two numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:09:53.312842Z",
     "start_time": "2021-10-04T12:09:53.211769Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python\n",
      "Matlab\n",
      "R\n",
      "C\n",
      "C++\n"
     ]
    }
   ],
   "source": [
    "# Example 1:\n",
    "\n",
    "person = {\n",
    "    'first_name':'Milaan',\n",
    "    'last_name':'Parmar',\n",
    "    'age':96,\n",
    "    'country':'Finland',\n",
    "    'is_marred':True,\n",
    "    'skills':['Python', 'Matlab', 'R', 'C', 'C++'],\n",
    "    'address':{\n",
    "        'street':'Space street',\n",
    "        'zipcode':'02210'\n",
    "    }\n",
    "}\n",
    "for key in person:\n",
    "    if key == 'skills':\n",
    "        for skill in person['skills']:\n",
    "            print(skill)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:09:53.465185Z",
     "start_time": "2021-10-04T12:09:53.315774Z"
    }
   },
   "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",
      "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",
    "sum=0\n",
    "for i in range(17,54):    \n",
    "    for j in range(2,i):        \n",
    "        if i%j ==0:            \n",
    "            break    \n",
    "    else:        \n",
    "        sum=sum+i\n",
    "        print(i)\n",
    "print(sum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:09:53.556006Z",
     "start_time": "2021-10-04T12:09:53.468116Z"
    },
    "code_folding": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Red flower\n",
      "Red watch\n",
      "Pink flower\n",
      "Pink watch\n"
     ]
    }
   ],
   "source": [
    "# Example 3: iterating through nested for loops\n",
    "\n",
    "color = ['Red', 'Pink']\n",
    "element = ['flower', 'watch']\n",
    "for i in color:\n",
    "    for j in element:\n",
    "        print(i, j)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:09:53.571631Z",
     "start_time": "2021-10-04T12:09:53.558938Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "45\n"
     ]
    }
   ],
   "source": [
    "# Example 4: A use case of a nested for loop in `list_of_lists` case would be\n",
    "\n",
    "list_of_lists = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
    "total=0\n",
    "for list1 in list_of_lists:\n",
    "    for i in list1:\n",
    "        total = total+i\n",
    "print(total)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:09:53.678564Z",
     "start_time": "2021-10-04T12:09:53.576026Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration 0: 1\n",
      "iteration 1: 2\n",
      "iteration 2: 3\n",
      "iteration 3: 4\n",
      "iteration 4: 5\n",
      "iteration 5: 6\n"
     ]
    }
   ],
   "source": [
    "# Example 5:\n",
    "\n",
    "numbers = [[1, 2, 3], [4, 5, 6]]\n",
    "\n",
    "cnt = 0\n",
    "for i in numbers:\n",
    "    for j in i:\n",
    "        print('iteration', cnt, end=': ')\n",
    "        print(j)\n",
    "        cnt = cnt + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Example: Nested `for` loop to print pattern\n",
    "\n",
    "```python\n",
    "*\n",
    "* *\n",
    "* * *\n",
    "* * * *\n",
    "* * * * *\n",
    "```\n",
    "\n",
    "```python\n",
    ">>>rows = 5\n",
    "   # outer loop\n",
    ">>>for i in range(1, rows + 1):\n",
    "       # inner loop\n",
    ">>>    for j in range(1, i + 1):\n",
    ">>>        print(\"*\", end=\" \")\n",
    ">>>    print('')\n",
    "```\n",
    "\n",
    "<div>\n",
    "<img src=\"img/nforloop2.png\" width=\"600\"/>\n",
    "</div>\n",
    "\n",
    "**Explanation:**\n",
    "\n",
    "* In this program, the outer loop is the number of rows print. \n",
    "* The number of rows is five, so the outer loop will execute five times\n",
    "* Next, the inner loop is the total number of columns in each row.\n",
    "* For each iteration of the outer loop, the columns count gets incremented by 1\n",
    "* In the first iteration of the outer loop, the column count is 1, in the next it 2. and so on.\n",
    "* The inner loop iteration is equal to the count of columns.\n",
    "* In each iteration of an inner loop, we print star"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:09:53.800634Z",
     "start_time": "2021-10-04T12:09:53.681496Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "* \n",
      "* * \n",
      "* * * \n",
      "* * * * \n",
      "* * * * * \n"
     ]
    }
   ],
   "source": [
    "# Example 1: Method 1\n",
    "\n",
    "rows = 5\n",
    "for i in range(1, rows + 1):    # outer loop    \n",
    "    for j in range(1, i + 1):   # inner loop\n",
    "        print(\"*\", end=\" \")\n",
    "    print('')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:10:19.154180Z",
     "start_time": "2021-10-04T12:09:53.805520Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "How many rows? 5\n",
      "* \n",
      "* * \n",
      "* * * \n",
      "* * * * \n",
      "* * * * * \n"
     ]
    }
   ],
   "source": [
    "# Example 1: Method 2 - Print Floyd Triangle with user input\n",
    "\t\t\n",
    "\n",
    "ran = input(\"How many rows? \")\n",
    "\n",
    "rang = int(ran)\n",
    "k = 1\n",
    "for i in range(1, rang+1):\n",
    "    for j in range(1, i+1):\n",
    "        print(\"*\", end=\" \")\n",
    "        k = k + 1\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:10:19.169316Z",
     "start_time": "2021-10-04T12:10:19.157142Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1  \n",
      "2 2  \n",
      "3 3 3  \n",
      "4 4 4 4  \n",
      "5 5 5 5 5  \n"
     ]
    }
   ],
   "source": [
    "# Example 2: Method 1\n",
    "\n",
    "for i in range(1,6):       # numbers from 0,1,2,3,4,5\n",
    "    for j in range(1, i+1):  \n",
    "        print(i, end=\" \")  # print number    \n",
    "    print(\" \")             # line after each row to display pattern correctly"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:10:19.338754Z",
     "start_time": "2021-10-04T12:10:19.171271Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " \n",
      "1  \n",
      "2 2  \n",
      "3 3 3  \n",
      "4 4 4 4  \n",
      "5 5 5 5 5  \n"
     ]
    }
   ],
   "source": [
    "# Example 2: Method 2\n",
    "\n",
    "rows = 6 \n",
    "for num in range(rows):     # from 0,1,2,3,4,5\n",
    "    for i in range(num):\n",
    "        print(num,end=\" \")  # print the number\n",
    "    print(\" \")              # line after each row to print"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:10:19.539923Z",
     "start_time": "2021-10-04T12:10:19.342658Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1  \n",
      "2 2  \n",
      "3 3 3  \n",
      "4 4 4 4  \n",
      "5 5 5 5 5  \n"
     ]
    }
   ],
   "source": [
    "# Example 3: Method 3\n",
    "\n",
    "n=5  # giving number of rows i want\n",
    "x = 0\n",
    "for i in range(0 , n):         # from 0 to 4\n",
    "    x += 1                     # equivalent to x=x+1\n",
    "    for j in range(0, i + 1):  # 0,1,2,3,4,5\n",
    "        print(x , end=\" \") \n",
    "    print(\" \") "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:10:19.693243Z",
     "start_time": "2021-10-04T12:10:19.549688Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1  \n",
      "1 2  \n",
      "1 2 3  \n",
      "1 2 3 4  \n",
      "1 2 3 4 5  \n"
     ]
    }
   ],
   "source": [
    "# Example 4: Method 1\n",
    "\n",
    "rows = 5\n",
    "for row in range(1, rows+1):       # from 1\n",
    "    for column in range(1, row+1): # from 1,2,3,4,5\n",
    "        print(column, end=\" \")\n",
    "    print(\" \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:10:19.953986Z",
     "start_time": "2021-10-04T12:10:19.699105Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 \n",
      "1 2 \n",
      "1 2 3 \n",
      "1 2 3 4 \n",
      "1 2 3 4 5 \n"
     ]
    }
   ],
   "source": [
    "# Example 4: Method 2\n",
    "\n",
    "for i in range (1, 6):  # rows from 1 to 5\n",
    "    for j in range(i):  # column range(i)\n",
    "        print (j + 1, end = ' ')\n",
    "    print ()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:10:20.121956Z",
     "start_time": "2021-10-04T12:10:19.956919Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1  \n",
      "2 1  \n",
      "3 2 1  \n",
      "4 3 2 1  \n",
      "5 4 3 2 1  \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'\\ni = 1 2 3 4 5 \\n\\n# loop 1\\nfor i = 1, range (1,0,-1): j=1\\ni = 1, print: 1 \\n\\n# loop 2\\nfor  i =2, range (2,0,-1): j = 2,1\\ni = 2, print: 2,1\\n'"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Example 5: Method 1\n",
    "\n",
    "for i in range (1,6):\n",
    "    for j in range (i,0,-1):\n",
    "        print(j, end=\" \")\n",
    "    print(\" \")\n",
    "    \n",
    "\"\"\"\n",
    "i = 1 2 3 4 5 \n",
    "\n",
    "# loop 1\n",
    "for i = 1, range (1,0,-1): j=1\n",
    "i = 1, print: 1 \n",
    "\n",
    "# loop 2\n",
    "for  i =2, range (2,0,-1): j = 2,1\n",
    "i = 2, print: 2,1\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:10:20.245002Z",
     "start_time": "2021-10-04T12:10:20.124886Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 \n",
      "2 1 \n",
      "3 2 1 \n",
      "4 3 2 1 \n",
      "5 4 3 2 1 \n"
     ]
    }
   ],
   "source": [
    "# Example 5: Method 2\n",
    "\n",
    "for i in range(0,5):\n",
    "    for j in range(i+1,0,-1):\n",
    "        print(j, end=\" \")\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:10:20.398322Z",
     "start_time": "2021-10-04T12:10:20.249887Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "* * * * *  \n",
      "* * * *  \n",
      "* * *  \n",
      "* *  \n",
      "*  \n"
     ]
    }
   ],
   "source": [
    "# Example 6: Example 1 reverse pyramid \n",
    "\n",
    "\n",
    "for i in range (1,6):            # rows from 1 to 5\n",
    "    for j in range (5,i-1,-1):   # column range(5,0,-1) = 54321\n",
    "        print (\"*\", end=\" \"),\n",
    "    print (\" \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:10:20.521369Z",
     "start_time": "2021-10-04T12:10:20.401256Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 5 5 5 5  \n",
      "4 4 4 4  \n",
      "3 3 3  \n",
      "2 2  \n",
      "1  \n"
     ]
    }
   ],
   "source": [
    "# Example 7: Example 2 reverse pyramid Method 1\n",
    "\n",
    "rows = 5\n",
    "#        range(1,10,2)  # from 1,3,5,7,9\n",
    "for i in range(rows,0,-1):  # from 3,2,1\n",
    "    num = i\n",
    "    for j in range(0,i):\n",
    "        print(num, end=\" \")\n",
    "    print(\" \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:10:20.736215Z",
     "start_time": "2021-10-04T12:10:20.526255Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 5 5 5 5  \n",
      "4 4 4 4  \n",
      "3 3 3  \n",
      "2 2  \n",
      "1  \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'\\ni = 5 4 3 2 1 \\n\\n# loop 1\\nfor i = 5, range (0,5): j=5 4 3 2 1\\ni = 5, print: 5 5 5 5 5\\n\\n# loop 2\\nfor i = 4, range (0,4): j=4 3 2 1\\ni = 4, print: 4 4 4 4 \\n'"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Example 7: Example 2 reverse pyramid Method 2\n",
    "\n",
    "for i in range(5,0,-1):  # range from 5 4 3 2 1\n",
    "    for j in range(0,i): # range(0,5)=0 1 2 3 4\n",
    "        print(i, end=\" \")\n",
    "    print(\" \")\n",
    "    \n",
    "\"\"\"\n",
    "i = 5 4 3 2 1 \n",
    "\n",
    "# loop 1\n",
    "for i = 5, range (0,5): j=5 4 3 2 1\n",
    "i = 5, print: 5 5 5 5 5\n",
    "\n",
    "# loop 2\n",
    "for i = 4, range (0,4): j=4 3 2 1\n",
    "i = 4, print: 4 4 4 4 \n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:10:20.873909Z",
     "start_time": "2021-10-04T12:10:20.739145Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 5 \n",
      "1 2 3 4 \n",
      "1 2 3 \n",
      "1 2 \n",
      "1 \n"
     ]
    }
   ],
   "source": [
    "# Example 8: Method 1\n",
    "\n",
    "for i in range(5,0,-1):  # rows range = 5 4 3 2 1 \n",
    "    for j in range(1,i+1): # column range \n",
    "        print(j, end =\" \")\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:10:21.094614Z",
     "start_time": "2021-10-04T12:10:20.877817Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 5  \n",
      "1 2 3 4  \n",
      "1 2 3  \n",
      "1 2  \n",
      "1  \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'\\ni = 1 2 3 4 5 \\n\\n# loop 1\\nfor i = 1, range (5): j=0 1 2 3 4\\ni = 1, print: 1 2 3 4 5\\n\\n# loop 2\\nfor i = 2, range (4): j=0 1 2 3\\ni = 2, print: 1 2 3 4\\n\\n# loop 3\\nfor i = 3, range (3): j=0 1 2\\ni = 3, print: 1 2 3\\n\\n# loop 4\\nfor i = 4, range (2): j=0 1\\ni = 4, print: 1 2\\n\\n# loop 5\\nfor i = 5, range (1): j=0 \\ni = 5, print: 1 \\n'"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Example 8: Method 2\n",
    "\n",
    "for i in range(1,6):\n",
    "    for j in range(6-i):\n",
    "        print(j+1, end=\" \")\n",
    "    print(\" \")\n",
    "    \n",
    "\"\"\"\n",
    "i = 1 2 3 4 5 \n",
    "\n",
    "# loop 1\n",
    "for i = 1, range (5): j=0 1 2 3 4\n",
    "i = 1, print: 1 2 3 4 5\n",
    "\n",
    "# loop 2\n",
    "for i = 2, range (4): j=0 1 2 3\n",
    "i = 2, print: 1 2 3 4\n",
    "\n",
    "# loop 3\n",
    "for i = 3, range (3): j=0 1 2\n",
    "i = 3, print: 1 2 3\n",
    "\n",
    "# loop 4\n",
    "for i = 4, range (2): j=0 1\n",
    "i = 4, print: 1 2\n",
    "\n",
    "# loop 5\n",
    "for i = 5, range (1): j=0 \n",
    "i = 5, print: 1 \n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:10:21.227425Z",
     "start_time": "2021-10-04T12:10:21.103408Z"
    }
   },
   "outputs": [],
   "source": [
    "# Example 9: Print following rectangle of stars of 6 rows and 3 columns\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `while` loop inside `for` loop\n",
    "\n",
    "The **[while loop](https://github.com/milaan9/03_Python_Flow_Control/blob/main/006_Python_while_Loop.ipynb)** is an entry-controlled loop, and a **`for`** loop is a count-controlled loop. We can also use a **`while`** loop under the for loop statement. For example,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:10:21.427621Z",
     "start_time": "2021-10-04T12:10:21.232310Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Multiplication table of: 1\n",
      "1 2 3 4 5 6 7 8 9 10 \n",
      "\n",
      "Multiplication table of: 2\n",
      "2 4 6 8 10 12 14 16 18 20 \n",
      "\n",
      "Multiplication table of: 3\n",
      "3 6 9 12 15 18 21 24 27 30 \n",
      "\n",
      "Multiplication table of: 4\n",
      "4 8 12 16 20 24 28 32 36 40 \n",
      "\n",
      "Multiplication table of: 5\n",
      "5 10 15 20 25 30 35 40 45 50 \n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Example 1: Print Multiplication table of a first 5 numbers using `for` loop and `while` loop\n",
    "\n",
    "# outer loop\n",
    "for i in range(1, 6):\n",
    "    print('Multiplication table of:', i)\n",
    "    count = 1\n",
    "    # inner loop to print multiplication table of current number\n",
    "    while count < 11:\n",
    "        print(i * count, end=' ')\n",
    "        count = count + 1\n",
    "    print('\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Explanation:** \n",
    "\n",
    "* In this program, we iterate the first five numbers one by one using the outer loop and range function\n",
    "* Next, in each iteration of the outer loop, we will use the inner while loop to print the multiplication table of the current number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:10:21.551647Z",
     "start_time": "2021-10-04T12:10:21.431529Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Amy Amy Amy Amy Amy \n",
      "Bella Bella Bella Bella Bella \n",
      "Cathy Cathy Cathy Cathy Cathy \n"
     ]
    }
   ],
   "source": [
    "# Example 2:\n",
    "\n",
    "names = ['Amy', 'Bella', 'Cathy']\n",
    "\n",
    "for name in names:  # outer loop    \n",
    "    count = 0       # inner while loop\n",
    "    while count < 5:\n",
    "        print(name, end=' ')\n",
    "        # increment counter\n",
    "        count = count + 1\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `for ` loop in one line\n",
    "\n",
    "We can also formulate the **`for`** loop statement in one line to reduce the number of lines of code. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:10:21.719615Z",
     "start_time": "2021-10-04T12:10:21.556531Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[33, 63, 93, 36, 66, 96, 39, 69, 99]\n"
     ]
    }
   ],
   "source": [
    "# Example 1: regular `for` loop code\n",
    "\n",
    "first = [3, 6, 9]\n",
    "second = [30, 60, 90]\n",
    "final = []\n",
    "for i in first:\n",
    "    for j in second:\n",
    "        final.append(i+j)\n",
    "print(final)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:10:21.858284Z",
     "start_time": "2021-10-04T12:10:21.723522Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[33, 63, 93, 36, 66, 96, 39, 69, 99]\n"
     ]
    }
   ],
   "source": [
    "# Example 1: single line `for` loop code\n",
    "\n",
    "first = [3, 6, 9]\n",
    "second = [30, 60, 90]\n",
    "final = [i+j for i in first for j in second]\n",
    "print(final)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:10:21.997934Z",
     "start_time": "2021-10-04T12:10:21.861219Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 6, 8, 10]\n"
     ]
    }
   ],
   "source": [
    "# Example 2: Print the even numbers by adding 1 to the odd numbers in the list\n",
    "\n",
    "odd = [1, 5, 7, 9]\n",
    "even = [i + 1 for i in odd if i % 2 == 1]\n",
    "print(even)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:10:22.151254Z",
     "start_time": "2021-10-04T12:10:22.000865Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[30, 60], [30, 90], [60, 30], [60, 90], [90, 60], [90, 30]]\n"
     ]
    }
   ],
   "source": [
    "# Example 3:\n",
    "\n",
    "final = [[x, y] for x in [30, 60, 90] for y in [60, 30, 90] if x != y]\n",
    "print(final)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Accessing the index in for loop\n",
    "\n",
    "The **[enumerate()](https://github.com/milaan9/04_Python_Functions/blob/main/002_Python_Functions_Built_in/018_Python_enumerate%28%29.ipynb)** function is useful when we wanted to access both value and its index number or any sequence such as list or string. For example, a list is an ordered data structure that stores each item with its index number. Using the item’s index number, we can access or modify its value.\n",
    "\n",
    "Using enumerate function with a loop, we can access the list’s items with their index number. The **`enumerate()`** adds a counter to iteration and returns it in the form of an enumerable object.\n",
    "\n",
    "There three ways to access the index in **`for`** loop let’s see each one by one"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:10:22.335828Z",
     "start_time": "2021-10-04T12:10:22.154187Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Numbers[ 0 ] = 4\n",
      "Numbers[ 1 ] = 2\n",
      "Numbers[ 2 ] = 5\n",
      "Numbers[ 3 ] = 7\n",
      "Numbers[ 4 ] = 8\n"
     ]
    }
   ],
   "source": [
    "# Example 1: Print elements of the list with its index number using the `enumerate()` function\n",
    "\n",
    "#In this program, the for loop iterates through the list and displays the \n",
    "#elements along with its index number.\n",
    "\n",
    "numbers = [4, 2, 5, 7, 8]\n",
    "for i, v in enumerate(numbers):\n",
    "    print('Numbers[', i, '] =', v)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:10:22.474496Z",
     "start_time": "2021-10-04T12:10:22.338757Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index: 0   Value: 1\n",
      "Index: 1   Value: 2\n",
      "Index: 2   Value: 4\n",
      "Index: 3   Value: 6\n",
      "Index: 4   Value: 8\n"
     ]
    }
   ],
   "source": [
    "# Example 2: Printing the elements of the list with its index number using the `range()` function\n",
    "\n",
    "numbers = [1, 2, 4, 6, 8]\n",
    "size = len(numbers)\n",
    "for i in range(size):\n",
    "    print('Index:', i, \" \", 'Value:', numbers[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iterate String using `for` loop\n",
    "\n",
    "By looping through the **[string](https://github.com/milaan9/02_Python_Datatypes/blob/main/002_Python_String.ipynb)** using **`for`** loop, we can do lots of string operations. Let’s see how to perform various string operations using a **`for`** loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:10:22.613169Z",
     "start_time": "2021-10-04T12:10:22.477429Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "P\n",
      "y\n",
      "t\n",
      "h\n",
      "o\n",
      "n\n",
      "P\n",
      "y\n",
      "t\n",
      "h\n",
      "o\n",
      "n\n"
     ]
    }
   ],
   "source": [
    "# Example 1: For loop with string\n",
    "\n",
    "# Method 1:\n",
    "language = 'Python'\n",
    "for letter in language:\n",
    "    print(letter)\n",
    "\n",
    "# Method 2: using range() function\n",
    "\n",
    "for i in range(len(language)):\n",
    "    print(language[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:10:22.721568Z",
     "start_time": "2021-10-04T12:10:22.617079Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "H\n",
      "e\n",
      "l\n",
      "l\n",
      "o\n",
      " \n",
      "W\n",
      "o\n",
      "r\n",
      "l\n",
      "d\n"
     ]
    }
   ],
   "source": [
    "# Example 2: Printing the elements of a string using for loop\n",
    "\n",
    "for i in 'Hello World':\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:10:22.843641Z",
     "start_time": "2021-10-04T12:10:22.724500Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A l a n "
     ]
    }
   ],
   "source": [
    "# Example 3: Access all characters of a string\n",
    "\n",
    "name = \"Alan\"\n",
    "for i in name:\n",
    "    print(i, end=' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:10:22.967662Z",
     "start_time": "2021-10-04T12:10:22.848523Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "n a l A "
     ]
    }
   ],
   "source": [
    "# Example 4: Iterate string in reverse order\n",
    "\n",
    "name = \"Alan\"\n",
    "for i in name[::-1]:\n",
    "    print(i, end=' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:10:23.120985Z",
     "start_time": "2021-10-04T12:10:22.971571Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a n   W a "
     ]
    }
   ],
   "source": [
    "# Example 5: Iterate over a particular set of characters in string\n",
    "\n",
    "name = \"Alan Watson\"\n",
    "for char in name[2:7:1]:\n",
    "    print(char, end=' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:10:23.244033Z",
     "start_time": "2021-10-04T12:10:23.123915Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Remember,\n",
      "Red,\n",
      "hope\n",
      "is\n",
      "a\n",
      "good\n",
      "thing,\n",
      "maybe\n",
      "the\n",
      "best\n",
      "of\n",
      "things,\n",
      "and\n",
      "no\n",
      "good\n",
      "thing\n",
      "ever\n",
      "dies\n"
     ]
    }
   ],
   "source": [
    "# Example 6: Iterate over words in a sentence using the `split()` function.\n",
    "\n",
    "dialogue = \"Remember, Red, hope is a good thing, maybe the best of things, and no good thing ever dies\"\n",
    "# split on whitespace\n",
    "for word in dialogue.split():\n",
    "    print(word)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:10:23.352429Z",
     "start_time": "2021-10-04T12:10:23.246960Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "b\n",
      "c\n",
      "total = 14\n"
     ]
    }
   ],
   "source": [
    "# Example 7:\n",
    "\n",
    "for ch in 'abc':\n",
    "    print(ch)\n",
    "total = 0\n",
    "for i in range(5):  # from 0 to 4\n",
    "    total += i  # total = 0+1+2+3+4 = 10\n",
    "for i,j in [(1,2),(3,1)]:  # [(1),(3)]\n",
    "    total += i**j  # total = 1+3 = 4\n",
    "print(\"total =\",total)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iterate List using `for` 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": 65,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:10:23.476453Z",
     "start_time": "2021-10-04T12:10:23.356337Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "6\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "# Example 1: Iterate over a list Method 1\n",
    "\n",
    "numbers = [1, 2, 3, 6, 9]\n",
    "for num in numbers:\n",
    "    print(num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:10:23.617078Z",
     "start_time": "2021-10-04T12:10:23.480360Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "6\n",
      "9\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[None, None, None, None, None]"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Example 2: Iterate over a list Method 2 (list comprehension)\n",
    "\n",
    "numbers = [1, 2, 3, 6, 9]\n",
    "[print(i) for i in numbers]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:10:23.738173Z",
     "start_time": "2021-10-04T12:10:23.620986Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "6\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "# Example 3: Iterate over a list using a for loop and range.\n",
    "\n",
    "numbers = [1, 2, 3, 6, 9]\n",
    "size = len(numbers)\n",
    "for i in range(size):\n",
    "    print(numbers[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:10:23.846571Z",
     "start_time": "2021-10-04T12:10:23.741102Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4, 6, 8, 10]\n",
      "[2, 4, 6, 8, 10]\n",
      "[2, 4, 6, 8, 10]\n",
      "[2, 4, 6, 8, 10]\n",
      "[2, 4, 6, 8, 10]\n"
     ]
    }
   ],
   "source": [
    "# Example 4: printing the elements of a list using for loop\n",
    "\n",
    "even_numbers = [2, 4, 6, 8, 10]  # list with 5 elements\n",
    "for i in even_numbers:\n",
    "    print(even_numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:10:24.000869Z",
     "start_time": "2021-10-04T12:10:23.850479Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "60\n",
      "HelloWorld\n",
      "90.96\n"
     ]
    }
   ],
   "source": [
    "# Example 5: printing the elements of a list using for loop\n",
    "\n",
    "list = [60, \"HelloWorld\", 90.96]\n",
    "for i in list:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:10:24.141492Z",
     "start_time": "2021-10-04T12:10:24.023330Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The sum is 50\n"
     ]
    }
   ],
   "source": [
    "# Example 6: Program to find the sum of all numbers stored in a list\n",
    "\n",
    "# List of numbers\n",
    "numbers = [6, 5, 3, 8, 4, 2, 5, 6, 11]  # list with 9 elements\n",
    "\n",
    "# variable to store the sum\n",
    "sum = 0\n",
    "\n",
    "# iterate over the list\n",
    "for val in numbers:\n",
    "    sum = sum+val\n",
    "\n",
    "print(\"The sum is\", sum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:10:24.306532Z",
     "start_time": "2021-10-04T12:10:24.159071Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Square of: 1 is: 1\n",
      "Square of: 2 is: 4\n",
      "Square of: 3 is: 9\n",
      "Square of: 4 is: 16\n",
      "Square of: 5 is: 25\n"
     ]
    }
   ],
   "source": [
    "# Example 7: Calculate the square of each number using for loop.\n",
    "\n",
    "numbers = [1, 2, 3, 4, 5]\n",
    "# iterate over each element in list num\n",
    "for i in numbers:\n",
    "    # ** exponent operator\n",
    "    square = i ** 2\n",
    "    print(\"Square of:\", i, \"is:\", square)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Explanation:** **`i`** iterates over the 0,1,2,3,4. Every time it takes each value and executes the algorithm inside the loop. It is also possible to iterate over a nested list illustrated below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:10:24.413953Z",
     "start_time": "2021-10-04T12:10:24.309463Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30.0\n"
     ]
    }
   ],
   "source": [
    "# Example 8: Calculate the average of list of numbers\n",
    "\n",
    "numbers = [10, 20, 30, 40, 50]\n",
    "\n",
    "# definite iteration\n",
    "# run loop 5 times because list contains 5 items\n",
    "sum = 0\n",
    "for i in numbers:\n",
    "    sum = sum + i\n",
    "list_size = len(numbers)\n",
    "average = sum / list_size\n",
    "print(average)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:10:24.553606Z",
     "start_time": "2021-10-04T12:10:24.418839Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "Green\n",
      "Pink\n",
      "Blue\n"
     ]
    }
   ],
   "source": [
    "# Example 9: Printing a list using range function\n",
    "\n",
    "color = ['Green', 'Pink', 'Blue']  # list with total 3 elements\n",
    "print(len(color))  # print length of color\n",
    "for i in range(len(color)):\n",
    "    print(color[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:10:24.569228Z",
     "start_time": "2021-10-04T12:10:24.559462Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3]\n",
      "[4, 5, 6]\n",
      "[7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "# Example 10: Printing a list using range function\n",
    "\n",
    "list_of_lists = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]  # list with 3 elements\n",
    "for list1 in list_of_lists:\n",
    "        print(list1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iterate Tuple using `for` loop\n",
    "\n",
    "**[Python list](https://github.com/milaan9/02_Python_Datatypes/blob/main/004_Python_Tuple.ipynb)** Only the difference is that list is enclosed between square bracket **`[]`**, tuple between parentheses **`()`** and we cannot change the elements of a tuple once it is assigned, i.e., **immutable** whereas we can change the elements of a list i.e., **mutable**.\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 tuple. There are ways to iterate through elements in it. Here are some examples to help you understand better."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:10:24.723523Z",
     "start_time": "2021-10-04T12:10:24.572159Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "# Example 1: For loop with tuple\n",
    "\n",
    "numbers = (0, 1, 2, 3, 4, 5)\n",
    "for number in numbers:\n",
    "    print(number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iterate Dictionary using `for` loop\n",
    "\n",
    "**[Python dictionary](https://github.com/milaan9/02_Python_Datatypes/blob/main/005_Python_Dictionary.ipynb)** is used to store the items in the format of **key-value** pair. It doesn’t allow duplicate items. It is enclosed with **`{}`**. Here are some of the examples of dictionaries.\n",
    "\n",
    "```python\n",
    ">>> dict1 = {1: \"Apple\", 2: \"Ball\", 3: \"Cat\"}\n",
    ">>> dict2 = {\"Antibiotics\": \"Penicillin\", \"Inventor\": \"Fleming\", \"Year\": 1928}\n",
    "```\n",
    "\n",
    "There are ways to iterate through **key-value** pairs. Here are some examples to help you understand better."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:10:24.876845Z",
     "start_time": "2021-10-04T12:10:24.727434Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Antibiotics\n",
      "Inventor\n",
      "Year\n"
     ]
    }
   ],
   "source": [
    "# Example 1: Access only the keys of the dictionary.\n",
    "\n",
    "dict1 = {\"Antibiotics\": \"Penicillin\", \"Inventor\": \"Fleming\", \"Year\": 1928}\n",
    "for key in dict1:\n",
    "    print(key)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:10:25.062391Z",
     "start_time": "2021-10-04T12:10:24.879776Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Vaccine -> Polio\n",
      "Inventor -> Salk\n",
      "Year -> 1953\n"
     ]
    }
   ],
   "source": [
    "# Example 2: Iterate keys and values of the dictionary\n",
    "\n",
    "dict1 = {\"Vaccine\": \"Polio\", \"Inventor\": \"Salk\", \"Year\": 1953}\n",
    "for key in dict1:\n",
    "    print(key, \"->\", dict1[key])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:10:25.216690Z",
     "start_time": "2021-10-04T12:10:25.065324Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Smallpox \n",
      "Jenner\n",
      "1796\n"
     ]
    }
   ],
   "source": [
    "# Example 3: Iterate only the values the dictionary\n",
    "\n",
    "dict1 = {\"Vaccine\": \"Smallpox \", \"Inventor\": \"Jenner\", \"Year\": 1796}\n",
    "for value in dict1.values():\n",
    "    print(value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:10:25.339735Z",
     "start_time": "2021-10-04T12:10:25.221574Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "first_name\n",
      "last_name\n",
      "age\n",
      "country\n",
      "is_marred\n",
      "skills\n",
      "address\n",
      "first_name Milaan\n",
      "last_name Parmar\n",
      "age 96\n",
      "country Finland\n",
      "is_marred True\n",
      "skills ['Python', 'Matlab', 'R', 'C', 'C++']\n",
      "address {'street': 'Space street', 'zipcode': '02210'}\n"
     ]
    }
   ],
   "source": [
    "# Example 4: For loop with dictionary\n",
    "#Looping through a dictionary gives you the key of the dictionary.\n",
    "\n",
    "person = {\n",
    "    'first_name':'Milaan',\n",
    "    'last_name':'Parmar',\n",
    "    'age':96,\n",
    "    'country':'Finland',\n",
    "    'is_marred':True,\n",
    "    'skills':['Python', 'Matlab', 'R', 'C', 'C++'],\n",
    "    'address':{\n",
    "        'street':'Space street',\n",
    "        'zipcode':'02210'\n",
    "    }\n",
    "}\n",
    "for key in person:\n",
    "    print(key)\n",
    "\n",
    "for key, value in person.items():\n",
    "    print(key, value) # this way we get both keys and values printed out"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iterate Set using `for` loop\n",
    "\n",
    "**[Python sets](https://github.com/milaan9/02_Python_Datatypes/blob/main/006_Python_Sets.ipynb)** is an unordered collection of items. Every set element is unique (no duplicates) and must be immutable (cannot be changed).\n",
    "\n",
    "However, a set itself is **mutable**. We can add or remove items from it.\n",
    "\n",
    "```python\n",
    ">>> my_set = {1, 2, 3}\n",
    ">>> my_vaccine = {\"Penicillin\", \"Fleming\", \"1928\"}\n",
    "```\n",
    "\n",
    "Sets can also be used to perform mathematical set operations like **union**, **intersection**, **symmetric difference**, etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-04T12:10:25.509661Z",
     "start_time": "2021-10-04T12:10:25.343645Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GUava\n",
      "Banana\n",
      "Grape\n",
      "Kiwi\n",
      "Orange\n",
      "Apple\n",
      "Mango\n"
     ]
    }
   ],
   "source": [
    "# Example 6: For loop with set\n",
    "\n",
    "mix_fruits = {'Banana', 'Apple', 'Mango', 'Orange', 'GUava', 'Kiwi', 'Grape'}\n",
    "for fruits in mix_fruits:\n",
    "    print(fruits)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 💻 Exercises ➞ <span class='label label-default'>List</span>\n",
    "\n",
    "### Exercises ➞ <span class='label label-default'>Level 1</span>\n",
    "\n",
    "1. Iterate 0 to 10 using **`for`** loop, do the same using **`while`** loop.\n",
    "2. Iterate 10 to 0 using **`for`** loop, do the same using **`while`** loop.\n",
    "3. Write a loop that makes seven calls to **`print()`**, so we get on the output the following triangle:\n",
    "\n",
    "```py\n",
    "# # # # # # # #\n",
    "# # # # # # # #\n",
    "# # # # # # # #\n",
    "# # # # # # # #\n",
    "# # # # # # # #\n",
    "# # # # # # # #\n",
    "# # # # # # # #\n",
    "# # # # # # # #\n",
    "```\n",
    "\n",
    "4. Use nested loops to create the following:\n",
    "\n",
    "```py\n",
    "      #\n",
    "     ###\n",
    "    #####\n",
    "   #######\n",
    "  #########\n",
    " ###########\n",
    "#############\n",
    "```\n",
    "\n",
    "5. Print the following pattern using loops\n",
    "\n",
    "```py\n",
    "   0 x 0 = 0\n",
    "   1 x 1 = 1\n",
    "   2 x 2 = 4\n",
    "   3 x 3 = 9\n",
    "   4 x 4 = 16\n",
    "   5 x 5 = 25\n",
    "   6 x 6 = 36\n",
    "   7 x 7 = 49\n",
    "   8 x 8 = 64\n",
    "   9 x 9 = 81\n",
    "   10 x 10 = 100\n",
    "```\n",
    "\n",
    "6. Iterate through the list, ['Python', 'Numpy','Pandas','Scikit', 'Pytorch'] using a **`for`** loop and print out the items.\n",
    "7. Use **`for`** loop to iterate from 0 to 100 and print only even numbers\n",
    "8. Use **`for`** loop to iterate from 0 to 100 and print only odd numbers\n",
    "   \n",
    "### Exercises ➞ <span class='label label-default'>Level 2</span>\n",
    "    \n",
    "1.  Use **`for`** loop to iterate from 0 to 100 and print the sum of all numbers.\n",
    "\n",
    "```py\n",
    "   The sum of all numbers is 5050.\n",
    "```\n",
    "\n",
    "1. Use **`for`** loop to iterate from 0 to 100 and print the sum of all evens and the sum of all odds.\n",
    "\n",
    "```py\n",
    "    The sum of all evens is 2550. And the sum of all odds is 2500.\n",
    "```\n",
    "\n",
    "### Exercises ➞ <span class='label label-default'>Level 3</span>\n",
    "\n",
    "1. Go to the data folder and use the **[countries.py](https://github.com/Asabeneh/30-Days-Of-Python/blob/master/data/countries.py)** file. Loop through the countries and extract all the countries containing the word **`land`**.\n",
    "1. This is a fruit list, ['banana', 'orange', 'mango', 'lemon'] reverse the order using loop.\n",
    "2. Go to the data folder and use the **[countries_data.py](https://github.com/milaan9/03_Python_Flow_Control/blob/main/countries_details_data.py)** file. \n",
    "   1. What are the total number of languages in the data\n",
    "   2. Find the ten most spoken languages from the data\n",
    "   3. Find the 10 most populated countries in the world"
   ]
  },
  {
   "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
}