List Methods: append, sort, len

Discussion prompt

Before we open List Methods: append, sort, len: without looking back, what was the main idea of for Loops, and what could you do by the end of it that you could not do before?

Hint: One sentence for the idea, one for the skill. If the second one is blank, that is the part to revisit.

Discussion prompt

A list holds many values in order, inside square brackets: [3, 1, 2]. Each item has a position, and the list can grow while your program runs.

That is stated as though it always holds. Do one of two things: produce a case where it fails, or say precisely what rules such a case out. "It just does" is not on the menu.

Hint: Hunt at the extremes first — zero, one, negative, empty, equal. If every extreme survives, the reason they survive is the proof.

Sort into buckets

Every line below is part of the definition of list or of in place (mutate) — one or the other, never both. Put each where it belongs.

list

An ordered, changeable collection of values.; As a robot takes readings, you append each one onto a list so they pile up in order.

in place (mutate)

To change the original list directly instead of building a new one.; append() and sort() both mutate the list in place - the same list, now different.

b1

An ordered, changeable collection of values. As a robot takes readings, you append each one onto a list so they pile up in order.

b2

To change the original list directly instead of building a new one. append() and sort() both mutate the list in place - the same list, now different.

Discussion prompt

Explain Your list is a whiteboard, not a photocopy by analogy to something with no Python in it at all — a queue, a recipe, a map, a bank balance, whatever fits. Then say where your analogy breaks.

Hint: An analogy that never breaks is not an analogy, it is the same idea wearing a hat. Find the seam — that is the part that is actually new.

Discussion prompt

Explain append(): add one item to the end to a student a year behind you. No notation, no jargon they have not met — and it still has to be true.

Hint: If your explanation needs a symbol they have never seen, you are describing the notation rather than the idea.

Put in order

Put the moves of append in action into the order they have to happen.

1. Line 1: start with three items
2. Line 2: append(4) adds 4 to the end
3. Trace the list

Why: These are the moves of the worked example in the order it makes them, and each one is set up by the one before it. nums is now [3, 1, 2, 4]. It grew in place - same list, one longer.

Comparison matrix

From append in action: refill the code column from what you know. The rest of the table is as it appeared.

Predict first

A student writes this, and it looks reasonable:

Goal: add 3 and 4 onto [1, 2].

It is wrong. Say what breaks — and say it before you turn the page.

Correct: nums is [1, 2, [3, 4]] - length 3, not 4.

To add the numbers separately, join with + (or append each one).

Why: nums is [1, 2, [3, 4]] - length 3, not 4. The [3, 4] is a single nested item, not two new numbers.

Comparison matrix

From Trap: appending a list nests it: every row here is a choice with a cost. Fill the value column, then say which row you would actually pick and what you give up for it.

Predict first

The table runs: 1 | nums = [3, 1, 2] | [3, 1, 2] · 2 | nums.sort() | [1, 2, 3]

In Sorting low to high, given the rows so far: what is the next one — the row where step is 3?

Correct: 3 | print(nums) | [1, 2, 3]

Why: The relationship between the columns, not the individual numbers, is what generates the next row. Smallest to largest: the same list becomes [1, 2, 3].

Annotate

Walk the callouts on Sorting low to high. Each one is a place this is easy to get subtly wrong.

• Smallest to largest: the same list becomes [1, 2, 3].
• Verified by execution: prints [1, 2, 3].

Fill in the blanks

From Sorting high to low — one line has had its right-hand side removed. Put it back.

nums = [3, 1, 2]
nums.sort(reverse=True)
print(nums)

Why: nums is what everything below it consumes, so the wrong expression here fails later and somewhere else. Verified by execution: prints [3, 2, 1].

Predict first

A student writes this, and it looks reasonable:

A list with numbers AND text in it.

It is wrong. Say what breaks — and say it before you turn the page.

Correct: sort() works by checking which item is smaller.

Keep a list all one type. Sort numbers with numbers, words with words.

Why: sort() works by checking which item is smaller. It has no rule for "a" versus 1, so it stops with an error.

Discussion prompt

The rule this trap just fixed:

Verified by execution: [1, 2, 3]. A high-score board is all numbers, so you are safe.

Now break it on purpose. Build a case that violates it and follow the consequences until something visibly fails. Where does the failure first show up — and would you have noticed it if you had not been looking?

Hint: The dangerous rules are the ones whose violation still produces an answer. If yours fails loudly, try to find one that fails quietly.

Annotate

Walk the callouts on len() in action. Each one is a place this is easy to get subtly wrong.

• A four-item list gives 4; an empty list gives 0.
• Verified by execution: len("robot") is 5 - same idea, how many pieces are inside.

