Advanced OOP in Python: ABCs, Dunder Methods, Slots

Once you’re comfortable with basic classes, Python’s advanced OOP features let you build robust, framework-quality code. You’ll learn how to define interfaces that subclasses must implement, how to make your objects behave like built-in Python types, and how to squeeze out memory savings with __slots__.

Abstract Base Classes

An Abstract Base Class (ABC) defines a set of methods that every subclass must implement. If a subclass fails to implement all abstract methods, Python raises a TypeError the moment you try to instantiate it. This is how you enforce a shared interface across a family of related classes.

from abc import ABC, abstractmethod

class Shape(ABC):
    """Every shape must know its area and perimeter."""

    @abstractmethod
    def area(self) -> float:
        ...

    @abstractmethod
    def perimeter(self) -> float:
        ...

    def describe(self) -> str:
        # Concrete method — shared by all subclasses
        return f"{self.__class__.__name__}: area={self.area():.2f}, perimeter={self.perimeter():.2f}"

Implementing the ABC

import math

class Circle(Shape):
    def __init__(self, radius: float):
        self.radius = radius

    def area(self) -> float:
        return math.pi * self.radius ** 2

    def perimeter(self) -> float:
        return 2 * math.pi * self.radius

class Rectangle(Shape):
    def __init__(self, width: float, height: float):
        self.width = width
        self.height = height

    def area(self) -> float:
        return self.width * self.height

    def perimeter(self) -> float:
        return 2 * (self.width + self.height)

# Both work polymorphically through the Shape interface
shapes: list[Shape] = [Circle(5), Rectangle(4, 6)]
for shape in shapes:
    print(shape.describe())

# Circle:    area=78.54, perimeter=31.42
# Rectangle: area=24.00, perimeter=20.00

# Trying to instantiate the ABC directly raises TypeError
# Shape()   # TypeError: Can't instantiate abstract class Shape

Multiple Inheritance and MRO

Python supports multiple inheritance — a class can inherit from more than one parent. When a method is called, Python searches parent classes in a specific order defined by the Method Resolution Order (MRO), computed using the C3 linearisation algorithm.

class Flyable:
    def move(self) -> str:
        return "flying"

class Swimmable:
    def move(self) -> str:
        return "swimming"

class Duck(Flyable, Swimmable):
    pass

d = Duck()
print(d.move())          # "flying" — Flyable comes first in MRO

print(Duck.__mro__)
# (<class 'Duck'>, <class 'Flyable'>, <class 'Swimmable'>, <class 'object'>)

Use super() to call the next class in the MRO chain rather than hardcoding a parent name:

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

class Pet:
    def __init__(self, owner: str):
        self.owner = owner

class Dog(Animal, Pet):
    def __init__(self, name: str, owner: str):
        Animal.__init__(self, name)
        Pet.__init__(self, owner)

d = Dog("Rex", "Alice")
print(d.name, d.owner)   # Rex Alice

Multiple inheritance increases complexity quickly. Reserve it for mixin patterns — small, focused classes that add one specific behaviour (e.g., LogMixin, SerializableMixin). Avoid deep or diamond inheritance hierarchies.

Dunder (Magic) Methods

Dunder methods (double-underscore, e.g., __str__) let your objects plug into Python’s built-in syntax and functions. Implementing them makes your classes feel like native Python types.

__str__ and __repr__

__str__ controls the human-readable string (str(obj), print(obj)). __repr__ controls the developer-readable string (repr(obj), shown in the REPL).

class Product:
    def __init__(self, name: str, price: float):
        self.name = name
        self.price = price

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

    def __str__(self) -> str:
        return f"{self.name} — ${self.price:.2f}"

p = Product("Laptop", 999.0)
print(str(p))    # Laptop — $999.00
print(repr(p))   # Product(name='Laptop', price=999.0)

__len__, __contains__, __getitem__

Make your object behave like a sequence or container.

class Playlist:
    def __init__(self, songs: list[str]):
        self.songs = songs

    def __len__(self) -> int:
        return len(self.songs)

    def __contains__(self, song: str) -> bool:
        return song in self.songs

    def __getitem__(self, index: int) -> str:
        return self.songs[index]

p = Playlist(["Song A", "Song B", "Song C"])
print(len(p))           # 3
print("Song B" in p)    # True
print(p[0])             # Song A

