We could repeat code we need more than once:
i = 1
print (i)
i += 1
print (i)
i += 1
print (i) #... stop when i == 9
But each line means an extra line we might make an error on.
while loops
Instead, we can loop through the same code multiple times:
i = 1
while (i < 10):
print (i)
i += 1
This is far less error prone.
Note, same syntax of clause header, condition, suite of statements.
Infinite loops
Watch you don't do this:
i = 1
while (i < 10):
print(i)
i += 1
Note that sometimes you want an infinite loop:
while (True):
# Check for user interaction.
To break out of an infinite loop, use CTRL-C or equivalent.
Break
A bit like the evil goto, but cleaner.
Break ends looping entirely:
# Fine largest number in 1 million divisible by 17
i = 1000000
while (i != 0):
if (i % 17 == 0):
break
i -= 1
print (i)
Firstly we don't want to keep counting down, and secondly we don't want to do "a -= 1" before printing.
Continue
A bit like the evil goto, but cleaner.
Continue ends current loop and starts next:
# Sum all even numbers in 1 million
i = 1000001
sum = 0
while (i != 0):
i -= 1
if (i % 2 == 1):
continue
sum += i
print (sum)
This often goes some way to making the code easier to read when the alternative is complicated nested if statements.
while-else
It isn't commonly used, but you can put an "else" statement after while. This happens when the loop ends (which may be the first time), but not when the loop is broken out of.
Essentially, it mashes up a loop and an if statement.
while (current_count < estimate_file_count):
if file_not_found(current_count + ".txt"):
print ("less files than expected")
break
current_count += 1
else:
print (estimate_file_count + "files read")
Counting loops
What if we want to count? We could do this:
i = 0
while (i < 10):
print(i)
i += 1
However, there are lots of mistakes we could make here. ii = 0
while (i <= 10):
print(a) j += 1
for loops
Because of this, lots of languages have a 'for loop' construction, which places all these elements in one area, where they are clearly related and can't be lost.
for (int i = 0; i < 10; i++) { // Java example
for-loop
Python takes a different approach. Python works with sequences, that is, you give it an object containing the numbers, and it works through them one at a time.
for loop_control_target_variable in sequence:
# do this
for i in (1,2,3,4,5,6,7,8,9):
print(i)
for loop
This may seem strangely verbose, but it is very powerful. It means you can do this:
for name in ("Dale", "Albert", "Gordon", "Tamara")
print(name)
Moreover, the syntax will take a sequence object:
names = ("Dale", "Albert", "Gordon", "Tamara")
for name in names:
print(name)
You can imagine, for example, reading the names in from a file.
iterators
In fact, what is happening is that for loops work with a type of construct called an iterator.
Pretty much all sequences are iterable (that is, there's a "next" object) and have a function to get an iterator object representing themselves.
The iterator has a function that gives the for loop the next object in the sequence when asked.
This doesn't especially matter here, but the terminology is used a lot in the documentation and examples.
You can generate an iterator from a sequence yourself with:
a = iter(sequence)
Range and slices
As both ranges and slices can be treated as sequences, we can do this:
for i in range(10): # i = 0,1,2,3,4,5,6,7,8,9
for i in range(5,10): # i = 5,6,7,8,9
for i in range(5,10,2): # i = 5,7,9
names = ("Dale", "Albert", "Gordon", "Tamara", "Philip", "Chester", "Windom")
for name in names[1:5:2]: # name = "Albert", "Tamara"
Indices
To combine having a number and an object it indexes, we can do this:
names = ("Dale", "Albert", "Gordon", "Tamara", "Philip", "Chester", "Windom")
for i in range(len(names)):
print(i, names[i])
However, you cannot change i during this to skip objects:
for i in range(len(names)):
print(i, names[i])
i += 1
Assignment creates a new temporary variable, and the target variable resets to its next value at the top of the loop - it is coming from the iterator. This creates some issues...
Efficiency
Slices copy containers, while ranges are iterators that actually generate the values one at a time.
It is better, therefore, with long sequences to do:
names = ("Dale", "Albert", "Gordon", "Tamara", "Philip", "Chester", "Windom")
for i in range(2,len(names),2):
print(names[i])
Than
for name in names[2::2]:
print(name)
Modifying loop sequences
The one disadvantage of not having an index counter is that it makes it hard to remove items from a list.
Usually, if you add or remove something, you'd increase or decrease the loop counter to accommodate the change.
As you can't adjust the loop control target variable, you can't do this.
Example
names = ["Dale","Albert","Gordon","Tamara","Philip",
"Chester","Windom"] # Mutable list
for name in names:
names.remove(name)
print(names)
May think this removes all names, but infact, this happens:
internal index 0, Dale removed; Albert goes to position 0, Gordon to position 1, etc.
internal index goes to 1, now references Gordon, Gordon removed not Albert, Tamara moves to position 1...
Output is: Albert, Tamara, Chester, not nothing
Solution
For Python, it is recommended you loop through a copy of the list; you can copy a list with a complete slice.
names = ["Dale","Albert","Gordon","Tamara","Philip",
"Chester","Windom"] # Mutable list
for name in names[:]: # Note full slice
names.remove(name)
print(names)
This way you traverse every object in the copy, without missing any, because you're removing from a different list.
Break
If a for loop is terminated by break, the loop control target keeps its current value.
Again, you can add an extra else clause not visited when break acts.
for target in sequence: