Session 15 - Tuples & Unpacking

Discussion prompt

Before we open Session 15 - Tuples & Unpacking: without looking back, what was the main idea of Session 14 - Capstone: Adventure Game (Part 2), 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 tuple stores several values in order, just like a list - but once made, it cannot be changed.

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

Explain The comma is what makes a tuple by analogy to something with no Python Fundamentals 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.

Put in order

Put the moves of Make a tuple and read it into the order they have to happen.

1. Line 1 packs 3 and 4 into one tuple
2. Index with [0] and [1] just like a list
3. Read the output

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. point is a single value that holds two numbers in order.

Comparison matrix

From Make a tuple and read it: refill the value column from what you know. The rest of the table is as it appeared.

Discussion prompt

Explain A tuple is a sealed label 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.

Discussion prompt

(5,) versus (5) — before any calculation: what is the plan? Name the moves in order, in plain English, without doing the arithmetic.

Hint: It starts with: The trailing comma on line 1 builds a tuple

Comparison matrix

From (5,) versus (5): 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

A student writes this, and it looks reasonable:

You mean a one-item tuple, but write plain brackets.

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

Correct: Without the comma, the brackets just group a number, so y is the int 5 - later code that expects a tuple will misbehave.

Add the trailing comma.

Why: Without the comma, the brackets just group a number, so y is the int 5 - later code that expects a tuple will misbehave.

Discussion prompt

The rule this trap just fixed:

The comma builds the tuple - brackets are optional. Real output: (5,) and <class 'tuple'>. Rule of thumb: a single trailing comma is the whole difference.

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.

Sort into buckets

Every line below is part of the definition of tuple or of unpacking — one or the other, never both. Put each where it belongs.

tuple

An ordered, immutable sequence of values, written with commas and usually round brackets; Immutable means you cannot add, remove, or replace items after it is built.

unpacking

Assigning the items of a sequence to several variables at once; a, b, c = (1, 2, 3) sets a=1, b=2, c=3.; The count on the left must match the count on the right.

b1

An ordered, immutable sequence of values, written with commas and usually round brackets: (3, 4). Immutable means you cannot add, remove, or replace items after it is built.

b2

Assigning the items of a sequence to several variables at once: a, b, c = (1, 2, 3) sets a=1, b=2, c=3. The count on the left must match the count on the right.

Put in order

Put the moves of Pack, then unpack into the order they have to happen.

1. Line 1 packs three values
2. Line 3 unpacks it into a, b, c
3. Read the output

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. No brackets needed - the commas pack 1, 2, 3 into one tuple.

Annotate

Walk the callouts on Pack, then unpack. Each one is a place this is easy to get subtly wrong.

• No brackets needed - the commas pack 1, 2, 3 into one tuple.
• Three names on the left take the three items in order.
• Verified by execution: the tuple, then its three items spread across names.

Draw it

Draw what Two variables at once just did — the shape of it, not the line-by-line working. One picture, labels only where you need them. Then check it against the steps: anything you could not draw is a step you followed rather than understood.

Predict first

A student writes this, and it looks reasonable:

The count on the left does not match the tuple.

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

Correct: Python has nothing to give c, so it raises a ValueError instead of guessing.

Match the number of names to the number of values.

Why: Python has nothing to give c, so it raises a ValueError instead of guessing.

Step through it

Step through Trap: wrong number of values to unpack one row at a time. What is driving the change, and what would the row after the last one be?

1. Step 1: name is a
2. Step 2: name is b
3. Step 3: name is c

Predict first

The table runs: start | 10 | 3 · pack right side | 10 | 3

In Swap in one line, given the rows so far: what is the next one — the row where step is after swap?

Correct: after swap | 3 | 10

Why: The relationship between the columns, not the individual numbers, is what generates the next row. b is 3 and a is 10 right now, so it builds (3, 10) before assigning.

Fill in the blanks

From The old way, for contrast — one line has had its right-hand side removed. Put it back.

a, b = 10, 3
temp = a
a = b
b = temp
print(a, b)

Why: b is what everything below it consumes, so the wrong expression here fails later and somewhere else. Without temp, setting a = b would lose the old a.

Sort into buckets

Sort these by a, from memory, without looking back at The old way, for contrast. Telling them apart on the spot is the skill; the table is only where the answer happens to be written down.

