Challenge — List Lab

By the end of this lesson you can:

• Find the maximum value in a list without using max(), by sweeping with a "best so far" variable.
• Compute a sum and a count by setting a variable to 0 before the loop and adding to it inside.
• Spot duplicates by checking, for each item, whether it appears again later in the list.

You've seen max() mentioned in passing — give it a list of numbers, get back the biggest. sum() adds them all up. Today we ignore those and write the loops ourselves. Why? Because tomorrow you'll need the same shape of loop for a task no built-in solves — and the only way to know that shape is to have written it once.

Predict-the-output. What does this print?

scores = [70, 92, 65, 88, 73]
best = scores[0]
for s in scores:
    if s > best:
        best = s
print(best)

92

Pattern 1 · Best so far (max, min)

Set best to the first item. Walk the list. Whenever something beats the current best, replace it. At the end, best holds the answer.

best = numbers[0]
for n in numbers:
    if n > best:
        best = n

Pattern 2 · Running total (sum, average)

Set total to 0. Walk the list. Add each number to total.

total = 0
for n in numbers:
    total = total + n

Pattern 3 · Running counter (count)

Set count to 0. Walk the list. Add 1 only when an item matches a condition (e.g. equals a target).

count = 0
for item in items:
    if item == target:
        count = count + 1

Pattern 4 · "Have I seen this before?" (duplicates)

Keep a second list of items already seen. For each item, check whether it's already in the seen list. If yes — duplicate. If no — add it to seen and move on.

seen = []
duplicates = []
for item in items:
    if item in seen:
        duplicates.append(item)
    else:
        seen.append(item)

The in keyword does the "is this item already in the list?" check — and you used .append() back in PY-L1-17 to grow a list one item at a time. Same tools, new combination.

Save the file as list_lab.py. We'll build all four sweeps in one file, sharing the same opening list so you can compare results.

Code · shared setup

# list_lab.py — four list sweeps, written from scratch

# A class's quiz scores. Notice 88 and 73 appear twice — useful later.
scores = [70, 92, 65, 88, 73, 88, 100, 73, 54, 92]

Task 1 · MAX — without max()

Daniel wants to know the highest score in the class. We sweep the list with a "best so far" tracker.

Code

# Task 1 — biggest number
highest = scores[0]
for score in scores:
    if score > highest:
        highest = score
print("Highest:", highest)

Output

Highest: 100

Two tiny rules. Seed highest with a real list item, not 0 (negatives would break it). Update only when score > highest — the equality case wouldn't hurt, but the strict > is the cleanest reading: "strictly better than my current champion".

Task 2 · SUM — without sum()

Aisyah wants the class total to compute the average later. Running total — empty bowl before the loop, ladle one number in per pass.

Code

# Task 2 — running total
total = 0
for score in scores:
    total = total + score
print("Total:", total)
print("Average:", total / len(scores))

Output

Total: 785
Average: 78.5

Once you have the total, the average is one extra line — total divided by count. We use len(scores) for the count because we want the program to keep working even if someone adds more scores to the list. Hard-coding 10 would silently lie the moment the list grew to eleven.

Task 3 · COUNT — how many times does a target appear?

Hafiz keeps getting 73 — is he the only one? Let's count how many students scored exactly 73.

Code

# Task 3 — count one target value
target = 73
count = 0
for score in scores:
    if score == target:
        count = count + 1
print(target, "appeared", count, "times")

Output

73 appeared 2 times

The shape is almost identical to the running total — the only difference is that we add 1 (not the score) and only when the value matches. That conditional + 1 is the "running counter" pattern, and you'll use it everywhere: counting passes, counting upvotes, counting hits.

Task 4 · DUPLICATES — which items appear more than once?

For the prize-giving, Mei wants to know which scores were repeated — those students could break a tie with a quiz-off.

Code

# Task 4 — find duplicates by tracking what we've seen
seen = []
duplicates = []
for score in scores:
    if score in seen:
        if score not in duplicates:
            duplicates.append(score)
    else:
        seen.append(score)
print("Duplicates:", duplicates)

Output

Duplicates: [88, 73, 92]

Two helper lists. seen remembers every value we've already walked past. duplicates collects the repeats. The extra inner if score not in duplicates stops the same number being added twice if it shows up three or more times — try changing the list so a value appears four times, and watch duplicates still list it just once. Without that inner check you'd get [88, 73, 92, 92], which is itself confusingly duplicated.

Pick at least two. Each starts from one of the four worked examples — tweak it, don't rebuild it.

lowest = scores[0]
for score in scores:
    if score < lowest:
        lowest = score
print("Lowest:", lowest)

passes = 0
for score in scores:
    if score >= 75:
        passes = passes + 1
print("Passes:", passes)

orders = ["nasi lemak", "roti canai", "nasi lemak", "satay",
          "roti canai", "nasi lemak", "mee goreng", "satay",
          "nasi lemak", "satay"]

best_dish  = orders[0]
best_count = 0
seen = []
for dish in orders:
    if dish in seen:
        continue
    seen.append(dish)
    count = 0
    for d in orders:
        if d == dish:
            count = count + 1
    if count > best_count:
        best_count = count
        best_dish  = dish

print("Most ordered:", best_dish, "—", best_count, "times")

Four sweeps, one shape: seed before, walk through, update inside, print after. Once that pattern lives in your fingers, you can answer almost any "summarise this list" question — even ones no built-in solves. Built-ins are convenience, not magic; behind every max() in the Python source is a sweep that looks just like the one you wrote today.