Discussion prompt

Explain "Do something" vs "give something" to a student a year behind you. No notation, no jargon they have not met — and it still has to be true.

Hint: If your explanation needs a symbol they have never seen, you are describing the notation rather than the idea.

Fill in the blanks

From Proof: append and sort return None — one line has had its right-hand side removed. Put it back.

nums = [3, 1, 2]
print(nums.append(4))
print(nums.sort())
print(len(nums))

Why: nums is what everything below it consumes, so the wrong expression here fails later and somewhere else. append and sort do their job on nums, but the call evaluates to None - so that is what prints.

Comparison matrix

From Proof: append and sort return None: refill the why column from what you know. The rest of the table is as it appeared.

Predict first

A student writes this, and it looks reasonable:

You want nums sorted, so you "save" the result.

It is wrong. Say what breaks — and say it before you turn the page.

Correct: Your sorted list is thrown away.

Call sort() on its own line. It already changes nums - don't assign it.

Why: Your sorted list is thrown away. nums is now None, not a list - your data is gone.

Sort into buckets

Some of these hold up and some are the exact mistakes this lesson is built to prevent. Sort them.

Holds up

A list holds many values in order, inside square brackets: [3, 1, 2]. Each item has a position, and the list can grow while your program runs.; Some list tools change the list itself - they add to it or rearrange it without making a new copy. That is called changing it in place.; nums.append(x) sticks x onto the end of nums, making the list one longer. It changes nums in place.

Breaks

Goal: add 3 and 4 onto [1, 2].; A list with numbers AND text in it.

sound

These are stated as this lesson states them — each one survives the edge cases List Methods: append, sort, len puts it through.

flawed

Each of these is lifted from a trap in this deck: reasonable-sounding, and wrong in a way that only shows up once you rely on it.

Discussion prompt

Explain append vs +: change one, or make a new one by analogy to something with no Python in it at all — a queue, a recipe, a map, a bank balance, whatever fits. Then say where your analogy breaks.

Hint: An analogy that never breaks is not an analogy, it is the same idea wearing a hat. Find the seam — that is the part that is actually new.

Fill in the blanks

From append vs + — one line has had its right-hand side removed. Put it back.

a = [1, 2]
a.append(3)
print(a)
b = [1, 2] + [3]
print(b)

Why: b is what everything below it consumes, so the wrong expression here fails later and somewhere else. Verified by execution: a.append(3) changes a in place; [1, 2] + [3] makes a new list stored in b.

Discussion prompt

A slice copies part of a list. nums[:3] gives the first three items as a new list.

That is stated as though it always holds. Do one of two things: produce a case where it fails, or say precisely what rules such a case out. "It just does" is not on the menu.

Hint: Hunt at the extremes first — zero, one, negative, empty, equal. If every extreme survives, the reason they survive is the proof.

Discussion prompt

Outside this lesson: where does List Methods: append, sort, len actually turn up? Name one concrete situation — a job, a piece of software someone ships, a decision somebody has to make — and say which part of The in-place method recipe is doing the work in it.

Hint: Vague is the failure mode here. "Engineering" is not a situation; "deciding whether this build is fast enough to ship" is.

Put in order

Put the moves of Build it (1/4): start empty, append five scores into the order they have to happen.

1. Line 1: start from an empty list
2. Lines 2-6: each append adds one score to the end
3. Trace the list as it grows

Why: These are the moves of the worked example in the order it makes them, and each one is set up by the one before it. scores is [] - length 0. Every game will append onto it.

Annotate

In Build it (1/4): start empty, append five scores, before reading the notes: mark where the time actually goes. Which line dominates?

• scores is [] - length 0. Every game will append onto it.
• The list grows by one item each time, in place - no new lists, no assignments.
• Verified by execution: prints [50, 90, 70, 60, 80] and 5.

Predict first

The table runs: 1 | scores = [50, 90, 70, 60, 80] | [50, 90, 70, 60, 80] · 2 | scores.sort(reverse=True) | [90, 80, 70, 60, 50]

In Build it (2/4): sort the board high to low, given the rows so far: what is the next one — the row where step is 3?

Correct: 3 | print(scores) | [90, 80, 70, 60, 50]

Why: The relationship between the columns, not the individual numbers, is what generates the next row. Verified by execution: [90, 80, 70, 60, 50] - in place, on its own line.

Predict first

Put it together: sort high-to-low, then announce how many games with len and the winner with scores[0].

Commit before you compute: what does Build it (3/4): the ranked board with len come out to? A rough magnitude and the right form is enough — the point is to have something concrete to be wrong about.

Correct: Sort first, then read from the ordered list

