Classes and Objects

Defining Classes

class Dog:
    # Class attribute — shared by all instances
    species = "Canis lupus familiaris"

    def __init__(self, name: str, age: int) -> None:
        # Instance attributes — unique per object
        self.name = name
        self.age = age

    def bark(self) -> str:
        return f"{self.name} says woof!"

    def __repr__(self) -> str:
        return f"Dog(name={self.name!r}, age={self.age})"


rex = Dog("Rex", 3)
print(rex.bark())          # Rex says woof!
print(rex)                # Dog(name='Rex', age=3)

Inheritance

class Animal:
    def __init__(self, name: str):
        self.name = name

    def speak(self) -> str:
        raise NotImplementedError

class Dog(Animal):
    def __init__(self, name: str, breed: str):
        super().__init__(name)       # call parent
        self.breed = breed

    def speak(self) -> str:
        return f"{self.name} (a {self.breed}) barks"


class Puppy(Dog):
    def speak(self) -> str:
        return f"{self.name} yips"

print(isinstance(Puppy("Bo", "Lab"), Animal))   # True

Multiple Inheritance and MRO

Python supports multiple inheritance. Method resolution follows the Method Resolution Order (MRO) — left to right, depth first, with C3 linearization.

class A: pass
class B(A): pass
class C(A): pass
class D(B, C): pass

print(D.__mro__)
# (D, B, C, A, object)

Dataclasses (Python 3.7+)

The boilerplate-free way to define value classes. @dataclass auto-generates __init__, __repr__, and __eq__.

from dataclasses import dataclass, field

@dataclass
class User:
    name: str
    email: str
    is_admin: bool = False
    tags: list[str] = field(default_factory=list)


u = User("Alice", "[email protected]")
print(u)
# User(name='Alice', email='[email protected]', is_admin=False, tags=[])

# Equality is by value, not identity
User("A", "x") == User("A", "x")        # True

Frozen / Immutable Dataclasses

@dataclass(frozen=True, slots=True)
class Point:
    x: float
    y: float

# Hashable (can be dict key / set member); attempts to assign raise FrozenInstanceError

Methods: instance, class, static

class Circle:
    pi = 3.14159

    def __init__(self, radius: float):
        self.radius = radius

    # Instance method — receives self
    def area(self) -> float:
        return Circle.pi * self.radius ** 2

    # Class method — receives the class
    @classmethod
    def unit(cls):
        return cls(1)

    # Static method — no implicit first arg
    @staticmethod
    def describe() -> str:
        return "A closed curve where all points are equidistant from a center."

Circle.unit()              # alt constructor — Circle(1)
Circle.describe()          # no instance needed

Properties

class Temperature:
    def __init__(self, celsius: float):
        self._c = celsius

    @property
    def celsius(self) -> float:
        return self._c

    @celsius.setter
    def celsius(self, value: float):
        if value < -273.15:
            raise ValueError("below absolute zero")
        self._c = value

    @property
    def fahrenheit(self) -> float:
        return self._c * 9/5 + 32

Dunder (Magic) Methods

Special methods that hook into Python's syntax. Implement them to make your objects behave like built-ins.

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

    def __repr__(self):
        return f"Vector({self.x}, {self.y})"

    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)

    def __eq__(self, other):
        return (self.x, self.y) == (other.x, other.y)

    def __hash__(self):
        return hash((self.x, self.y))

    def __len__(self):
        return int((self.x**2 + self.y**2) ** 0.5)

Common Dunder Methods