10

start; temp = a

3

a = b; b = temp

g1

a is "10" for start, temp = a — that is what the table on "The old way, for contrast" records, and it is the single property separating this group from the rest.

g2

a is "3" for a = b, b = temp — that is what the table on "The old way, for contrast" records, and it is the single property separating this group from the rest.

Discussion prompt

Unpack each record in the loop — before any calculation: what is the plan? Name the moves in order, in plain English, without doing the arithmetic.

Hint: It starts with: Each item is a (name, score) tuple

Step through it

Step through enumerate gives (index, item) tuples one row at a time. What is driving the change, and what would the row after the last one be?

1. Step 1: pass is 1
2. Step 2: pass is 2
3. Step 3: pass is 3

Put in order

Put the moves of Return the low and high together into the order they have to happen.

1. return min(nums), max(nums) packs a tuple
2. The caller unpacks it into low, high
3. Or catch the whole tuple in one name

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. The comma makes one return value that holds both numbers.

Sort into buckets

Sort these by value, from memory, without looking back at Return the low and high together. Telling them apart on the spot is the skill; the table is only where the answer happens to be written down.

(1, 9)

min_max([4, 9, 1, 7]); result

1

low

9

high

g1

value is "(1, 9)" for min_max([4, 9, 1, 7]), result — that is what the table on "Return the low and high together" records, and it is the single property separating this group from the rest.

g2

value is "1" for low — that is what the table on "Return the low and high together" records, and it is the single property separating this group from the rest.

g3

value is "9" for high — that is what the table on "Return the low and high together" records, and it is the single property separating this group from the rest.

Comparison matrix

From **first, rest: refill the type* column from what you know. The rest of the table is as it appeared.

Step through it

Step through **a, mid, b* one row at a time. What is driving the change, and what would the row after the last one be?

1. Step 1: name is a
2. Step 2: name is mid
3. Step 3: name is b

Fill in the blanks

From List changes, tuple record stays put — one line has had its right-hand side removed. Put it back.

scores = [88, 72, 95]
scores[0] = 90
print(scores)
record = ("Ana", "2010-05-14")
print(record[0], record[1])

Why: scores is what everything below it consumes, so the wrong expression here fails later and somewhere else. scores[0] = 90 replaces the first item in place.

Predict first

A student writes this, and it looks reasonable:

You reach for a list habit and assign into a tuple.

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

Correct: A tuple cannot be edited in place, so Python raises a TypeError - the assignment never happens.

Build a fresh tuple instead of editing.

Why: A tuple cannot be edited in place, so Python raises a TypeError - the assignment never happens.

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 tuple stores several values in order, just like a list - but once made, it cannot be changed.; point = (3, 4) makes a tuple of two values. You read items by index with [ ], exactly like a list.; Picture a shipping label already printed and sealed: a name and a date, side by side, in a fixed order.

Breaks

You mean a one-item tuple, but write plain brackets.; The count on the left does not match the tuple.

sound

These are stated as this lesson states them — each one survives the edge cases Session 15 - Tuples & Unpacking 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.

Step through it

Step through A (row, col) coordinate as a key one row at a time. What is driving the change, and what would the row after the last one be?

1. Step 1: key is (0, 0)
2. Step 2: key is (1, 2)
3. Step 3: key is lookup (1, 2)

Discussion prompt

Explain When to use each 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 Tuples support read-only operations — one line has had its right-hand side removed. Put it back.

t = (1, 2, 3)
print(len(t))
print(2 in t)
print(t + (4, 5))
print(t * 2)

Why: t is what everything below it consumes, so the wrong expression here fails later and somewhere else. These read or build new tuples; none of them change t.

Discussion prompt

Explain Tuples still have count and index by analogy to something with no Python Fundamentals 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.

Draw it

Draw what count and index on a tuple just did — the shape of it, not the line-by-line working. One picture, labels only where you need them. Then check it against the steps: anything you could not draw is a step you followed rather than understood.

Predict first

The table runs: (1, 2) == (1, 2) | True · (1, 2) < (1, 3) | True

In Tuples compare item by item, given the rows so far: what is the next one — the row where comparison is (1, 5) < (2, 0)?

Correct: (1, 5) < (2, 0) | True

Why: The relationship between the columns, not the individual numbers, is what generates the next row. Two tuples are equal only when all their items match in order.

