Dunder methods

Key features

• Name(...) calls __new__ first to create the object, then __init__ to set it up
• __new__(cls, ...) is a staticmethod (implicitly) that must return an instance
• If __new__ returns an instance of cls, Python calls __init__ on it automatically
• __init__ never returns a value — returning anything but None is a TypeError
• Overriding __new__ is rare — mainly for immutable-type subclassing and singletons

Command

class Name:
    def __new__(cls, *args, **kwargs):
        instance = super().__new__(cls)   # actually allocate
        return instance

    def __init__(self, *args, **kwargs):
        ...                                 # then set up attributes

Key features

• __repr__(self) should be unambiguous — ideally, valid Python that recreates the object
• __str__(self) returns a readable string for print()/str()/f-strings
• If __str__ is not defined, Python falls back to __repr__ for print()/str() too
• The interactive REPL always uses __repr__ to display a bare expression's result
• Both must return an actual str — returning anything else raises TypeError

Command

class Name:
    def __repr__(self):
        return f"Name({self.value!r})"   # unambiguous, ideally valid Python

    def __str__(self):
        return f"{self.value}"            # reader-friendly

Key features

• Without __eq__, == falls back to is — comparing identity, not value
• __eq__(self, other) should return True/False, or NotImplemented for an unrelated type
• __ne__ is derived automatically from __eq__ — Python negates its result
• Defining __eq__ sets __hash__ to None automatically, making instances unhashable
• Returning NotImplemented (not False) lets Python try other.__eq__(self) as a fallback

Command

class Name:
    def __eq__(self, other):
        if not isinstance(other, Name):
            return NotImplemented
        return self.value == other.value   # compare by value, not identity

Key features

• __lt__(self, other) defines self < other; __le__(self, other) defines self <= other
• Neither is derived from the other, or from __eq__ — each must be defined explicitly
• Should return NotImplemented for an unrelated type, the same convention __eq__ uses
• @functools.total_ordering fills in the rest from __eq__ plus just one ordering method
• Comparing to an unrelated type with no ordering defined raises TypeError

Command

class Name:
    def __lt__(self, other):
        if not isinstance(other, Name):
            return NotImplemented
        return self.value < other.value

    def __le__(self, other):
        if not isinstance(other, Name):
            return NotImplemented
        return self.value <= other.value

Key features

• __gt__(self, other) defines self > other; __ge__(self, other) defines self >= other
• Neither is derived from __lt__/__le__ or from each other — each needs its own definition
• If a.__gt__(b) returns NotImplemented, Python tries b.__lt__(a) as a reflected fallback
• That reflected-fallback trick is the one piece of automatic help ordering operators get
• @functools.total_ordering remains the simplest way to get all four from __eq__ plus one

Command

class Name:
    def __gt__(self, other):
        if not isinstance(other, Name):
            return NotImplemented
        return self.value > other.value

    def __ge__(self, other):
        if not isinstance(other, Name):
            return NotImplemented
        return self.value >= other.value

Key features

• __hash__(self) must return an int — used by dict/set to place an object into a bucket
• Rule: a == b implies hash(a) == hash(b) — Python cannot verify this automatically
• Defining __eq__ without __hash__ sets __hash__ to None, making instances unhashable
• Two unequal objects CAN share a hash (a "collision") — allowed and handled internally
• hash((self.a, self.b)) is standard — hash a tuple of the same fields __eq__ compares

Command

class Name:
    def __eq__(self, other):
        return isinstance(other, Name) and self.value == other.value

    def __hash__(self):
        return hash(self.value)   # hash the same fields __eq__ compares

Key features

• __bool__(self) must return an actual bool — True or False
• Without __bool__, Python falls back to __len__(self) == 0 meaning falsy
• Without either __bool__ or __len__, every instance is truthy
• bool(obj) and if obj: both go through this same lookup chain
• __bool__ returning a non-bool value raises TypeError

Command

class Name:
    def __bool__(self):
        return self.some_condition   # must return True/False

Key features

• __len__(self) must return a non-negative int — len(obj) calls it directly
• __contains__(self, item) defines in — should return True/False
• Without __contains__, in falls back to iterating via __iter__ and comparing each element
• len() raises TypeError immediately if __len__ returns a negative number
• A class with neither __len__ nor __iter__ cannot support in at all

Command

class Name:
    def __len__(self):
        return len(self._items)

    def __contains__(self, item):
        return item in self._items

Key features

• __iter__(self) must return an iterator — an object with its own __next__
• __next__(self) returns the next value, or raises StopIteration when exhausted
• A class implementing both on itself, returning self from __iter__, is its own iterator
• for x in obj: is exactly iter(obj) once, then next() in a loop, stopping on StopIteration
• A fresh call to __iter__ should start a NEW independent iteration, not resume an old one

Command

class Name:
    def __iter__(self):
        return self          # this object is also its own iterator

    def __next__(self):
        if done:
            raise StopIteration
        return next_value

Key features

• __getitem__(self, key) defines obj[key] — key is often an int, str, or slice
• __setitem__(self, key, value) defines obj[key] = value
• Without __setitem__, a class with only __getitem__ supports reads but not writes
• A missing key should raise KeyError (mapping-style) or IndexError (sequence-style)
• __getitem__ over sequential integer indices is auto-iterable, even without __iter__

Command

class Name:
    def __getitem__(self, key):
        return self._data[key]

    def __setitem__(self, key, value):
        self._data[key] = value

Key features

• __enter__(self) runs at the start of a with block; its return value becomes as name
• __exit__(self, exc_type, exc_value, traceback) always runs at the end, even on error
• If no exception occurred, all three __exit__ arguments are None
• Returning True from __exit__ suppresses the exception — as if nothing happened
• Returning falsy (the default) lets the exception propagate after __exit__ runs

Command

class Name:
    def __enter__(self):
        return self                       # becomes the "as" name

    def __exit__(self, exc_type, exc_value, traceback):
        # cleanup here — always runs
        return False                      # do not suppress exceptions

Key features

• __call__(self, *args, **kwargs) lets obj(...) work — sugar for obj.__call__(...)
• callable(obj) returns True for any object whose class defines __call__
• A class implementing __call__ can hold state between calls, unlike a plain function
• Functions themselves are callable because function objects implement __call__ too
• Common uses: configurable operations, decorators-as-classes, running counters/accumulators

Command

class Name:
    def __call__(self, *args, **kwargs):
        return self.do_something(*args, **kwargs)