Session 16 - Sets & Set Operations

Discussion prompt

Before we open Session 16 - Sets & Set Operations: without looking back, what was the main idea of Session 15 - Tuples & Unpacking, 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 set is a container like a list, with two twists: every item is unique (no duplicates), and there is no order (no first, no last, no index).

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 Curly braces with commas make a set 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.

Fill in the blanks

From Build a set and check its type — one line has had its right-hand side removed. Put it back.

colors = {1, 2, 3}
print(colors)
print(type(colors))

Why: colors is what everything below it consumes, so the wrong expression here fails later and somewhere else. Comma-separated values in {} with no colons make a set, not a dict.

Comparison matrix

From Build a set and check its type: refill the output column from what you know. The rest of the table is as it appeared.

Discussion prompt

Explain A set is a bag of stickers 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.

Annotate

Walk the callouts on Duplicates disappear. Each one is a place this is easy to get subtly wrong.

• The two extra 1s and the extra 2 collapse into one each.
• Verified by execution: only the three unique values survive, so len is 3.

Comparison matrix

From Set vs list vs dict at a glance: every row here is a choice with a cost. Fill the ordered? column, then say which row you would actually pick and what you give up for it.

Draw it

Draw what set() vs {} 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:

You want an empty set to fill up, so you reach for the braces.

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

Correct: You silently made an empty dict.

Call set() for an empty set.

Why: You silently made an empty dict. Later .add would fail and set operators would misbehave - all because of two braces.

Predict first

The table runs: start | {1, 2, 3} · s.add(4) | {1, 2, 3, 4}

In Adding, including a duplicate, given the rows so far: what is the next one — the row where step is s.add(2)?

Correct: s.add(2) | {1, 2, 3, 4}

Why: The relationship between the columns, not the individual numbers, is what generates the next row. 4 was not present, so the set grows to four items.

Step through it

Step through Adding, including a duplicate one row at a time. What is driving the change, and what would the row after the last one be?

1. Step 1: step is start
2. Step 2: step is s.add(4)
3. Step 3: step is s.add(2)

Put in order

Put the moves of Full trace: building a set in a loop into the order they have to happen.

1. Start empty, add each roll
2. Repeats add nothing
3. Trace every pass

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. seen begins as set(); each pass adds one roll.

Step through it

Step through Full trace: building a set in a loop one row at a time. What is driving the change, and what would the row after the last one be?

1. Step 1: r is 2
2. Step 2: r is 5
3. Step 3: r is 2
4. Step 4: r is 6
5. Step 5: r is 5

Sort into buckets

Every line below is part of the definition of set or of .discard vs .remove — one or the other, never both. Put each where it belongs.

set

An unordered collection of unique, hashable items.; Duplicates are dropped automatically and there is no positional order.

.discard vs .remove

Use .discard when the item may or may not be there (safe).; Use .remove only when you are sure it exists, or want the error if it does not.

b1

An unordered collection of unique, hashable items. Duplicates are dropped automatically and there is no positional order.

b2

Use .discard when the item may or may not be there (safe). Use .remove only when you are sure it exists, or want the error if it does not.

Step through it

Step through discard removes, and is safe when absent one row at a time. What is driving the change, and what would the row after the last one be?

1. Step 1: step is start
2. Step 2: step is s.discard(2)
3. Step 3: step is s.discard(99)

Predict first

A student writes this, and it looks reasonable:

You call .remove for an item that is not in the set.

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

Correct: 99 is not in the set, and .remove insists the item exists - so it crashes with the missing key.

Use .discard when the item might be missing.

Why: 99 is not in the set, and .remove insists the item exists - so it crashes with the missing key.

Discussion prompt

The rule this trap just fixed:

Real output: {1, 2, 3}. discard never raises for a missing item, so it is the safe default.

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.

Comparison matrix

From Membership checks: refill the output 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 treat the set like a list and grab item zero.

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

Correct: A set has no positions, so subscripting it is meaningless - Python refuses with 'not subscriptable'.

Loop over it, test with in, or sort it into a list first.

Why: A set has no positions, so subscripting it is meaningless - Python refuses with 'not subscriptable'.

Fill in the blanks

