1. Sequences and Indexing
A sequence is a type of thing that represents a:
Finite, ordered collection of things
Indexed by non- negative integers.
For example:
A list: ['red', 'white', 'blue']
A string: 'Check out Joan Osborne, super musician'
A tuple: (800, 400, 310)
You can still get to the items (aka elements) in the collection, by indexing:
colors = ['red', 'white', 'blue']
colors[0] has value 'red'
colors[1] has value 'white'
colors[2] has value 'blue'
Indexing starts at zero, not at one
The len function returns the length of the sequence, that is, the number of items in the sequence.

2. Patterns for Looping (“iterating”) through the items of sequences
Beginning To End
Basic idea: You want to iterate through ALL of a sequence, from its beginning to its end.
In this example, the code iterates through the entire FORWARDs looking at EVERY ITEM, printing those items.
for k in range(len(sequence)):
... sequence[k] ...
for k in range(len(sequence)):
print(sequence[k])
Be sure that you understand the use of the index k in the above example. It is not a “magic” symbol; it is just an ordinary variable that goes 0, 1, 2, ... per the range statement. Do you see now why the range statement is defined to start at 0 and ends one short of the value of its argument?

3. Patterns for Looping (“iterating”) through the items of sequences
Other Ranges
Basic idea: You want to iterate through PART of a sequence, or perhaps through it backwards, or some combination of both.
Form 1
Form 2
Form 3
for k in range(NUMBER):
... sequence[BLAH] ...
for k in range(BLAH):
... sequence[k] ...
m = ...
for k in range(NUMBER):
... sequence[m] ...
where NUMBER is the number of items in the sequence to examine and BLAH is some formula involving k that is carefully crafted to produce exactly the right indices.
where BLAH is some range OTHER than 0, 1, 2, ... that is carefully crafted to produce exactly the right indices.
where NUMBER is the number of items in the sequence to examine and m is an auxiliary variable that is carefully controlled to produce exactly the right indices.
Examples for each form. In each example, the code iterates through the code BACKWARDS looking at EVERY 3rd ITEM, printing those items.
last = len(sequence) – 1
for k in range(len(sequence) // 3):
print(sequence[last - (k * 3)])
last = len(sequence) - 1
for k in range(last, -1, -3):
print(sequence[k])
last = len(sequence) – 1
m = last
for k in range(len(sequence) // 3):
print(sequence[m])
m = m - 3

4. Patterns for Looping (“iterating”) through the items of sequences
Selecting Items
Basic idea: You examine all or some of the items in the sequence, but use an IF statement to process only ones that satisfy a certain condition.
In this example, the code selects the items that are integers (and counts them, returning the count).
for k in range(len(sequence)):
if ... sequence[k] ...:
... sequence[k] ...
def count_integers(sequence):
count = 0
for k in range(len(sequence)):
if type(sequence[k]) == int:
count = count + 1
return count
I have shown the pattern combined with the Beginning-To-End pattern, but it could also be used with any of the Other-Ranges patterns.

5. Patterns for Looping (“iterating”) through the items of sequences
Finding something
Basic idea: You examine all or some of the items in the sequence, looking for one that satisfies a certain condition. When you find such an item, you return its index (position) in the sequence. If there is no item in the sequence that meets the condition, you return -1.
for k in range(len(sequence)):
if ... sequence[k] ...:
return k
return -1
In this example, the code returns the index of the first item it finds that is bigger than 20.
def find_bigger_than_20(sequence):
for k in range(len(sequence)):
if sequence[k] > 20:
return k
return -1
I have shown the pattern combined with the Beginning-To-End pattern, but it could also be used with any of the Other-Ranges patterns.
In a variation of this pattern, the function might return True if it found an item that meets the condition, or False if not. Or, in another variation, it might return the item that is found, or None if there is no item in the sequence that meets the condition.
Note the placement of the second return statement. This is NOT the time for an if-else in the loop!

6. Patterns for Looping (“iterating”) through the items of sequences
Two places at once
Basic idea: At each iteration of the loop, you examine TWO items in the sequence during that iteration.
for k in range(BLAH):
... sequence[INDEX_1] ... sequence[INDEX_2] ...
In this example, the code compares each item to the NEXT item in the sequence, counting the number of times that the next one is bigger than the current one, and returns that count.
For example, if the sequence is
[9, 7, 12, 35, 24, 25],
the function returns 3 because 12 is bigger than 7, 35 is bigger than 12, and 25 is bigger than 24.
where:
BLAH is some range appropriate to the problem,
INDEX_1 is some function of k that gives ONE of the “two places at once” to examine, and
INDEX_2 is another function of k that gives the OTHER of the “two places at once” to examine.
Typically, INDEX_1 or INDEX_2 (but not both!) is simply k.
def count_increases(sequence):
count = 0
for k in range(len(sequence) - 1):
if sequence[k + 1] > sequence[k]:
count = count + 1
return count
You often have to restrict the range to less than the entire sequence when using this pattern, as in the example to the right.

7. Patterns for Looping (“iterating”) through the items of sequences
Parallel sequences
Basic idea: At each iteration of the loop, you examine TWO SEQUENCES, looking at the kth item of each, during that iteration.
for k in range(len(sequence1)):
... sequence1[k] ... sequence2[k] ...
In this example, the code compares each item in one sequence to its “parallel” item in the other sequence, counting the number of times that the latter is bigger than the former, and returns that count.
For example, if the sequences are:
[11, 22, 10, 44, 33, 12]
[55, 10, 30, 29, 31, 30]
then this function returns 3, since 55 > 11 and 30 > and 30 > 12.
The above assumes that the two sequences are the same length, but variations can remove that restriction.
def count_bigger(sequence1, sequence2):
count = 0
for k in range(len(sequence1)):
if sequence2[k] > sequence1[k]:
count = count + 1
return count
Using parallel sequences is an error-prone approach, since it is easy to modify one sequence and forget to modify the “parallel” sequence. Nonetheless, this is an important pattern to understand.

8. Patterns for Looping (“iterating”) through the items of sequences
Max or Min
Basic idea: You examine all or some of the items in the sequence, looking for the biggest (or smallest) one. Return the index of that item (or perhaps just the item itself).
k_for_max = 0
for k in range(1, len(sequence)):
if sequence[k] > sequence[k_for_max]:
k_for_max = k
return k_for_max
In this example, the code returns the index of the smallest item in the sequence.
def index_of_min(sequence):
k_for_min = 0
for k in range(1, len(sequence)):
if sequence[k] < sequence[k_for_min]:
k_for_min = k
return k_for_min
The above is for Max. Reverse the comparison in the IF statement for Min.
In a variation of this pattern, the function might return sequence[k_for_max] instead of k_for_max.
I have shown the pattern combined with the Beginning-To-End pattern, but it could also be used with any of the Other-Ranges patterns.
This pattern requires that the sequence be non-empty.
Do you see why the range starts at 1, not at 0?