__eq__, __lt__, and comparison methods

Control how objects are compared with ==, <, >, etc.

from dataclasses import dataclass

@dataclass
class Vector:
    x: float
    y: float

    def magnitude(self) -> float:
        return (self.x ** 2 + self.y ** 2) ** 0.5

    def __eq__(self, other: object) -> bool:
        if not isinstance(other, Vector):
            return NotImplemented
        return self.x == other.x and self.y == other.y

    def __lt__(self, other: "Vector") -> bool:
        return self.magnitude() < other.magnitude()

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

v1 = Vector(3, 4)   # magnitude = 5
v2 = Vector(1, 1)   # magnitude ≈ 1.41

print(v1 + v2)       # Vector(x=4, y=5)
print(v2 < v1)       # True
print(sorted([v1, v2]))  # [Vector(x=1, y=1), Vector(x=3, y=4)]

__call__ — callable objects

Make an instance callable like a function by implementing __call__.

class Multiplier:
    def __init__(self, factor: float):
        self.factor = factor

    def __call__(self, value: float) -> float:
        return value * self.factor

double = Multiplier(2)
triple = Multiplier(3)

print(double(10))   # 20.0
print(triple(10))   # 30.0

# Works anywhere a function is expected
prices = [100, 250, 500]
print(list(map(double, prices)))  # [200.0, 500.0, 1000.0]

`slots` for Memory Optimisation

By default, Python stores each instance’s attributes in a __dict__ dictionary — flexible but memory-heavy. When you declare __slots__, Python uses a fixed-size array instead, which cuts per-instance memory by roughly 40–50% and speeds up attribute access.

import sys

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

class SlottedPoint:
    __slots__ = ("x", "y")

    def __init__(self, x: float, y: float):
        self.x = x
        self.y = y

regular = RegularPoint(1.0, 2.0)
slotted  = SlottedPoint(1.0, 2.0)

print(sys.getsizeof(regular.__dict__))  # ~232 bytes (the dict overhead)
print(hasattr(slotted, "__dict__"))     # False — no dict at all

__slots__ prevents adding arbitrary attributes to instances at runtime. Use it when you create many instances of a small, fixed-schema class — for example, points in a geometry engine, rows in a data pipeline, or nodes in a graph.

Putting It All Together: a Shape Hierarchy

from abc import ABC, abstractmethod
import math

class Shape(ABC):
    @abstractmethod
    def area(self) -> float: ...

    @abstractmethod
    def perimeter(self) -> float: ...

    def __repr__(self) -> str:
        return f"{self.__class__.__name__}(area={self.area():.2f})"

    def __lt__(self, other: "Shape") -> bool:
        return self.area() < other.area()

    def __eq__(self, other: object) -> bool:
        if not isinstance(other, Shape):
            return NotImplemented
        return self.area() == other.area()


class Circle(Shape):
    __slots__ = ("radius",)

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

    def area(self) -> float:
        return math.pi * self.radius ** 2

    def perimeter(self) -> float:
        return 2 * math.pi * self.radius


class Rectangle(Shape):
    __slots__ = ("width", "height")

    def __init__(self, width: float, height: float):
        self.width  = width
        self.height = height

    def area(self) -> float:
        return self.width * self.height

    def perimeter(self) -> float:
        return 2 * (self.width + self.height)


shapes: list[Shape] = [Circle(3), Rectangle(10, 2), Circle(1), Rectangle(4, 4)]

# Sort by area using __lt__
for shape in sorted(shapes):
    print(shape)

# Circle(area=3.14)
# Circle(area=28.27)
# Rectangle(area=20.00)
# Rectangle(area=16.00)

Core Python

Advanced Python

Pydantic

Advanced OOP in Python: ABCs, Dunder Methods, Slots

Abstract Base Classes

Implementing the ABC

Multiple Inheritance and MRO

Dunder (Magic) Methods

`slots` for Memory Optimisation

Putting It All Together: a Shape Hierarchy

​Abstract Base Classes

​Implementing the ABC

​Multiple Inheritance and MRO

​Dunder (Magic) Methods

​__slots__ for Memory Optimisation

​Putting It All Together: a Shape Hierarchy

Abstract Base Classes

Implementing the ABC

Multiple Inheritance and MRO

Dunder (Magic) Methods

`slots` for Memory Optimisation

Putting It All Together: a Shape Hierarchy