From Sort a set into a list — one line has had its right-hand side removed. Put it back.

letters = set("banana")
print(len(letters))
print(sorted(letters))

Why: letters is what everything below it consumes, so the wrong expression here fails later and somewhere else. The string's characters become items; repeats of a and n collapse.

Match the pairs

Match each term to the definition this lesson gave it — not the one you would guess from the word.

• t1. set
• t2. .discard vs .remove
• t3. hashable

• d1. An unordered collection of unique, hashable items. Duplicates are dropped automatically and there is no positional order.
• d2. Use .discard when the item may or may not be there (safe). Use .remove only when you are sure it exists, or want the error if it does not.
• d3. An item with a fixed hash value that does not change over its life. Lists and dicts are mutable, so they are unhashable and cannot go in a set.

Why: These are the working definitions of set, .discard vs .remove, hashable as Session 16 - Sets & Set Operations uses them. Pairing them correctly is the test of whether you could state each one with the slide switched off.

Predict first

A student writes this, and it looks reasonable:

You try to add a list as one item.

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

Correct: A list can change, so it has no stable hash - the set cannot store it and refuses with 'unhashable type'.

Use a tuple (unchangeable), which is hashable.

Why: A list can change, so it has no stable hash - the set cannot store it and refuses with 'unhashable type'.

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 set is a container like a list, with two twists: every item is unique (no duplicates), and there is no order (no first, no last, no index).; Write items between { and }, separated by commas: {1, 2, 3}. That is a set literal.; Picture a bag you drop labeled stickers into. You can ask 'is the red sticker in here?' and dump the bag out - but there is no 'sticker number 3'.

Breaks

You want an empty set to fill up, so you reach for the braces.; You call .remove for an item that is not in the set.

sound

These are stated as this lesson states them — each one survives the edge cases Session 16 - Sets & Set Operations 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.

Annotate

In Intersection of two sets, before reading the notes: mark where the time actually goes. Which line dominates?

• 3 is the only item in a and b at the same time.
• Verified by execution: just the single shared value.

Discussion prompt

Explain Difference - : in a but not b 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

Explain Symmetric difference ^ : in one, not both 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 Symmetric difference 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.

Put in order

Put the moves of All four operators at once into the order they have to happen.

1. Two attendance lists, four questions
2. sorted() gives a stable, readable order
3. Read every result

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. Union = anyone who came; intersection = came both days; difference = Monday-only; symmetric = came exactly one day.

Annotate

Walk the callouts on All four operators at once. Each one is a place this is easy to get subtly wrong.

• Union = anyone who came; intersection = came both days; difference = Monday-only; symmetric = came exactly one day.
• Sets are unordered, so sorting the results makes the output deterministic.
• Verified by execution: four people total; Ben and Cara both days; only Ana on Monday; Ana and Dan came exactly one day.

Discussion prompt

|, &, -, and ^ each return a new set and leave the two originals untouched. You usually store the result in a new name.

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.

Fill in the blanks

From The originals are unchanged — one line has had its right-hand side removed. Put it back.

a = {3, 4, 5}
b = ___
c = a & b
print(c)
print(a)
print(b)

Why: b is what everything below it consumes, so the wrong expression here fails later and somewhere else. The intersection is computed and stored in c; a and b are only read, not modified.

Comparison matrix

From The originals are unchanged: every row here is a choice with a cost. Fill the value after column, then say which row you would actually pick and what you give up for it.

Predict first

The table runs: a | b | union | in either (or both) · a & b | intersection | in both · a - b | difference | in a, not in b

In The four set operators, given the rows so far: what is the next one — the row where operator is a ^ b?

Correct: a ^ b | symmetric difference | in exactly one

Why: The relationship between the columns, not the individual numbers, is what generates the next row. Each takes two sets and returns a new set; pick by which items you want to keep.

Comparison matrix

From The four set operators: refill the keeps column from what you know. The rest of the table is as it appeared.

Check your understanding

What does this print?

• A. <class 'dict'> (correct)
• B. <class 'set'>
• C. set()
• D. <class 'list'>

Answer: A

Why: {} is an empty dict, not an empty set, so type(x) is dict. For an empty set you must call set(). Verified by execution.

