Session 25 - Dunder Methods

Discussion prompt

Before we open Session 25 - Dunder Methods: without looking back, what was the main idea of Session 24 - Methods & Encapsulation, 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

When you write len(x), x == y, or print(x), Python quietly looks for a specially-named method on x and calls it. Define that method and the syntax works on your objects.

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 You already know one: __init__ 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 __init__ builds the object's data — one line has had its right-hand side removed. Put it back.

class Point:
def __init__(self, x, y):
self.x = x
self.y = y

p = Point(1, 2)
print(p.x, p.y)

Why: p is what everything below it consumes, so the wrong expression here fails later and somewhere else. You wrote Point(1, 2), not p.__init__(...).

Comparison matrix

From __init__ builds the object's data: refill the value column from what you know. The rest of the table is as it appeared.

Discussion prompt

Explain Dunders are Python's connectors 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

In What print shows with no dunders, before reading the notes: mark where the time actually goes. Which line dominates?

• So print falls back to the default: the class location and a memory address.
• Verified by execution: prints <__main__.Point object at 0x...>. The 0x... hex differs every run - it is where the object lives in memory, not its data.

Sort into buckets

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

dunder method

A method whose name is wrapped in double underscores, like __init__ or __len__.; 'Dunder' = 'double underscore'.; Python calls them for you when the matching syntax runs - you rarely call them by name.

__str__

Returns the 'nice' string for an object.; Called by print(x) and str(x).; If it is missing, Python uses __repr__ instead.

b1

A method whose name is wrapped in double underscores, like __init__ or __len__. 'Dunder' = 'double underscore'. Python calls them for you when the matching syntax runs - you rarely call them by name.

b2

Returns the 'nice' string for an object. Called by print(x) and str(x). If it is missing, Python uses __repr__ instead.

Comparison matrix

From Add __str__ and print improves: every row here is a choice with a cost. Fill the you get column, then say which row you would actually pick and what you give up for it.

Sort into buckets

These are the pieces of Session 25 - Dunder Methods, out of order. Put each one back under the part of the lesson it belongs to.

Hooks into Syntax

A dunder method hooks Python syntax; You already know one: __init__; __init__ builds the object's data

The Default repr

Every object already has a text form; What print shows with no dunders; That address tells you nothing useful

__str__ and __repr__

__str__ is the friendly form; Add __str__ and print improves; __repr__ is the unambiguous form

s1

Hooks into Syntax is where Session 25 - Dunder Methods puts A dunder method hooks Python syntax, You already know one: __init__, __init__ builds the object's data. Knowing which part of the lesson a problem belongs to is most of knowing which method to reach for.

s2

The Default repr is where Session 25 - Dunder Methods puts Every object already has a text form, What print shows with no dunders, That address tells you nothing useful. Knowing which part of the lesson a problem belongs to is most of knowing which method to reach for.

s3

__str__ and __repr__ is where Session 25 - Dunder Methods puts __str__ is the friendly form, Add __str__ and print improves, __repr__ is the unambiguous form. Knowing which part of the lesson a problem belongs to is most of knowing which method to reach for.

Predict first

The table runs: print(p) | __repr__ (no __str__) | Point(1, 2) · repr(p) | __repr__ | Point(1, 2)

In Add __repr__: print, repr, and the shell, given the rows so far: what is the next one — the row where call is p in the shell?

Correct: p in the shell | __repr__ | Point(1, 2)

Why: The relationship between the columns, not the individual numbers, is what generates the next row. print prefers __str__, but if there is no __str__ it falls back to __repr__ - so both lines use the same string here.

Annotate

Walk the callouts on Add __repr__: print, repr, and the shell. Each one is a place this is easy to get subtly wrong.

• print prefers __str__, but if there is no __str__ it falls back to __repr__ - so both lines use the same string here.
• Verified by execution: prints Point(1, 2) on both lines. In the shell, just typing p would also echo Point(1, 2).

