Week 04 - Task 1.3 : @dataclass, abstract base classes via the abc module & composition vs inheritance

Three more Python OOP tools that sound fancy but solve very ordinary problems: cutting boilerplate, enforcing rules on child classes, and choosing the right kind of relationship between objects.

🎁 @dataclass — Stop Writing Boilerplate

Every class that just stores data ends up looking the same:

class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __repr__(self):
        return f"Student(name={self.name}, age={self.age})"

@dataclass writes that for you:

from dataclasses import dataclass

@dataclass
class Student:
    name: str
    age: int

student = Student("Deepika", 21)
print(student)
# Student(name='Deepika', age=21)

Python auto-generates __init__(), __repr__(), and a few other useful methods based on the fields you declare.

Simple definition: @dataclass is a decorator that auto-generates common methods for classes whose main job is holding data.

Use it when: the class is basically a data container — think DTOs, config objects, records — not something with complex custom behavior.

🧱 Abstract Base Classes (abc) — Enforcing a Contract

Sometimes you don't want to give child classes an option to implement something — you want to force it.

Say you have several shapes, and every single one must have an area() method:

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

Shape is now an Abstract Base Class. @abstractmethod means:

"Every child class must provide its own area()."

class Circle(Shape):
    def area(self):
        return 3.14 * 5 * 5

Try to instantiate Shape directly, though:

shape = Shape()   # ❌ TypeError

Python refuses, because Shape still has an unimplemented abstract method.

Shape
 ├── Circle     → must implement area()
 ├── Rectangle  → must implement area()
 └── Triangle   → must implement area()

Simple definition: an Abstract Base Class defines methods that every child class is required to implement — a shared contract.

⚖️ @dataclass vs ABC — Different Jobs

One-liners to remember:

• @dataclass → "I want to store data easily."
• ABC → "I want my child classes to follow a rule."

🧬 Composition vs Inheritance

This one trips people up conceptually more than syntactically. The cleanest way to hold it in your head:

Inheritance = IS-A · Composition = HAS-A

Inheritance (IS-A)

One class is a type of another.

class Animal:
    def eat(self):
        print("Eating")

class Dog(Animal):
    pass

Dog IS-A Animal — so Dog inherits eat() for free.

Same logic: Car IS-A Vehicle, Circle IS-A Shape.

Composition (HAS-A)

One class contains another — it's built out of other objects, rather than being a specialized version of one.

class Engine:
    def start(self):
        print("Engine started")

class Car:
    def __init__(self):
        self.engine = Engine()

car = Car()
car.engine.start()

A Car is not an Engine — it has an Engine. That relationship calls for composition, not inheritance.

A car also HAS-A Steering and HAS-A Battery — same pattern.

Side by Side

When to use which

• Inheritance → genuine IS-A relationship: Dog IS-A Animal, Car IS-A Vehicle, Circle IS-A Shape
• Composition → HAS-A relationship: Car HAS-A Engine, Computer HAS-A CPU, House HAS-A Room

Rule of thumb: if you're forcing an IS-A relationship just to reuse some code, it's usually a sign you actually wanted composition.

🎯 Quick Recap