Python_Lecture_5_PYTHON_FOR_LOOP_IF_STRUCTURE_WHILE_STRUCTURE.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# For loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "The structure of a for loop is as follows:\n",
    "\n",
    " for variable name in range( number of times to repeat ):\n",
    " \n",
    "     statements to be repeated\n",
    "\n",
    "The syntax is important here. The word for must be in lowercase, the first line must end with a\n",
    "colon, and the statements to be repeated must be indented. Indentation is used to tell Python which\n",
    "statements will be repeated."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The for Statement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "n = 1\n",
    "while n <= 10:\n",
    "    print(n)\n",
    "    n += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The print statement in this code executes exactly 10 times every time this code runs. This code requires\n",
    "three crucial pieces to manage the loop:\n",
    "\n",
    "    • initialization: n = 1\n",
    "\n",
    "    • check: n <= 10\n",
    "\n",
    "    • update: n += 1\n",
    "    \n",
    "Python provides a more convenient way to express a definite loop. The for statement iterates over a\n",
    "range of values. These values can be a numeric range, or, as we shall, elements of a data structure like a\n",
    "string, list, or tuple. The above while loop can be rewritten:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "for n in range(1, 11):\n",
    "    print(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The general form of the range function call is\n",
    "\n",
    "    range( begin,end,step )\n",
    "    \n",
    "where\n",
    "\n",
    "    • begin is the first value in the range; if omitted, the default value is 0\n",
    "\n",
    "    • end is one past the last value in the range; the end value may not be omitted\n",
    "\n",
    "    • change is the amount to increment or decrement; if the change parameter is omitted, it defaults to 1 (counts up by ones)\n",
    "\n",
    "begin, end, and step must all be integer values; floating-point values and other types are not allowed.\n",
    "The range function is very flexible. Consider the following loop that counts down from 21 to 3 by\n",
    "threes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "21 \n",
      "18 \n",
      "15 \n",
      "12 \n",
      "9 \n",
      "6 \n",
      "3 \n"
     ]
    }
   ],
   "source": [
    "for n in range(21, 0, -3):\n",
    "    print n, ''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4950\n"
     ]
    }
   ],
   "source": [
    "#The following code computes and prints the sum of all the positive integers less than 100:\n",
    "# Initialize sum\n",
    "sum = 0\n",
    "for i in range(1, 100):\n",
    "    sum += i\n",
    "print(sum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Nested Loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just like with if statements, while and for blocks can contain arbitrary Python statements, including\n",
    "other loops. A loop can therefore be nested within another loop.(timestable.py) prints a\n",
    "multiplication table on the screen using nested for loops."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "       1   2   3   4   5   6   7   8   9  10\n",
      "   +----------------------------------------\n",
      " 1 |   1   2   3   4   5   6   7   8   9  10 \n",
      " 2 |   2   4   6   8  10  12  14  16  18  20 \n",
      " 3 |   3   6   9  12  15  18  21  24  27  30 \n",
      " 4 |   4   8  12  16  20  24  28  32  36  40 \n",
      " 5 |   5  10  15  20  25  30  35  40  45  50 \n",
      " 6 |   6  12  18  24  30  36  42  48  54  60 \n",
      " 7 |   7  14  21  28  35  42  49  56  63  70 \n",
      " 8 |   8  16  24  32  40  48  56  64  72  80 \n",
      " 9 |   9  18  27  36  45  54  63  72  81  90 \n",
      "10 |  10  20  30  40  50  60  70  80  90 100 \n"
     ]
    }
   ],
   "source": [
    "# Print a multiplication table to 10 x 10\n",
    "# Print column heading\n",
    "from __future__ import print_function   # allows you to use the Python 3.0 style print function \n",
    "print ( \"       1   2   3   4   5   6   7   8   9  10\")\n",
    "print (\"   +----------------------------------------\")\n",
    "for row in range(1, 11): # 1 <= row <= 10, table has 10 rows\n",
    "    if row < 10:         # Need to add space?\n",
    "        print(\" \", end=\"\")\n",
    "    print(row, \"| \", end=\"\") # Print heading for this row.\n",
    "    for column in range(1, 11): # Table has 10 columns.\n",
    "        product = row*column; # Compute product\n",
    "        if product < 100: # Need to add space?\n",
    "            print(end=\" \")\n",
    "        if product < 10: # Need to add another space?\n",
    "            print(end=\" \")\n",
    "        print(product, end=\" \") # Display product\n",
    "# Move cursor to next row\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is how (timestable.py) works:\n",
    "\n",
    "• It is important to distinguish what is done only once (outside all loops) from that which is done\n",
    "repeatedly. The column heading across the top of the table is outside of all the loops; therefore, it is\n",
    "printed once in the beginning.\n",
    "\n",
    "• The work to print the heading for the rows is distributed throughout the execution of the outer loop.\n",
    "This is because the heading for a given row cannot be printed until all the results for the previous row\n",
    "have been printed.\n",
    "\n",
    "• A code fragment like\n",
    "\n",
    "if x < 10:\n",
    "\n",
    "print(end=\" \")\n",
    "\n",
    "print(x, end=\" \")\n",
    "\n",
    "prints x in one of two ways: if x is a one-digit number, it prints a space before it; otherwise, it does\n",
    "not print the extra space. The net effect is to right justify one and two digit numbers within a two\n",
    "character space printing area. This technique allows the columns within the times table to be properly\n",
    "right aligned.\n",
    "\n",
    "• row is the control variable for the outer loop; column controls the inner loop.\n",
    "\n",
    "• The inner loop executes ten times on every single iteration of the outer loop. How many times is the\n",
    "statement\n",
    "\n",
    "product = row*column #Compute product\n",
    "\n",
    "executed? 10 × 10 = 100, one time for every product in the table.\n",
    "\n",
    "• A newline is printed after the contents of each row is displayed; thus, all the values printed in the\n",
    "inner (column) loop appear on the same line."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Listing 5.9: flexibletimestable.py\n",
    "\n",
    "With a little work, we can make our multiplication table program more flexible. (flexibletimestable.py)\n",
    "will print times tables of various sizes based on the value of the variable named MAX."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18 \n",
      "   +------------------------------------------------------------------------\n",
      " 1 |   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18 \n",
      " 2 |   2   4   6   8  10  12  14  16  18  20  22  24  26  28  30  32  34  36 \n",
      " 3 |   3   6   9  12  15  18  21  24  27  30  33  36  39  42  45  48  51  54 \n",
      " 4 |   4   8  12  16  20  24  28  32  36  40  44  48  52  56  60  64  68  72 \n",
      " 5 |   5  10  15  20  25  30  35  40  45  50  55  60  65  70  75  80  85  90 \n",
      " 6 |   6  12  18  24  30  36  42  48  54  60  66  72  78  84  90  96 102 108 \n",
      " 7 |   7  14  21  28  35  42  49  56  63  70  77  84  91  98 105 112 119 126 \n",
      " 8 |   8  16  24  32  40  48  56  64  72  80  88  96 104 112 120 128 136 144 \n",
      " 9 |   9  18  27  36  45  54  63  72  81  90  99 108 117 126 135 144 153 162 \n",
      "10 |  10  20  30  40  50  60  70  80  90 100 110 120 130 140 150 160 170 180 \n",
      "11 |  11  22  33  44  55  66  77  88  99 110 121 132 143 154 165 176 187 198 \n",
      "12 |  12  24  36  48  60  72  84  96 108 120 132 144 156 168 180 192 204 216 \n",
      "13 |  13  26  39  52  65  78  91 104 117 130 143 156 169 182 195 208 221 234 \n",
      "14 |  14  28  42  56  70  84  98 112 126 140 154 168 182 196 210 224 238 252 \n",
      "15 |  15  30  45  60  75  90 105 120 135 150 165 180 195 210 225 240 255 270 \n",
      "16 |  16  32  48  64  80  96 112 128 144 160 176 192 208 224 240 256 272 288 \n",
      "17 |  17  34  51  68  85 102 119 136 153 170 187 204 221 238 255 272 289 306 \n",
      "18 |  18  36  54  72  90 108 126 144 162 180 198 216 234 252 270 288 306 324 \n"
     ]
    }
   ],
   "source": [
    "from __future__ import print_function   # allows you to use the Python 3.0 style print function \n",
    "# Print a MAX x MAX multiplication table\n",
    "MAX = 18\n",
    "# First, print heading\n",
    "print(end=\" \")\n",
    "# Print column heading numbers\n",
    "for column in range(1, MAX + 1):\n",
    "    print(end=\" %2i \" % column)\n",
    "print()\n",
    "# Go down to the next line\n",
    "# Print line separator; a portion for each column\n",
    "print(end=\"   +\")\n",
    "for column in range(1, MAX + 1):\n",
    "    print(end=\"----\") # Print portion of line\n",
    "print()\n",
    "# Go down to the next line\n",
    "# Print table contents\n",
    "for row in range(1, MAX + 1):#1 <= row <= MAX, table has MAX rows\n",
    "    print(end=\"%2i | \" % row)#Print heading for this row.\n",
    "    for column in range(1, MAX + 1):#Table has 10 columns.\n",
    "        product = row*column;#Compute product\n",
    "        print(end=\"%3i \" % product)#Display product\n",
    "    print()#Move cursor to next row"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Listing 5.10 (permuteabc.py) \n",
    "\n",
    "uses a triply-nested loop to print all the different arrangements of the\n",
    "letters A, B, and C. Each string printed is a permutation of ABC."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ABC\n",
      "ACB\n",
      "BAC\n",
      "BCA\n",
      "CAB\n",
      "CBA\n"
     ]
    }
   ],
   "source": [
    "from __future__ import print_function   # allows you to use the Python 3.0 style print function \n",
    "# The first letter varies from A to C\n",
    "for first in 'ABC':\n",
    "    for second in 'ABC': # The second varies from A to C\n",
    "        if second != first: #No duplicate letters allowed\n",
    "            for third in 'ABC': # The third varies from A to C\n",
    "             # Don't duplicate first or second letter\n",
    "                if third != first and third != second:\n",
    "                    print(first + second + third)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Listing 5.11 (permuteabcd.py) \n",
    "\n",
    "uses a four-deep nested loop to print all the different arrangements of\n",
    "the letters A, B, C, and D. Each string printed is a permutation of ABCD."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ABCD\n",
      "ABDC\n",
      "ACBD\n",
      "ACDB\n",
      "ADBC\n",
      "ADCB\n",
      "BACD\n",
      "BADC\n",
      "BCAD\n",
      "BCDA\n",
      "BDAC\n",
      "BDCA\n",
      "CABD\n",
      "CADB\n",
      "CBAD\n",
      "CBDA\n",
      "CDAB\n",
      "CDBA\n",
      "DABC\n",
      "DACB\n",
      "DBAC\n",
      "DBCA\n",
      "DCAB\n",
      "DCBA\n"
     ]
    }
   ],
   "source": [
    "from __future__ import print_function   # allows you to use the Python 3.0 style print function\n",
    "#File permuteabcd.py\n",
    "# The first letter varies from A to D\n",
    "for first in 'ABCD':\n",
    "    for second in 'ABCD': # The second varies from A to D\n",
    "        if second != first: #No duplicate letters allowed\n",
    "            for third in 'ABCD': # The third varies from A to D\n",
    "# Don't duplicate first or second letter\n",
    "                if third != first and third != second:\n",
    "                    for fourth in 'ABCD': #The fourth varies from A to D\n",
    "                        if fourth != first and fourth != second and fourth != third:\n",
    "                            print(first + second + third + fourth)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example 1 The following program will print Hello ten times."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for i in range(10):\n",
    "    print( ' Hello ' )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example 2 The program below asks the user for a number and prints its square, then asks for\n",
    "another number and prints its square, etc. It does this three times and then prints that the loop is\n",
    "done."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for i in range(3):\n",
    "    num = eval(input( ' Enter a number: ' ))\n",
    "    print ( ' The square of your number is ' , num*num)\n",
    "print( ' The loop is now done. ' )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for i in range(4):\n",
    "    print( ' * ' *6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for i in range(5,0,-1):\n",
    "    print i\n",
    "print( 'Blast off!! ' )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for i in range(3):\n",
    "    print(i+1, ' -- Hello ' )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a program that uses exactly four for loops to print the sequence of letters below.\n",
    "\n",
    "AAAAAAAAAABBBBBBBCDCDCDCDEFFFFFFG"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Fibonacci numbers are the sequence below, where the first two numbers are 1, and each\n",
    "number thereafter is the sum of the two preceding numbers. Write a program that asks the\n",
    "user how many Fibonacci numbers to print and then prints that many.\n",
    "\n",
    "1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89 . . ."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# If statements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# A Simple Example\n",
    "The computer picks a random number, the player tries to\n",
    "guess, and the program tells them if they are correct. To see if the player’s guess is correct, we need\n",
    "something new, called an if statement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from random import randint\n",
    "num = randint(1,10)\n",
    "guess = eval(input( ' Enter your guess: ' ))\n",
    "if guess==num:\n",
    "    print( ' You got it! ' )\n",
    "else:\n",
    "    print ('Sorry. The number is ' , num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Conditional operators\n",
    "\n",
    "The comparison operators are == , > , < , >= , <= , and != . That last one is for not equals.\n",
    "\n",
    "There are three additional operators used to construct more complicated conditions: and , or , and\n",
    "not .\n",
    "\n",
    "# Order of operations\n",
    "\n",
    "In terms of order of operations, and is done before or , so if you have a\n",
    "complicated condition that contains both, you may need parentheses around the or condition.\n",
    "Think of and as being like multiplication and or as being like addition."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "score = eval(input('Enter a number'))\n",
    "turns_remaining = eval(input('Enter another number'))\n",
    "if (score<1000 or time>20) and turns_remaining==0:\n",
    "    print( ' Game over. ' )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# elif"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "grade = eval(input( ' Enter your score: ' ))\n",
    "if grade>=90:\n",
    "    print( ' A ' )\n",
    "if grade>=80 and grade<90:\n",
    "    print( ' B ' )\n",
    "if grade>=70 and grade<80:\n",
    "    print( ' C ' )\n",
    "if grade>=60 and grade<70:\n",
    "    print( ' D ' )\n",
    "if grade<60:\n",
    "    print( ' F ' )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The code above is pretty straightforward and it works. However, a more elegant way to do it is\n",
    "shown below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "grade = eval(input( ' Enter your score: ' ))\n",
    "if grade>=90:\n",
    "    print( ' A ' )\n",
    "elif grade>=80:\n",
    "    print( ' B ' )\n",
    "elif grade>=70:\n",
    "    print( ' C ' )\n",
    "elif grade>=60:\n",
    "    print( ' D ' )\n",
    "else:\n",
    "    print( ' F ' )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Generate a random number between 1 and 10. Ask the user to guess the number and print a\n",
    "message based on whether they get it right or not.\n",
    "\n",
    "2. A store charges \\$12 per item if you buy less than 10 items. If you buy between 10 and 99 items, the cost is \\$10 per item. If you buy 100 or more items, the cost is \\$7 per item. Write a program that asks the user how many items they are buying and prints the total cost.\n",
    "\n",
    "3. Write a program that asks the user for two numbers and prints Close if the numbers are\n",
    "within .001 of each other and Not close otherwise.\n",
    "\n",
    "4. Write a program that asks the user to enter a number and prints out all the divisors of that\n",
    "number.\n",
    "\n",
    "5. Write a multiplication game program for kids. The program should give the player ten ran-\n",
    "domly generated multiplication questions to do. After each, the program should tell them\n",
    "whether they got it right or wrong and what the correct answer is.\n",
    "\n",
    "6. Write a program that lets the user play Rock-Paper-Scissors against the computer. There\n",
    "should be five rounds, and after those five rounds, your program should print out who won\n",
    "and lost or that there is a tie."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# While loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes, though, we need to repeat something, but we don’t know ahead of time exactly\n",
    "how many times it has to be repeated. For instance, a game of Tic-tac-toe keeps going until someone\n",
    "wins or there are no more moves to be made, so the number of turns will vary from game to game.\n",
    "This is a situation that would call for a while loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#the temperature converter.\n",
    "temp = 0\n",
    "while temp!=-1000:\n",
    "    temp = eval(input( ' Enter a temperature (-1000 to quit): ' ))\n",
    "    print( ' In Fahrenheit that is ' , 9/5*temp+32)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One problem with the previous program is that when the user enters in −1000 to\n",
    "quit, the program still converts the value −1000 and doesn’t give any message to indicate that the\n",
    "program has ended. A nicer way to do the program is shown below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "temp = 0\n",
    "while temp!=-1000:\n",
    "    temp = eval(input( ' Enter a temperature (-1000 to quit): ' ))\n",
    "    if temp!=-1000:\n",
    "        print( ' In Fahrenheit that is ' , 9/5*temp+32)\n",
    "    else:\n",
    "        print( ' Bye! ' )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# with a while loop to create a program that allows the user to keep guessing until they get it right.\n",
    "from random import randint\n",
    "secret_num = randint(1,10)\n",
    "guess = 0\n",
    "while guess != secret_num:\n",
    "    guess = eval(input( ' Guess the secret number: ' ))\n",
    "print( ' You finally got it! ' )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use a while loop to mimic a for loop, as shown below. Both loops have the\n",
    "exact same effect."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for i in range(10):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "i=0\n",
    "while i<10:\n",
    "    print(i)\n",
    "    i=i+1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The while Statement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "count = 1                   #Initialize counter\n",
    "while count <= 5:           #Should we continue?\n",
    "    print(count)                #Display counter, then\n",
    "    count += 1                  #Increment counter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The while statement has the general form:\n",
    "\n",
    "    while condition :\n",
    "\n",
    "        block"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "• The reserved word while begins the while statement.\n",
    "\n",
    "• The condition determines whether the body will be (or will continue to be) executed. A colon (:)\n",
    "must follow the condition.\n",
    "\n",
    "• block is a block of one or more statements to be executed as long as the condition is true. As a block,\n",
    "all the statements that comprise the block must be indented the same number of spaces from the left.\n",
    "As with the if statement, the block must be indented more spaces than the line that begins the while\n",
    "statement. The block technically is part of the while statement."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example \n",
    "\n",
    "Listing (addnonnegatives.py) a program that allows a user to enter any number of non-negative\n",
    "integers. When the user enters a negative value, the program no longer accepts input, and it displays the\n",
    "sum of all the non-negative values. If a negative number is the first entry, the sum is zero."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter numbers to sum, negative number ends list:\n",
      "'5'\n",
      "('Sum =', 5)\n",
      "'6'\n",
      "('Sum =', 11)\n",
      "'-9'\n",
      "('Sum =', 11)\n"
     ]
    }
   ],
   "source": [
    "#Allow the user to enter a sequence of non-negative\n",
    "#numbers. The user ends the list with a negative\n",
    "#number. At the end the sum of the non-negative\n",
    "#numbers entered is displayed. The program prints\n",
    "#zero if the user provides no non-negative numbers.\n",
    "entry = 0 #Ensure the loop is entered\n",
    "sum = 0#Initialize sum\n",
    "\n",
    "# Request input from the user\n",
    "print(\"Enter numbers to sum, negative number ends list:\")\n",
    "while entry >= 0:#A negative number exits the loop\n",
    "    entry = eval(input())#Get the value\n",
    "    if entry >= 0:#Is number non-negative?\n",
    "        sum += entry#Only add it if it is non-negative\n",
    "    print(\"Sum =\", sum)#Display the sum"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Definite Loops vs. Indefinite Loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "n = 1\n",
    "while n <= 10:\n",
    "    print(n)\n",
    "    n += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can inspect the code and determine the number of iterations the loop performs. This kind of loop is\n",
    "known as a definite loop, since we can predict exactly how many times the loop repeats."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'4'\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "n = 1\n",
    "stop = int(input())\n",
    "while n <= stop:\n",
    "    print(n)\n",
    "    n += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Looking at the source code (definite2.py), we cannot predict how many times the loop\n",
    "will repeat. The number of iterations depends on the input provided by the user. However, at the program’s\n",
    "point of execution after obtaining the user’s input and before the start of the execution of the loop, we would\n",
    "be able to determine the number of iterations the while loop would perform. Because of this, the loop in (definite2.py) is considered to be a definite loop as well."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'999'\n"
     ]
    }
   ],
   "source": [
    "done = False\n",
    "while not done:\n",
    "    entry = eval(input())\n",
    "    if entry == 999:\n",
    "        done = True\n",
    "    else:\n",
    "        print(entry)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In (indefinite.py), we cannot predict at any point during the loop’s execution how many\n",
    "iterations the loop will perform. The value to match (999) is know before and during the loop, but the\n",
    "variable entry can be anything the user enters. The user could choose to enter 0 exclusively or enter 999\n",
    "immediately and be done with it. The while statement in (indefinite.py) is an example of\n",
    "an indefinite loop."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Infinite loops\n",
    "\n",
    "i=0\n",
    "\n",
    "while i<10:\n",
    "    \n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The break statement"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The break statement can be used to break out of a for or while loop before the loop is finished."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example 1 Here is a program that allows the user to enter up to 10 numbers. The user can stop\n",
    "early by entering a negative number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Enter number: '8'\n",
      " Enter number: '-8'\n"
     ]
    }
   ],
   "source": [
    "for i in range(10):\n",
    "    num = eval(input( ' Enter number: ' ))\n",
    "    if num<0:\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This could also be accomplished with a while loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Enter a number: '8'\n",
      " Enter a number: '8'\n",
      " Enter a number: '-8'\n"
     ]
    }
   ],
   "source": [
    "i=0\n",
    "num=1\n",
    "while i<10 and num>0:\n",
    "    num = eval(input( ' Enter a number: ' ))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " : '-1000'\n",
      " Bye! \n"
     ]
    }
   ],
   "source": [
    "temp = 0\n",
    "while temp!=-1000:\n",
    "    temp = eval(input( ' : ' ))\n",
    "    if temp!=-1000:\n",
    "        print(9/5*temp+32)\n",
    "    else:\n",
    "        print( ' Bye! ' )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " : '90'\n",
      "122\n",
      " : '-1000'\n",
      " Bye \n"
     ]
    }
   ],
   "source": [
    "while True:\n",
    "    temp = eval(input( ' : ' ))\n",
    "    if temp==-1000:\n",
    "        print( ' Bye ' )\n",
    "        break\n",
    "    print(9/5*temp+32)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The else statement\n",
    "There is an optional else that you can use with break statements. The code indented under the\n",
    "else gets executed only if the loop completes without a break happening."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Enter number: '0'\n",
      " Enter number: '1'\n",
      " Enter number: '8'\n",
      " Enter number: '9'\n",
      " Enter number: '0'\n",
      " Enter number: '9'\n",
      " Enter number: '8'\n",
      " Enter number: '7'\n",
      " Enter number: '6'\n",
      " Enter number: '5'\n",
      " User entered all ten values \n"
     ]
    }
   ],
   "source": [
    "for i in range(10):\n",
    "    num = eval(input( ' Enter number: ' ))\n",
    "    if num<0:\n",
    "        print( ' Stopped early ' )\n",
    "        break\n",
    "else:\n",
    "    print( ' User entered all ten values ' )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here are two ways to check if an integer num is prime. A prime number is a number\n",
    "whose only divisors are 1 and itself."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Prime \n"
     ]
    }
   ],
   "source": [
    "i=2\n",
    "while i<num and num%i!=0:\n",
    "    i=i+1\n",
    "if i==num:\n",
    "    print( ' Prime ' )\n",
    "else:\n",
    "    print( ' Not prime ' )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Prime \n"
     ]
    }
   ],
   "source": [
    "for i in range(2, num):\n",
    "    if num%i==0:\n",
    "        print( ' Not prime ' )\n",
    "        break\n",
    "else:\n",
    "    print( ' Prime ' )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The guessing game, more nicely done"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Enter your guess (1-100): '3'\n",
      "(' HIGHER. ', 4, ' guesses left.\\n ')\n",
      " Enter your guess (1-100): '4'\n",
      "(' HIGHER. ', 3, ' guesses left.\\n ')\n",
      " Enter your guess (1-100): '77'\n",
      "(' HIGHER. ', 2, ' guesses left.\\n ')\n",
      " Enter your guess (1-100): '99'\n",
      "(' HIGHER. ', 1, ' guesses left.\\n ')\n",
      " Enter your guess (1-100): '100'\n",
      " You got it! \n"
     ]
    }
   ],
   "source": [
    "from random import randint\n",
    "secret_num = randint(1,100)\n",
    "num_guesses = 0\n",
    "guess = 0\n",
    "while guess != secret_num and num_guesses <= 4:\n",
    "    guess = eval(input( ' Enter your guess (1-100): ' ))\n",
    "    num_guesses = num_guesses + 1\n",
    "    if guess < secret_num:\n",
    "        print( ' HIGHER. ' , 5-num_guesses, ' guesses left.\\n ' )\n",
    "    elif guess > secret_num:\n",
    "        print( ' LOWER. ' , 5-num_guesses, ' guesses left.\\n ' )\n",
    "    else:\n",
    "        print( ' You got it! ' )\n",
    "if num_guesses==5 and guess != secret_num:\n",
    "    print( ' You lose. The correct number is ' , secret_num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is an alternative solution using a for/break loop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Enter your guess (1-100): '77'\n",
      "(' LOWER. ', 5, ' guesses left.\\n ')\n",
      " Enter your guess (1-100): '50'\n",
      "(' LOWER. ', 4, ' guesses left.\\n ')\n",
      " Enter your guess (1-100): '20'\n",
      "(' HIGHER. ', 3, ' guesses left.\\n ')\n",
      " Enter your guess (1-100): '30'\n",
      "(' HIGHER. ', 2, ' guesses left.\\n ')\n",
      " Enter your guess (1-100): '40'\n",
      "(' HIGHER. ', 1, ' guesses left.\\n ')\n",
      "(' You lose. The correct number is ', 46)\n"
     ]
    }
   ],
   "source": [
    "from random import randint\n",
    "secret_num = randint(1,100)\n",
    "for num_guesses in range(5):\n",
    "    guess = eval(input( ' Enter your guess (1-100): ' ))\n",
    "    if guess < secret_num:\n",
    "        print( ' HIGHER. ' , 5-num_guesses, ' guesses left.\\n ' )\n",
    "    elif guess > secret_num:\n",
    "        print( ' LOWER. ' , 5-num_guesses, ' guesses left.\\n ' )\n",
    "    else:\n",
    "        print( ' You got it! ' )\n",
    "        break\n",
    "else:\n",
    "    print( ' You lose. The correct number is ' , secret_num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Write a program that uses a while loop (not a for loop) to read through a string and print\n",
    "the characters of the string one-by-one on separate lines.\n",
    "\n",
    "2. Modify the program above to print out every second character of the string.\n",
    "\n",
    "3. Write a program that asks the user to enter a password. If the user enters the right password,\n",
    "the program should tell them they are logged in to the system. Otherwise, the program\n",
    "should ask them to reenter the password. The user should only get five tries to enter the\n",
    "password, after which point the program should tell them that they are kicked off of the\n",
    "system.\n",
    "\n",
    "4. Recall that, given a string s , s.index( ' x ' ) returns the index of the first x in s and an error if there is no x.\n",
    "\n",
    " (a) Write a program that asks the user for a string and a letter. Using a while loop, the program should print the index of the first occurrence of that letter and a message if the string does not contain the letter.\n",
    "\n",
    " (b) Write the above program using a for/break loop instead of a while loop.\n",
    "\n",
    "5. The GCD (greatest common divisor) of two numbers is the largest number that both are di- visible by. For instance, gcd (18, 42) is 6 because the largest number that both 18 and 42 are divisible by is 6. Write a program that asks the user for two numbers and computes their gcd. Shown below is a way to compute the GCD, called Euclid’s Algorithm.\n",
    "\n",
    " • First compute the remainder of dividing the larger number by the smaller number\n",
    "\n",
    " • Next, replace the larger number with the smaller number and the smaller number with the remainder.\n",
    "\n",
    " • Repeat this process until the smaller number is 0. The GCD is the last value of the larger number.\n",
    "\n",
    "6. A 4000-year old method to compute the square root of 5 is as follows: Start with an initial guess, say 1. Then compute\n",
    "\n",
    " (1 +  5/1 )/2 = 3\n",
    "\n",
    " Next, take that 3 and replace the 1’s in the previous formula with 3’s . This gives\n",
    "\n",
    " (3 +  5/3 )/2 = 7/3 = 2.33\n",
    "\n",
    " Next replace the 3 in the previous formula with 7/3 . This gives\n",
    "\n",
    " (7/3 +  5/(7/3) )/2 = 47/22 = 2.24\n",
    "\n",
    " If you keep doing this process of computing the formula, getting a result, and plugging it back in, the values will eventually get closer and closer to 5 . This method works for numbers other than 5. Write a program that asks the user for a number and uses this method to estimate the square root of the number correct to within 10^( −10) . The estimate will be correct to within 10^( −10) when the absolute value of the difference between consecutive values is less than 10^(−10) .\n",
    "\n",
    "7. Write a program that starts with an 5 × 5 list of zeroes and randomly changes exactly ten of those zeroes to ones.\n",
    "\n",
    "8. Write a program in which you have a list that contains seven integers that can be 0 or 1. Find the first nonzero entry in the list and change it to a 1. If there are no nonzero entries, print a message saying so.\n",
    "\n",
    "9. Write a program to play the following simple game. The player starts with \\$100. On each turn a coin is flipped and the player has to guess heads or tails. The player wins \\$9 for each correct guess and loses \\$10 for each incorrect guess. The game ends either when the player runs out of money or gets to \\$200.\n",
    "\n",
    "10. Randomly generate a 6 × 6 list that has exactly 12 ones placed in random locations in the list. The rest of the entries should be zeroes.\n",
    "\n",
    "11. Randomly generate a 9 × 9 list where the entries are integers between 1 and 9 with no repeat entries in any row or in any column."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}