Loops.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src='images/logo_full.png'/>\n",
    "\n",
    "## <center> Python for Data Science </center>\n",
    "The course is offered by [Ai Adventures](https://aiadventures.in/). The notebooks are created by [Pranav Uikey](https://twitter.com/Pranav_Uikey_) and [Ankur Singh](https://twitter.com/I_ankursingh). This material is subject to the terms and conditions of the [Creative Commons CC BY-NC-SA 4.0](https://creativecommons.org/licenses/by-nc-sa/4.0/) license. Any use for commercial purpose is strictly prohibited."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "## *while* Loop Statements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "You can make a block of code execute over and over again with a *while* statement. The code in a *while* clause will be executed as long as the *while* statement’s condition is True. In code, a *while* statement always consists of the following:\n",
    "\n",
    "1. The *while* keyword\n",
    "\n",
    "2. A condition (that is, an expression that evaluates to True or False)\n",
    "\n",
    "3. A colon\n",
    "\n",
    "4. Starting on the next line, an indented block of code (called the while clause)\n",
    "\n",
    "You can see that a while statement looks similar to an *if* statement. The difference is in **how they behave**. At the end of an *if* clause, the program execution continues after the *if* statement. But at the end of a *while* clause, the program execution jumps back to the start of the *while* statement. The *while* clause is often called the **while loop** or just the **loop**.\n",
    "\n",
    "Let’s look at an *if* statement and a *while* loop that use the same condition and take the same actions based on that condition."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, world.\n"
     ]
    }
   ],
   "source": [
    "# Here is the code with an if statement:\n",
    "\n",
    "spam = 0\n",
    "if spam < 5:\n",
    "    print('Hello, world.')\n",
    "    spam = spam + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, world.\n",
      "Hello, world.\n",
      "Hello, world.\n",
      "Hello, world.\n",
      "Hello, world.\n"
     ]
    }
   ],
   "source": [
    "# Here is the code with a while statement:\n",
    "\n",
    "spam = 0\n",
    "while spam < 5:\n",
    "    print('Hello, world.')\n",
    "    spam = spam + 1\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "These statements are similar—both *if* and *while* check the value of spam, and if it’s less than five, they print a message. But when you run these two code snippets, something very different happens for each one. For the *if* statement, the output is simply \"Hello, world.\". But for the *while* statement, it’s \"Hello, world.\" repeated five times! Take a look at the flowcharts for these two pieces of code, to see why this happens.\n",
    "\n",
    "### *if* statement:\n",
    "![](images/000091.png)\n",
    "\n",
    "### *while* statement:\n",
    "![](images/000094.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "The code with the *if* statement checks the condition, and it prints Hello, world. only once if that condition is true. The code with the *while* loop, on the other hand, will print it five times. It stops after five prints because the integer in spam is incremented by one at the end of each loop iteration, which means that the loop will execute five times before `spam < 5` is False.\n",
    "\n",
    "In the *while* loop, the condition is always checked at the start of each iteration (that is, each time the loop is executed). If the condition is True, then the clause is executed, and afterward, the condition is checked again. The first time the condition is found to be False, the *while* clause is skipped."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "### An Annoying while Loop\n",
    "Here’s a small example program that will keep asking you to type, literally, **your name**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please type your name\n",
      "xyz\n",
      "Please type your name\n",
      "zyx\n",
      "Please type your name\n",
      "your name\n",
      "thank you!\n"
     ]
    }
   ],
   "source": [
    "name = '' # (1)\n",
    "while name != 'your name': # (2)\n",
    "    print('Please type your name')\n",
    "    name = input() # (3)\n",
    "print('thank you!') # (4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "First, the program sets the name variable ❶ to an empty string. This is so that the name != 'your name' condition will evaluate to True and the program execution will enter the while loop’s clause ❷.\n",
    "\n",
    "The code inside this clause asks the user to type their name, which is assigned to the name variable ❸. Since this is the last line of the block, the execution moves back to the start of the while loop and reevaluates the condition. If the value in name is not equal to the string 'your name', then the condition is True, and the execution enters the while clause again.\n",
    "\n",
    "But once the user types your name, the condition of the while loop will be `'your name' != 'your name'`, which evaluates to False. The condition is now False, and instead of the program execution reentering the while loop’s clause, it skips past it and continues running the rest of the program ❹"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "If you never enter your name, then the while loop’s condition will never be False, and the program will just keep asking forever. Here, the `input()` call lets the user enter the right string to make the program move on. In other programs, the condition might never actually change, and that can be a problem. Let’s look at how you can break out of a while loop.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## *break* Statements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is a shortcut to getting the program execution to break out of a *while*\n",
    "loop’s clause early. If the execution reaches a *break* statement, it immediately\n",
    "exits the *while* loop’s clause. In code, a *break* statement simply contains\n",
    "the *break* keyword.\n",
    "Pretty simple, right? Here’s a program that does the same thing as the\n",
    "previous program, but it uses a *break* statement to escape the loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please type your name.\n",
      "your name\n"
     ]
    }
   ],
   "source": [
    "while True:\n",
    "    print('Please type your name.')\n",
    "    name = input()\n",
    "    if name == 'your name':\n",
    "        break\n",
    "    print('Thank you!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first line creates an infinite loop; it is a *while* loop whose condition\n",
    "is always True. (The expression True, after all, always evaluates down to the\n",
    "value True.) The program execution will always enter the loop and will exit\n",
    "it only when a *break* statement is executed. (An infinite loop that never exits\n",
    "is a common programming bug.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](images/000099.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## *continue* Statements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Like *break* statements, *continue* statements are used inside loops. When the\n",
    "program execution reaches a *continue* statement, the program execution\n",
    "immediately jumps back to the start of the loop and reevaluates the loop’s\n",
    "condition. (This is also what happens when the execution reaches the end\n",
    "of the loop.)\n",
    "\n",
    "Let’s use continue to write a program that asks for a name and password."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Who are you?\n",
      "xyz\n",
      "Who are you?\n",
      "Joe\n",
      "Hello, Joe. What is the password? (It is a fish.)\n",
      "swordfish\n",
      "Access granted.\n"
     ]
    }
   ],
   "source": [
    "while True:\n",
    "    print('Who are you?')\n",
    "    name = input()\n",
    "    if name != 'Joe':\n",
    "        continue\n",
    "    print('Hello, Joe. What is the password? (It is a fish.)')\n",
    "    password = input()\n",
    "    if password == 'swordfish':\n",
    "        break\n",
    "print('Access granted.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](images/000100.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## *for* Loops and the *range()* Function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The *while* loop keeps looping while its condition is True (which is the reason for its name), but what if you want to execute a block of code only a certain number of times? You can do this with a *for* loop statement and the range() function.\n",
    "\n",
    "In code, a *for* statement looks something like `for i in range(5):` and always includes the following:\n",
    "\n",
    "1. The *for* keyword\n",
    "\n",
    "2. A variable name\n",
    "\n",
    "3. The *in* keyword\n",
    "\n",
    "4. A call to the *range()* method with up to three integers passed to it\n",
    "\n",
    "5. A colon\n",
    "\n",
    "6. Starting on the next line, an indented block of code (called the *for* clause)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My name is\n",
      "Jimmy Five Times (0)\n",
      "Jimmy Five Times (1)\n",
      "Jimmy Five Times (2)\n",
      "Jimmy Five Times (3)\n",
      "Jimmy Five Times (4)\n"
     ]
    }
   ],
   "source": [
    "print('My name is')\n",
    "for i in range(5):\n",
    "    print('Jimmy Five Times (' + str(i) + ')')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The code in the *for* loop’s clause is run five times. The first time it is run, the variable i is set to 0. The *print()* call in the clause will print Jimmy Five Times (0). After Python finishes an iteration through all the code inside the for loop’s clause, the execution goes back to the top of the loop, and the *for* statement increments *i* by one. This is why `range(5)` results in five iterations through the clause, with *i* being set to 0, then 1, then 2, then 3, and then 4. The variable *i* will go up to, but will not include, the integer passed to *range()*\n",
    "\n",
    "#### *for* statement\n",
    "![](images/000102.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### An Equivalent *while* Loop\n",
    "You can actually use a *while* loop to do the same thing as a *for* loop; *for* loops are just more concise and readable. Let’s rewrite it, to use a *while* loop equivalent of a *for* loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My name is\n",
      "Jimmy Five Times (0)\n",
      "Jimmy Five Times (1)\n",
      "Jimmy Five Times (2)\n",
      "Jimmy Five Times (3)\n",
      "Jimmy Five Times (4)\n"
     ]
    }
   ],
   "source": [
    "print('My name is')\n",
    "i = 0\n",
    "while i < 5:\n",
    "    print('Jimmy Five Times (' + str(i) + ')')\n",
    "    i = i+1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As another *for* loop example, consider this story about the mathematician Karl Friedrich Gauss. When Gauss was a boy, a teacher wanted to give the class some busywork. The teacher told them to add up all the numbers from 0 to 100. Young Gauss came up with a clever trick to figure out the answer in a few seconds, but you can write a Python program with a *for* loop to do this calculation for you."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5050\n"
     ]
    }
   ],
   "source": [
    "total = 0 # (1)\n",
    "for num in range(101): # (2)\n",
    "    total = total + num # (3)\n",
    "print(total) # (4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The result should be 5,050. When the program first starts, the total variable is set to 0 ❶. The for loop ❷ then executes total = total + num ❸ 100 times. By the time the loop has finished all of its 100 iterations, every integer from 0 to 100 will have been added to total. At this point, total is printed to the screen ❹. Even on the slowest computers, this program takes less than a second to complete."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### range() function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### The Starting, Stopping, and Stepping Arguments to range()\n",
    "Some functions can be called with multiple arguments separated by a comma, and *range()* is one of them. This lets you change the integer passed to *range()* to follow any sequence of integers, including starting at a number other than zero."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n",
      "13\n",
      "14\n",
      "15\n"
     ]
    }
   ],
   "source": [
    "for i in range(12, 16):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first argument will be where the *for* loop’s variable starts, and the second argument will be up to, but not including, the number to stop at.\n",
    "\n",
    "The *range()* function can also be called with **three arguments**. The first **two arguments** will be the **start** and **stop values**, and the **third** will be the **step argument**. The **step** is the amount that the variable is increased by after each iteration."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "2\n",
      "4\n",
      "6\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "for i in range(0, 10, 2):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So calling range(0, 10, 2) will count from zero to eight by intervals of two.\n",
    "\n",
    "The range() function is flexible in the sequence of numbers it produces for for loops. For example, you can even use a **negative number** for the step argument to make the for loop count down instead of up."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "4\n",
      "3\n",
      "2\n",
      "1\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "for i in range(5, -1, -1):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Summary\n",
    "\n",
    "You can execute code over and over again in a loop while a certain condition evaluates to True.\n",
    "\n",
    "When working with *while* loops pay special attention to **update** statements. Else, you will get trapped in an infinite *while* loop which is not a good thing to happen (trust me!)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}