Fill in the blanks

Only __repr__ covers str and lists, with the scaffolding fading: two lines are gone now — fill both.

class Dog:
def __init__(self, name):
self.name = name
def __repr__(self):
return f"Dog(Dog("Rex"))"

d = ___
print(d)
print(str(d))
print([d])

Why: Reproducing these unaided, rather than reading them, is what tells you the method has transferred. With no __str__, all three routes fall back to __repr__.

Step through it

Step through Only __repr__ covers str and lists one row at a time. What is driving the change, and what would the row after the last one be?

1. Step 1: call is print(d)
2. Step 2: call is print(str(d))
3. Step 3: call is print([d])

Step through it

Step through Both defined: each route picks its own one row at a time. What is driving the change, and what would the row after the last one be?

1. Step 1: call is print(t)
2. Step 2: call is repr(t)
3. Step 3: call is [t]

Predict first

A student writes this, and it looks reasonable:

You define __str__, then print a list of objects and expect the friendly strings.

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

Correct: A container prints each item with __repr__, not __str__.

Define __repr__ (the form containers use). Then lists show it - and print/str fall back to it too.

Why: A container prints each item with __repr__, not __str__. Point has no __repr__, so you get the default addresses back - exactly what you were trying to avoid.

Discussion prompt

The rule this trap just fixed:

Verified by execution: prints [Point(1, 2), Point(3, 4)]. Rule of thumb: for anything you will see inside a list or dict, you want __repr__.

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.

Match the pairs

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

• t1. __str__
• t2. __repr__
• t3. identity vs equality

• d1. Returns the 'nice' string for an object. Called by print(x) and str(x). If it is missing, Python uses __repr__ instead.
• d2. Returns the 'developer' string for an object. Called by repr(x), by the interactive shell (echoing a value), and by containers (lists, dicts) when they print their items.
• d3. Identity (is): the very same object. Equality (==): objects that count as equal by their values. Default == uses identity; __eq__ lets you define value equality instead.

Why: These are the working definitions of __str__, __repr__, identity vs equality as Session 25 - Dunder Methods uses them. Pairing them correctly is the test of whether you could state each one with the slide switched off.

Draw it

Draw what Equal-looking Points, == is False 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 built two objects with the same data and check whether they match.

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

Correct: got and wanted carry identical values but are distinct objects, so == is False and the else branch runs - even though a human would call them equal.

Define __eq__ so == compares the values you care about.

Why: got and wanted carry identical values but are distinct objects, so == is False and the else branch runs - even though a human would call them equal.

Sort into buckets

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

Holds up

__init__ is a dunder. You never call obj.__init__() yourself - Python runs it when you write ClassName(...). Every dunder works the same way: a name Python watches for.; Think of Python's syntax - +, ==, len(), print(), sorting - as sockets. A dunder method is the plug on your class that fits one of those sockets.; Print an object with no dunders and Python still shows something: a fallback built into every object. It is technically correct but useless to a human.

Breaks

You define __str__, then print a list of objects and expect the friendly strings.; You built two objects with the same data and check whether they match.

sound

These are stated as this lesson states them — each one survives the edge cases Session 25 - Dunder Methods 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.

Comparison matrix

From __eq__ powers != and in too: refill the result column from what you know. The rest of the table is as it appeared.

Fill in the blanks

From len() before __len__: TypeError — one line has had its right-hand side removed. Put it back.

class Team:
def __init__(self, members):
self.members = members

t = Team(["Ana", "Ben", "Cid"])
print(len(t))

Why: self.members is what everything below it consumes, so the wrong expression here fails later and somewhere else. len() looks for the dunder, does not find it, and refuses - it will not guess.

Step through it

Step through Add __lt__ and sorted() ranks them one row at a time. What is driving the change, and what would the row after the last one be?

1. Step 1: sorted position is 1st
2. Step 2: sorted position is 2nd
3. Step 3: sorted position is 3rd

