CPX18Selection, Loops, Lists and Records

Selection chooses which code to run, depending on whether a condition is True or False.

• The code that belongs to an if, elif or else is the indented block under it. The line after the block runs whatever happened.
• For ranges, test in order from one end: start at the top with >, or at the bottom with <. In the wrong order, a value can fall into the wrong band.
• One if … elif … else is better than several separate ifs. It stops testing once one condition is True, and only one block can run.
• You can nest selection (an if inside another), but elif is usually clearer.

windSpeed = 38

if (windSpeed < 20):
    print ("Calm")
elif (windSpeed < 40):
    print ("Breezy")
elif (windSpeed < 62):
    print ("Gale")
else:
    print ("Storm")

Selection

Choosing which statements to run depending on a condition.

Nested selection

An if statement inside another if statement.

A count-controlled loop repeats a set number of times, known before the loop starts.

• range (start, stop, step) counts from start up to but not including stop, adding step each time.
• To include a last value, make stop one more than it: 1 to 10 is range (1, 11).
• Counting down needs a negative step, and stop one below the last value: 5 down to 1 is range (5, 0, -1).
• The loop variable can be used inside the loop. Don’t change it yourself.

The stop value is never included

for times in range (1, 13):
    print ("7 x " + str (times) + " = " + str (7 * times))

Repetition

Going round a loop running the same instructions while a condition is True (or a set number of times).

Count-controlled loop

A loop whose number of passes is known before it starts, e.g. for … in range ().

A condition-controlled loop repeats while a condition is True. The number of passes isn’t known when it starts.

• while (condition): tests the condition before each pass. If it is False the first time, the body never runs.
• Something inside the loop must eventually make the condition False, or the loop never ends (an infinite loop).
• A sentinel value is a special input that means ‘stop’, such as an empty string, 0 or −1. Pick one that can’t be real data.
• Pattern for input loops: take the first input before the loop, and the next input as the last line inside the loop.
• A Boolean flag such as finished = False can control a loop: the loop sets it to True when it should stop. This gives the loop one exit. Pearson’s guidance is to avoid break.

total = 0.0
donations = 0

donation = float (input ("Donation (0 to finish): "))
while (donation != 0):
    total = total + donation
    donations = donations + 1
    donation = float (input ("Donation (0 to finish): "))

print ("Donations:", donations)
print ("Total: £" + "{:.2f}".format (total))

Condition-controlled loop

A loop that repeats while a condition is True; the number of passes isn’t known in advance.

Sentinel value

A special value, such as −1 or an empty string, that tells a loop to stop.

Infinite loop

A loop whose condition never becomes False, so it never stops.

Flag

A Boolean variable that records whether something has happened, e.g. found = True.

Pearson uses iteration for a loop that processes every item in a data structure, such as a list or a string.

• Use for item in list: when you just need each value.
• Use for index in range (len (list)): when you need the position too: to change an item, to report where it is, or to use the same index in another list.
• Use a while loop with an index when the loop may need to stop early (see linear search).
• Pearson says not to worry about fine distinctions. If a task says ‘iteration’, a for loop over the structure is expected.

pulseRates = [72, 65, 80, 77]
for rate in pulseRates:
    print (rate)
for index in range (len (pulseRates)):
    pulseRates[index] = pulseRates[index] + 2
print (pulseRates)

Iteration

Going round a loop until every item in a data structure has been processed.

An array is a sequence of items of the same data type. In Python an array is a list. Indexes start at 0.

• The last index is always len (list) - 1. Using list[len (list)] causes an IndexError.
• append and insert make the list longer and del makes it shorter, so later items move to new indexes.
• Build a list as the program runs: start with [], then append each new item.
• print (nums) shows the brackets and commas. To show items neatly, print them one at a time in a loop.

queue = ["Ava", "Ben"]
queue.append ("Cal")
queue.insert (0, "Dee")
del queue[2]
queue[1] = "Eli"

Array

A sequence of items of the same (homogeneous) data type. Python uses a list.

Index

An item’s position in a list or string, starting from 0.

IndexError

The runtime error when an index is outside the list.

A record is a sequence of items, usually of mixed data types. Each item is a field. In Python a record is also a list.

