User:Milanandreew/Python 3 Programming/Loops

While loops
This is our first control structure. Ordinarily the computer starts with the first line and then goes down from there. Control structures change the order that statements are executed or decide if a certain statement will be run. As a side note, decision statements (e.g.,  statements), which you learned about in the last chapter, also influence whether or not a certain statement will run. Here's the source for a program that uses the  control structure: So what does the program do? First it sees the line  and sets the variable a to zero. Then it sees  and so the computer checks to see if. The first time the computer sees this statement,  is zero, and zero is less than 5. In other words, while a is less than five, the computer will run the indented statements.

Here is another example of the use of : Notice how   is only run at the end. The  statement only affects the lines that are tabbed in (a.k.a. indented). The  means does not equal so   means until   is zero run the tabbed in statements that are afterwards.

Now that we have  loops, it is possible to have programs that run forever. An easy way to do this is to write a program like this: This program will output  until the heat death of the universe or until you stop it. The way to stop it is to hit the Control (or Ctrl) button and `c' (the letter) at the same time. This will kill the program. (Note: sometimes you will have to hit enter after the Control C.)

For loops
The next type of loop in Python is the  loop. Unlike in most languages,  requires some   object like a   or   to work. The output looks very familiar, but the program code looks different. The first line uses the  function. The  function uses two arguments like this. is the first number that is produced. is one larger than the last number. Note that this program could have been done in a shorter way: Here are some examples to show what happens with the  function: Another way to use the   function in a   loop is to supply only one argument: The above code acts exactly the same as: with 0 implied as the starting point.

The code would cycle through the  loop 10 times as expected, but starting with 0 instead of 1.

The next line  uses the   control structure. A  control structure looks like. is gone through starting with the first element of the list and going to the last. As  goes through each element in a list it puts each into. That allows  to be used in each successive time the for loop is run through. Here is another example to demonstrate: Notice how the for loop goes through and sets item to each element in the list. (Notice how if you don't want  to go to the next line add a comma at the end of the statement (i.e. if you want to print something else on that line). ) So, what is   good for? The first use is to go through all the elements of a list and do something with each of them. Here a quick way to add up all the elements: Or you could write a program to find out if there are any duplicates in a list like this program does: How does it work? Here is a special debugging version: Note: The reason there are so many  calls is because   calls can show the value of each variable at different times, and help debug the program. First the program starts with the old list. Next the program sorts the list. This is so that any duplicates get put next to each other. The program then initializes a (ious) variable. Next the first element of the list is deleted so that the first item is not incorrectly thought to be a duplicate. Next a  loop is gone into. Each item of the list is checked to see if it is the same as the previous. If it is a duplicate was found. The value of  is then changed so that the next time the for loop is run through   is the previous item to the current. Sure enough, the  is found to be a duplicate.

The other way to use  loops is to do something a certain number of times. Here is some code to print out the first 9 numbers of the Fibonacci series: Everything that can be done with  loops can also be done with   loops but   loops give an easy way to go through all the elements in a list or to do something a certain number of times.

The break statement
A -loop checks its termination condition before each entry into the loop body, and terminates if the condition has gone. Thus, the loop body will normally iterate zero, one or more complete times.

A -loop iterates its body once for each value returned from the iterator expression. Again, each iteration is normally of the complete loop body.

Sometimes you want to conditionally stop the loop in the middle of the loop body. An example situation might look like this:


 * 1) Obtain the next value to check
 * 2) Is there in fact another value to check? If not, exit the loop with failure.
 * 3) Is the value what I'm looking for? If so, exit the loop with success.
 * 4) Otherwise, go back to step 1.

As you can see, there are two possible exits from this loop. You can exit from the middle of a Python - or  -loop with the  -statement. Here is one way to write such a loop: The trouble with this is the asymmetry between the two ways out of the loop: one through normal -loop termination, the other through the. As a stylistic matter, it would be more consistent to follow this principle:


 * If one exit from a loop is represented by a, then all exits from the loop should be represented by  s.

In particular, this means that the loop construct itself becomes a “loop-forever” loop; the only out of it is via a  statement.

We can do this by explicitly dealing with an iterator yielding the values to be checked. Perhaps the  call above already yields an iterator; if not, it can be converted to one by wrapping it in a call to the   built-in function, and then using the   built-in function to obtain successive values from this iterator. Then the loop becomes: This uses the special Python value  to indicate that the iterator has reached its end. This is a common Python convention. But if you need to use  as a valid item in your sequence of values, then it is easy enough to define some other unique value (e.g. a custom dummy class) to represent the end of the list.

Exercise

 * 1) Write a programme that computes and prints the 1000th prime number.

Solution