Why B tempts people

Empty braces belong to dict; you only get a set from braces when there is at least one item inside.

Why C tempts people

set() is how you build an empty set, but it is not what {} produces - and type() prints <class ...>, not set().

Why D tempts people

Braces never make a list; a list uses square brackets [].

Check your understanding

What does this print?

• A. 3 (correct)
• B. 5
• C. 2
• D. Error - duplicate keys

Answer: A

Why: The set drops the repeated 1 and 3, leaving the unique values 1, 2, 3, so len is 3. Verified by execution.

Why B tempts people

5 is how many you typed; the set collapses duplicates before len counts, so it is 3.

Why C tempts people

Only the 1 and 3 were duplicated; 2 still counts, giving three unique values.

Why D tempts people

Duplicates in a set literal are not an error - they are silently dropped.

Check your understanding

What does this print?

• A. {1, 2, 3} (correct)
• B. KeyError: 9
• C. {1, 2, 3, 9}
• D. None

Answer: A

Why: discard on a missing item does nothing and never raises, so the set prints unchanged as {1, 2, 3}. Verified by execution.

Why B tempts people

KeyError is what .remove(9) would raise; .discard is the safe version that stays quiet.

Why C tempts people

discard removes items, it never adds; 9 does not get inserted.

Why D tempts people

print(s) shows the set, not None; discard returns None but we are printing s.

Check your understanding

What does this print?

• A. {2, 3} (correct)
• B. {1, 2, 3, 4}
• C. {1, 4}
• D. {1}

Answer: A

Why: & keeps only items in both sets. 2 and 3 appear in each, so the intersection is {2, 3}. Verified by execution.

Why B tempts people

That is the union (|), which keeps everything in either set - not the intersection.

Why C tempts people

{1, 4} is the symmetric difference (^): items in exactly one set, the opposite of what & keeps.

Why D tempts people

{1} is the difference {1, 2, 3} - {2, 3, 4}; & keeps the shared items, not the leftover ones.

Check your understanding

What happens?

• A. TypeError: 'set' object is not subscriptable (correct)
• B. 10
• C. It prints the smallest item, 10
• D. IndexError: set index out of range

Answer: A

Why: A set has no order or positions, so s[0] is not allowed and Python raises TypeError: 'set' object is not subscriptable. Verified by execution.

Why B tempts people

There is no 'first' item in a set, so s[0] never returns a value - it raises before printing.

Why C tempts people

Sets are not sorted and have no index; use sorted(s)[0] if you want the smallest.

Why D tempts people

The error is a TypeError (indexing is not supported at all), not an IndexError about range.

Check your understanding

What does this print?

• A. {1, 4} (correct)
• B. {2, 3}
• C. {1, 2, 3, 4}
• D. {}

Answer: A

Why: ^ keeps items in exactly one set. 2 and 3 are in both (dropped); 1 and 4 are each in only one, giving {1, 4}. Verified by execution.

Why B tempts people

{2, 3} is the intersection (&) - the shared items, which ^ removes rather than keeps.

Why C tempts people

That is the union (|). Symmetric difference excludes the items both sets share.

Why D tempts people

The sets do share 2 and 3, but 1 and 4 are unshared, so the result is not empty.

Check your understanding

What happens?

• A. TypeError: unhashable type: 'list' (correct)
• B. {1, 2, 3, 4}
• C. {1, 2, [3, 4]}
• D. It adds 3 and 4 separately

Answer: A

Why: A list is mutable, so it has no stable hash and cannot be a set item; .add raises TypeError: unhashable type: 'list'. Verified by execution.

Why B tempts people

add inserts its argument as one item, not several; and a list cannot be that item anyway.

Why C tempts people

A set cannot hold a list at all - it is unhashable, so nothing is stored and an error is raised.

Why D tempts people

add never splits its argument; to add 3 and 4 individually you would call add twice with numbers.

Draw it

One page, no notation unless you need it: draw how these connect — What a Set Is · The Empty Set Trap · Adding & Removing · Membership: in · Deduplicating a List · Unordered: No Indexing. Put an arrow wherever one of them is what makes another possible, and label the arrow with why.