Dunder Methods Part 2 — __eq__ & __lt__

By the end of this lesson you can:

• Define __eq__(self, other) so a == b compares values.
• Define __lt__(self, other) so sorted() and min/max work.
• Use functools.total_ordering to get <=, >, >= for free.
• Recognise when to define __hash__ — needed if objects go in a set or as dict keys.

class Hero:
    def __init__(self, name, hp):
        self.name = name; self.hp = hp

a = Hero("Aisyah", 100)
b = Hero("Aisyah", 100)     # same data!

print(a == b)               # → False    -- surprising?
print(a is b)               # → False    -- different objects in memory

By default == tests identity, same as is. Two heroes with identical data are still considered different.

Today: teach Python that two Heroes are equal if their names match. Same shape for sortability — "Hero A is less than Hero B" means "A's HP is smaller than B's" or whatever we decide.

__eq__ — value equality

class Hero:
    def __init__(self, name, hp):
        self.name = name; self.hp = hp

    def __eq__(self, other):
        if not isinstance(other, Hero):
            return NotImplemented        # let Python try the other way round
        return self.name == other.name

a = Hero("Aisyah", 100)
b = Hero("Aisyah", 80)            # different HP — still equal because we compare on name
print(a == b)                     # → True

Two new things: (1) isinstance check — refuse to compare with unrelated types; return NotImplemented (Python falls back to the other object's __eq__, then to False). (2) Decide which fields define equality — sometimes name, sometimes id, sometimes all fields.

__lt__ — "less than"

Python's sorted, min, max all rely on <. Implement __lt__ and they spring to life:

class Hero:
    # ... __init__ ...
    def __lt__(self, other):
        return self.hp < other.hp     # order by HP

party = [Hero("Aisyah", 80), Hero("Wei Jie", 50), Hero("Priya", 95)]
party.sort()
for h in party:
    print(h.name, h.hp)
# Wei Jie 50
# Aisyah  80
# Priya   95

One method, and the entire sorted infrastructure starts working on your class.

The other comparisons

Operator    Dunder           Inverse
a == b      __eq__           __ne__ (default: not __eq__)
a < b       __lt__           __gt__ (use __lt__ with args swapped)
a <= b      __le__           __ge__
a > b       __gt__
a >= b      __ge__

You don't need all of them. Define __eq__ and __lt__ and Python wires the rest sensibly — but only with a helper:

functools.total_ordering — the shortcut

from functools import total_ordering

@total_ordering
class Hero:
    def __init__(self, name, hp):
        self.name = name; self.hp = hp

    def __eq__(self, other):
        return isinstance(other, Hero) and self.hp == other.hp

    def __lt__(self, other):
        return self.hp < other.hp

# Now Hero supports ==, !=, <, <=, >, >= — all for free

@total_ordering is a class decorator that fills in the missing comparison dunders from __eq__ and __lt__. Saves four method definitions.

The hash gotcha

Defining __eq__ on a class makes it unhashable by default — you can't put it in a set or use it as a dict key. To fix that, also define __hash__:

class Hero:
    def __init__(self, name, hp):
        self.name = name; self.hp = hp

    def __eq__(self, other):
        return isinstance(other, Hero) and self.name == other.name

    def __hash__(self):
        return hash(self.name)       # MUST match what __eq__ compares

set([Hero("Aisyah", 80), Hero("Aisyah", 100)])    # → set of one (same name)

Rule: if a == b, then hash(a) == hash(b). Otherwise sets and dicts misbehave. Compute the hash from the same fields you compare in __eq__.

Save as sortable.py:

# sortable.py — equality, ordering, hashing

from functools import total_ordering

@total_ordering
class Hero:
    def __init__(self, name, hp, level):
        self.name = name; self.hp = hp; self.level = level

    def __repr__(self):
        return f"Hero({self.name!r}, hp={self.hp}, level={self.level})"

    def __eq__(self, other):
        if not isinstance(other, Hero):
            return NotImplemented
        return self.name == other.name

    def __lt__(self, other):
        # Sort by level descending, then HP descending — strongest first
        return (self.level, self.hp) > (other.level, other.hp)

    def __hash__(self):
        return hash(self.name)


party = [
    Hero("Aisyah",  85, 3),
    Hero("Wei Jie", 70, 5),
    Hero("Priya",   95, 4),
    Hero("Iman",    60, 5),
    Hero("Aizat",   80, 2),
]

# 1 — sort uses __lt__
print("=== Sorted ===")
for h in sorted(party):
    print(f"  {h.name:<10} Lv {h.level}  HP {h.hp}")

# 2 — min / max
print(f"\nStrongest: {min(party)}")     # min by our __lt__ = strongest first
print(f"Weakest  : {max(party)}")

# 3 — equality by name
clone = Hero("Aisyah", 999, 99)
print(f"\nAisyah duplicate?  {clone in party}")     # uses __eq__

# 4 — set membership uses __eq__ + __hash__
unique = set(party + [Hero("Wei Jie", 1, 1)])
print(f"\nUnique heroes: {len(unique)} (out of {len(party) + 1})")
for h in unique:
    print(f"  {h}")

Output

=== Sorted ===
  Wei Jie    Lv 5  HP 70
  Iman       Lv 5  HP 60
  Priya      Lv 4  HP 95
  Aisyah     Lv 3  HP 85
  Aizat      Lv 2  HP 80

Strongest: Hero('Wei Jie', hp=70, level=5)
Weakest  : Hero('Aizat', hp=80, level=2)

Aisyah duplicate?  True

Unique heroes: 5 (out of 6)
  Hero('Wei Jie', hp=70, level=5)
  Hero('Aisyah', hp=85, level=3)
  ...

Read the diff

Three operators wired up. The tuple trick (self.level, self.hp) > (other.level, other.hp) sorts by level first, then HP as a tie-breaker. Equality uses name only — "same name = same hero". The set dedupes by name; the second Wei Jie gets dropped. Hash matches eq, exactly as required.

Three dunders, one decorator. __eq__ defines value equality — what makes two instances "the same". __lt__ defines ordering — enough for sorted, min, max, and (with @total_ordering) all six comparison operators. __hash__ is mandatory when objects go in sets or dict keys — and must match __eq__. The tuple trick (a, b, c) < (x, y, z) gives you multi-key sorting for free.