Advanced Dunder Methods

init, str, repr, add, and operator overloading.

Overview

Master dunder method patterns.

String Representations

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    def __str__(self):
        return f"({self.x}, {self.y})"
    
    def __repr__(self):
        return f"Point({self.x}, {self.y})"
    
    def __eq__(self, other):
        return self.x == other.x and self.y == other.y
    
    def __hash__(self):
        return hash((self.x, self.y))

p1 = Point(1, 2)
p2 = Point(1, 2)

print(str(p1))   # (1, 2)
print(repr(p1))  # Point(1, 2)
print(p1 == p2)  # True
print(hash(p1) == hash(p2))  # True

Operator Overloading

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)
    
    def __sub__(self, other):
        return Vector(self.x - other.x, self.y - other.y)
    
    def __mul__(self, scalar):
        return Vector(self.x * scalar, self.y * scalar)
    
    def __repr__(self):
        return f"Vector({self.x}, {self.y})"

v1 = Vector(1, 2)
v2 = Vector(3, 4)

print(v1 + v2)  # Vector(4, 6)
print(v1 - v2)  # Vector(-2, -2)
print(v1 * 3)   # Vector(3, 6)

Container Protocols

class Inventory:
    def __init__(self):
        self.items = {}
    
    def __setitem__(self, key, value):
        self.items[key] = value
    
    def __getitem__(self, key):
        return self.items[key]
    
    def __delitem__(self, key):
        del self.items[key]
    
    def __contains__(self, key):
        return key in self.items
    
    def __len__(self):
        return len(self.items)
    
    def __iter__(self):
        return iter(self.items)

inventory = Inventory()
inventory["sword"] = 1
inventory["shield"] = 1

print("sword" in inventory)  # True
print(len(inventory))  # 2

Practice

Implement a matrix class with full operator overloading.