Draw it

Draw what + before __add__: TypeError 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.

Fill in the blanks

Add __add__: + builds a new object, with the scaffolding fading: two lines are gone now — fill both.

class Money:
def __init__(self, cents):
self.cents = cents
def __repr__(self):
return f"Money(Money(75))"
def __add__(self, other):
return Money(self.cents + other.cents)

a = Money(150)
b = ___
print(a + b)

Why: Reproducing these unaided, rather than reading them, is what tells you the method has transferred. It reads both cents totals, adds them, and builds a new Money.

Annotate

Walk the callouts on Add __add__: + builds a new object. Each one is a place this is easy to get subtly wrong.

• It reads both cents totals, adds them, and builds a new Money. a and b are untouched.
• Verified by execution: prints Money(225). 150 + 75 cents, wrapped back into a Money object you can keep using.

Fill in the blanks

From Return a new object, and + chains — one line has had its right-hand side removed. Put it back.

class Vec:
def __init__(self, x, y):
self.x = x
self.y = y
def __repr__(self):
return f"Vec(Vec(3, 4), ___)"
def __add__(self, other):
return Vec(self.x + other.x, self.y + other.y)

a = Vec(1, 2)
b = ___
c = Vec(10, 10)
print(a + b + c)

Why: b is what everything below it consumes, so the wrong expression here fails later and somewhere else. a + b builds Vec(4, 6); that result has __add__ too, so + c works on it.

Comparison matrix

From Return a new object, and + chains: every row here is a choice with a cost. Fill the x column, then say which row you would actually pick and what you give up for it.

Discussion prompt

Explain Operators are method calls in disguise 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 One class, many dunders 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.

Predict first

The table runs: Money(150) + Money(75) | __add__ | Money(225) · print(wallet) | __repr__ | Money(225)

In A Money class that feels built-in, given the rows so far: what is the next one — the row where expression is wallet == Money(225)?

Correct: wallet == Money(225) | __eq__ | True

Why: The relationship between the columns, not the individual numbers, is what generates the next row. The + builds Money(225); print asks __repr__ for its string; == runs __eq__ to compare cents.

Comparison matrix

From A Money class that feels built-in: refill the dunder used column from what you know. The rest of the table is as it appeared.

Discussion prompt

Built-in types feel effortless because they answer to +, ==, len(), and print already. Dunders are how you give the same fluency to a class you wrote.

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 25 - Dunder Methods 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 Writing a solid __repr__ 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 print(c) show?

• A. Cat("Mimi")
• B. Mimi
• C. <__main__.Cat object at 0x...> (correct)
• D. TypeError

Answer: C

Why: With no __str__ or __repr__, print falls back to the default repr: the class location and a memory address. Verified by execution.

Why A tempts people

That would require a __repr__ that returns it; none is defined, so you get the default address form.

Why B tempts people

Printing just the name would need a __str__ or __repr__ returning self.name; there is none.

Why D tempts people

print always works - every object has the default repr, so there is no error.

Check your understanding

What does this print?

• A. [P1, P2]
• B. [<__main__.P object at 0x...>, <__main__.P object at 0x...>] (correct)
• C. P1 P2
• D. TypeError

Answer: B

Why: A list prints each item with __repr__, not __str__. P defines only __str__, so the items fall back to the default address repr. Verified by execution.

Why A tempts people

That is what you'd get if __repr__ returned P1/P2 - but only __str__ is defined, and containers ignore __str__.

Why C tempts people

print([...]) shows a list with brackets and commas, not space-separated bare values.

Why D tempts people

There is no error; the items just use the default repr.

Check your understanding

What does this print?

• A. True
• B. False (correct)
• C. 5
• D. TypeError

Answer: B

Why: With no __eq__, == compares identity. The two Box objects are built separately, so they are different objects and == is False. Verified by execution.

Why A tempts people