Annotate

Walk the callouts on Tuples compare item by item. Each one is a place this is easy to get subtly wrong.

• Two tuples are equal only when all their items match in order.
• Python compares the first items; only if they tie does it look at the next. Verified by execution.

Discussion prompt

Same indexing and looping; the split is whether the contents can change.

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 Session 15 - Tuples & Unpacking 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 Tuple or list? 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.

Check your understanding

What does this print?

• A. <class 'int'> (correct)
• B. <class 'tuple'>
• C. (7,)
• D. <class 'list'>

Answer: A

Why: Without a trailing comma, (7) is just the number 7 in brackets, so its type is int. A tuple would need (7,). Verified by execution.

Why B tempts people

A one-item tuple needs the comma: (7,). Plain (7) is only grouping brackets.

Why C tempts people

That is the value of a one-item tuple, but type() prints the class, and here x is not a tuple anyway.

Why D tempts people

Square brackets make a list; these are round grouping brackets around a single int.

Check your understanding

What does this print?

• A. 9 2 (correct)
• B. 2 9
• C. 9 9
• D. 2 2

Answer: A

Why: The right side packs the current values (9, 2) first, then unpacks them into a, b - so a becomes 9 and b becomes 2. Verified by execution.

Why B tempts people

That is the starting order; the swap line flips them before printing.

Why C tempts people

a is not copied into b twice - Python packs (b, a) as (9, 2) before assigning, so b keeps a distinct value.

Why D tempts people

b does not overwrite a first; the whole right side is evaluated before either name changes.

Check your understanding

What is the SECOND line of output?

• A. 2 two (correct)
• B. 1 one
• C. (2, 'two')
• D. 2 one

Answer: A

Why: On the second pass the loop hands over (2, 'two'), and n, word unpacks it to n=2 and word='two', printing 2 two. Verified by execution.

Why B tempts people

That is the first pass. The question asks for the second line, which uses the second tuple.

Why C tempts people

Because the for line unpacks into n and word, you print the two items with a space, not the whole tuple.

Why D tempts people

word comes from the same tuple as n, so it is 'two', not 'one' from the previous pass.

Comparison matrix

From Check: unpack in a loop: every row here is a choice with a cost. Fill the word column, then say which row you would actually pick and what you give up for it.

Check your understanding

What does print(rest) show?

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

Answer: A

Why: first takes 1, and *rest collects the remaining items into a list, so rest is [2, 3, 4]. A starred target always produces a list. Verified by execution.

Why B tempts people

A starred target collects into a list, not a tuple, even when the right side is a tuple.

Why C tempts people

rest gathers all leftover items, not just the next single one.

Why D tempts people

first has already taken the leading 1, so it is not part of rest.

Comparison matrix

From Check: star unpacking: refill the value column from what you know. The rest of the table is as it appeared.

Check your understanding

What happens?

• A. TypeError: 'tuple' object does not support item assignment (correct)
• B. t becomes (99, 2, 3)
• C. t becomes [99, 2, 3]
• D. IndexError: tuple index out of range

Answer: A

Why: Tuples are immutable, so assigning to t[0] raises TypeError: 'tuple' object does not support item assignment. The tuple is never changed. Verified by execution.

Why B tempts people

Immutability blocks the assignment - the item is never replaced, so t stays (1, 2, 3).

Why C tempts people

A tuple never turns into a list from an assignment; the operation just fails.

Why D tempts people

Index 0 is valid; the error is about assignment being disallowed, not a bad index.

Check your understanding

What does this print?

• A. (1, 9) (correct)
• B. 1 9
• C. [1, 9]
• D. 1

Answer: A

Why: return min(nums), max(nums) packs the two results into one tuple, so printing the call shows (1, 9). Verified by execution.

Why B tempts people

Printing the returned tuple shows it with brackets and a comma; 1 9 would need the values unpacked into two names first.

Why C tempts people

The comma builds a tuple, not a list - a list would need square brackets.

Why D tempts people

return sends back both values as one tuple, not just the minimum.

Draw it

One page, no notation unless you need it: draw how these connect — What a Tuple Is · Packing & Unpacking · The One-Line Swap · Unpacking in Loops · Returning Many Values · Star Unpacking. Put an arrow wherever one of them is what makes another possible, and label the arrow with why.