Why: A prediction you can defend turns the computation into a check rather than a leap of faith — and an answer that contradicts it is caught on the spot. After sorting, scores[0] is the highest.

Discussion prompt

Work backwards. The example finished here:

Sort first, then read from the ordered list

What was it asked to do, and what must it have been given? Reconstruct the problem from its answer.

Hint: Every quantity in the result had to enter somewhere. Account for each one.

Predict first

Stretch goal: print only the podium. Sort high-to-low, then slice the first three.

Commit before you compute: what does Build it (4/4): stretch - top three only come out to? A rough magnitude and the right form is enough — the point is to have something concrete to be wrong about.

Correct: Slice after sorting to grab the best three

Why: A prediction you can defend turns the computation into a check rather than a leap of faith — and an answer that contradicts it is caught on the spot. Verified by execution: scores[:3] is [90, 80, 70], printed as Podium: [90, 80, 70].

Comparison matrix

From Build it (4/4): stretch - top three only: every row here is a choice with a cost. Fill the value column, then say which row you would actually pick and what you give up for it.

Check your understanding

What does this print?

• A. [5, 2, 8] (correct)
• B. [8, 5, 2]
• C. [5, 2, [8]]
• D. [5, 10]

Answer: A

Why: append adds its argument as one item at the END of the list, in place. So nums becomes [5, 2, 8]. Verified by execution.

Why B tempts people

append always adds to the end, never the front. To put 8 at the front you would use nums.insert(0, 8).

Why C tempts people

append(8) adds the number 8, not a list [8]. You only see inner brackets if you append a list, like append([8]).

Why D tempts people

append adds a separate item; it does not add 8 onto the last number. The list gets one item longer, values never merge.

Check your understanding

What does this print?

• A. None (correct)
• B. [1, 2, 3]
• C. [3, 1, 2]
• D. [3, 2, 1]

Answer: A

Why: sort() reorders the list in place and returns None. Storing that None into nums throws the list away, so nums is None and print shows None. Fix it by calling nums.sort() on its own line. Verified by execution.

Why B tempts people

This is what you wanted, but sort() returns None, not the sorted list. The assignment nums = nums.sort() overwrites your list with None.

Why C tempts people

The original list is gone too - the assignment replaced nums entirely with sort()'s return value, which is None.

Why D tempts people

Plain sort() is low-to-high, not reverse - but more importantly the result here is None because of the assignment, not any list at all.

Comparison matrix

From Check yourself: the None trap: refill the nums column from what you know. The rest of the table is as it appeared.

Check your understanding

What does len(data) print?

• A. 4 (correct)
• B. 5
• C. 3
• D. 2

Answer: A

Why: append adds the whole list [4, 5] as ONE item, so data is [1, 2, 3, [4, 5]] - four items. len counts top-level items, not the numbers inside the nested list. Verified by execution.

Why B tempts people

Assumed [4, 5] merged in to give [1, 2, 3, 4, 5]. append adds it as a single nested item, so the length is 4, not 5.

Why C tempts people

Forgot that append added anything. It always adds exactly one item, taking the count from 3 up to 4.

Why D tempts people

Undercounted the original items - data already held 1, 2, 3 before the append.

Check your understanding

What does this print?

• A. [7, 4, 3, 1] (correct)
• B. [1, 3, 4, 7]
• C. [4, 1, 7, 3]
• D. [7, 1, 4, 3]

Answer: A

Why: sort(reverse=True) orders the list from largest to smallest, in place: [7, 4, 3, 1]. Verified by execution.

Why B tempts people

That is plain sort() order, low-to-high. reverse=True flips it to high-to-low.

Why C tempts people

sort() changes the list in place, so nums really is reordered even though sort() itself returns None. print(nums) shows the sorted list.

Why D tempts people

sort fully orders the list; it does not partially shuffle. The correct high-to-low order is [7, 4, 3, 1].

Check your understanding

What does len(scores) print?

• A. 3 (correct)
• B. 0
• C. 235
• D. 1

Answer: A

Why: Three appends add three items to the empty list, so it holds [80, 95, 60] and len is 3. len counts how many items there are, not their total. Verified by execution.

Why B tempts people

scores started empty, but each append adds one item in place. After three appends it holds 3 items, not 0.

Why C tempts people

Added the score values (80 + 95 + 60 = 235). len counts how many items there are - 3 - not their sum.

Why D tempts people

Counted only one append. All three lines run, each adding an item, so the final count is 3.

Draw it

One page, no notation unless you need it: draw how these connect — The in-place method recipe · A list is an ordered collection · The big idea: changing a list "in place" · Your list is a whiteboard, not a photocopy · append(): add one item to the end. Put an arrow wherever one of them is what makes another possible, and label the arrow with why.