True would require an __eq__ comparing v. Without it, == asks 'same object?' - and these are two objects.

Why C tempts people

== returns a bool (True/False), never the stored value 5.

Why D tempts people

Comparing objects with == never errors; the default just falls back to identity.

Check your understanding

What does this print?

• A. True (correct)
• B. False
• C. 2
• D. TypeError

Answer: A

Why: in compares each item with ==, which now runs __eq__. Box(2) is value-equal to the second item, so it is found. Verified by execution.

Why B tempts people

False would be the answer without __eq__ (identity). With __eq__ comparing v, the value-equal Box matches.

Why C tempts people

in returns a bool, not the value inside the box.

Why D tempts people

No error - __eq__ is defined, so membership testing works fine.

Check your understanding

What does this print?

• A. 4 (correct)
• B. 1
• C. TypeError
• D. None

Answer: A

Why: len(b) calls __len__, which returns len(self.items) - the list has 4 items, so it returns 4. Verified by execution.

Why B tempts people

1 would treat the Bag as a single thing; but __len__ delegates to the inner list's length, which is 4.

Why C tempts people

TypeError is what you'd get with NO __len__. Here it is defined, so len() works.

Why D tempts people

__len__ returns an int (4), and len() passes it straight back - never None.

Check your understanding

What does this print?

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

Answer: A

Why: sorted() orders lowest-first using __lt__ (self.s < other.s), and __repr__ prints each score, giving [1, 2, 3]. Verified by execution.

Why B tempts people

That is the original order; sorted() returns a new ordered list, it does not leave them unsorted.

Why C tempts people

That is descending order; sorted() defaults to ascending (lowest s first).

Why D tempts people

TypeError happens only without __lt__. Here it is defined, so sorting works.

Check your understanding

What does this print?

• A. Jar(7) (correct)
• B. 7
• C. Jar(3)Jar(4)
• D. TypeError

Answer: A

Why: __add__ adds the two n values (3 + 4) and returns a new Jar(7); __repr__ then prints it as Jar(7). Verified by execution.

Why B tempts people

7 would be the raw number, but __add__ wraps the sum back into a Jar, and __repr__ shows Jar(7).

Why C tempts people

+ does not concatenate the two reprs; it runs __add__, which builds one new Jar from the sum.

Why D tempts people

TypeError is the no-__add__ case. Here __add__ is defined, so + works.

Check your understanding

What does print(str(t)) show?

• A. Tag('sale') (correct)
• B. sale
• C. <__main__.Tag object at 0x...>
• D. TypeError

Answer: A

Why: With no __str__, str() falls back to __repr__, which returns Tag('sale') - the !r adds the quotes around 'sale'. Verified by execution.

Why B tempts people

Bare sale (no quotes, no Tag) would need a __str__ returning self.name; none is defined, so repr is used.

Why C tempts people

The default address form only appears when NO __repr__ exists; here __repr__ is defined.

Why D tempts people

str() never errors here - it just uses __repr__ as its fallback.

Check your understanding

What does print(Coin(25)) show?

• A. 25c (correct)
• B. Coin(25)
• C. <__main__.Coin object at 0x...>
• D. 25

Answer: A

Why: print prefers __str__ when it exists, so it uses the friendly form and shows 25c. __repr__ would be used by repr(), the shell, or a list. Verified by execution.

Why B tempts people

Coin(25) is the __repr__ form; you'd see it from repr(Coin(25)) or inside a list, but print uses __str__ first.

Why C tempts people

The default address only appears when neither dunder is defined; here both are.

Why D tempts people

Bare 25 would need a __str__ returning str(self.v); this __str__ adds the 'c', giving 25c.

Draw it

One page, no notation unless you need it: draw how these connect — Hooks into Syntax · The Default repr · __str__ and __repr__ · __eq__: Value Equality · __len__: len() · __lt__: Sorting. Put an arrow wherever one of them is what makes another possible, and label the arrow with why.