• One record: boat = ["T02", "Canoe", 3, 42.5]. boat[1] is the field "Canoe".
• A two-dimensional list is a list of lists. A table of records is a list of records: boats = [[…], […], […]].
• boats[1] is a whole record. boats[1][3] is one field: the price of record 1.
• Every record in a table has the same number of fields, in the same order. The PLS doesn’t use ragged lists, where rows have different lengths.
• len (boats) is the number of records. len (boats[0]) is the number of fields in a record.
• Add a record with boats.append (["T04", "Pedalo", 4, 30.0]). Remove one with del boats[2].
• Keeping related data in one table is better than separate (parallel) lists that share an index. Parallel lists are easy to get out of step.

First index: which record (row). Second index: which field

Record

A sequence of items, usually of mixed data types. Python uses a list.

Field

One item in a record, e.g. the price.

Two-dimensional list

A list of lists. Two indexes are needed to reach one item: table[row][field].

To visit every item of a two-dimensional list, put one loop inside another. The outer loop goes through the records and the inner loop through the fields of each record.

• for record in table: then for item in record: visits every item, row by row.
• With indexes: for row in range (len (table)): then for col in range (len (table[row])):, using table[row][col].
• The inner loop runs completely for each pass of the outer loop. 4 records × 3 fields = 12 passes of the inner body.
• Reset a per-row total inside the outer loop, before the inner loop. Keep a grand total outside both loops.
• When you only need one field from each record, you don’t need an inner loop: for record in table: then use record[2].

sales = [[12, 15, 9],
         [7, 11, 14],
         [20, 18, 16]]
grandTotal = 0

for booth in range (len (sales)):
    boothTotal = 0
    for day in range (len (sales[booth])):
        boothTotal = boothTotal + sales[booth][day]
    print ("Booth", booth + 1, "sold", boothTotal)
    grandTotal = grandTotal + boothTotal

print ("All booths:", grandTotal)

A linear search checks each item in turn until it finds the target or reaches the end. In Python, write it as a while loop with a Boolean flag, so it can stop as soon as the item is found.

• Three things end the search: the item is found, the end of the list is reached, or (in a sorted list) the search has passed where the item would be.
• Put all the stopping tests in the while condition. The loop then has one exit, which is easier to follow and debug than break.
• A for loop over the whole list always checks every item, even after a match. That is less efficient and loses design marks in long questions.
• In a list sorted into ascending order, once the current item is greater than the target, the target can’t be further on, so stop.
• After the loop, use the flag to decide what to output.

The loop has one exit: the condition at the top

bookedSeats = [4, 9, 15, 16, 23, 31]
found = False
passed = False
index = 0

seat = int (input ("Seat number: "))
while ((not found) and (not passed) and (index < len (bookedSeats))):
    if (bookedSeats[index] == seat):
        found = True
    elif (bookedSeats[index] > seat):
        passed = True
    else:
        index = index + 1

if (found):
    print ("Seat", seat, "is booked")
else:
    print ("Seat", seat, "is free")

Linear search

Checking each item in turn, from the start, until the target is found or there are no items left.

Single exit

A loop or subprogram that can only finish in one place, e.g. when its while condition is False.

• Start ‘largest’ at the first item (or at a value lower than any possible item). Starting at 0 fails if every item is negative.
• To remember which record was largest, also store its name (or index) when you update the largest value.
• Check that a count isn’t 0 before dividing by it, or you get a ZeroDivisionError.
• Merging two sorted lists (the merge step of merge sort): while both lists have items left, compare the front items and append the smaller, moving that list’s index on. Then copy whatever is left in either list.

Pearson expects you to be able to code this merge with while loops

listA = [3, 8, 12]
listB = [5, 6, 14, 20]
merged = []
indexA = 0
indexB = 0

while ((indexA < len (listA)) and (indexB < len (listB))):
    if (listA[indexA] <= listB[indexB]):
        merged.append (listA[indexA])
        indexA = indexA + 1
    else:
        merged.append (listB[indexB])
        indexB = indexB + 1

while (indexA < len (listA)):
    merged.append (listA[indexA])
    indexA = indexA + 1

while (indexB < len (listB)):
    merged.append (listB[indexB])
    indexB = indexB + 1

print (merged)

Merge

Combining two sorted lists into one sorted list by repeatedly taking the smaller front item.