Abstraction

Introduction

When you drive a car, you press the accelerator without knowing exactly how fuel injection, combustion, and the transmission work together. The car exposes a simple interface — pedals and a steering wheel — while hiding enormous mechanical complexity underneath. Abstraction brings this same idea to your classes.

In this lesson, you will learn what abstraction means, how Python's abc module lets you define abstract base classes that cannot be instantiated directly, and how @abstractmethod forces subclasses to implement specific methods.

What is Abstraction?

Abstraction means exposing only the essential features of an object while hiding the complicated implementation details behind a simple, well-defined interface. Users of a class need to know what a method does, not necessarily how it does it internally.

You already use abstraction constantly: calling len("hello") does not require you to know how Python computes a string's length internally. In your own classes, abstraction is often expressed by defining a common set of methods that every subclass must provide, without dictating exactly how each one is implemented.

The abc Module

Python's built-in abc module (short for "Abstract Base Classes") provides the tools needed to define formal abstract classes: the ABC base class to inherit from, and the @abstractmethod decorator to mark methods that subclasses are required to implement.

from abc import ABC, abstractmethod

Defining an Abstract Base Class

To create an abstract class, inherit from ABC and mark any method that subclasses must implement with @abstractmethod. The method body is typically left empty (or uses pass), since the abstract class only defines the contract, not the implementation.

from abc import ABC, abstractmethod


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

    @abstractmethod
    def perimeter(self):
        pass


# Trying to create a Shape directly fails:
try:
    s = Shape()
except TypeError as e:
    print("Error:", e)

Error: Can't instantiate abstract class Shape with abstract methods area, perimeter

Python refuses to create a Shape instance because Shape has abstract methods that have not been implemented. This enforces that Shape is meant only to be a blueprint for subclasses, not something you use directly.

Implementing Abstract Methods in Subclasses

A subclass of an abstract class must implement every method marked with @abstractmethod before it can be instantiated. Once it does, it becomes a normal, concrete class that behaves just like any other.

from abc import ABC, abstractmethod


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

    @abstractmethod
    def perimeter(self):
        pass


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

    def area(self):
        return round(3.1416 * self.radius ** 2, 2)

    def perimeter(self):
        return round(2 * 3.1416 * self.radius, 2)


class Square(Shape):
    def __init__(self, side):
        self.side = side

    def area(self):
        return self.side ** 2

    def perimeter(self):
        return 4 * self.side


shapes = [Circle(3), Square(5)]

for shape in shapes:
    print(f"{shape.__class__.__name__}: area={shape.area()}, perimeter={shape.perimeter()}")

Circle: area=28.27, perimeter=18.85
Square: area=25, perimeter=20

Abstraction vs Encapsulation

These two concepts are often confused because both involve "hiding" something, but they hide different things for different reasons.

In short: abstraction is about designing a clean interface and hiding complex internals, while encapsulation (covered earlier) is about protecting an object's internal state from invalid or unauthorized changes.

Why Abstraction Matters

Common Mistakes

Best Practices

Frequently Asked Questions

Key Takeaways

Summary

Abstraction lets you define a clean, consistent interface for a family of related classes while hiding the specific implementation details inside each subclass. Python's abc module, through ABC and @abstractmethod, enforces this contract at the language level, refusing to instantiate incomplete classes.

You have now covered all four pillars of OOP: encapsulation, inheritance, polymorphism, and abstraction. Next, you will learn about magic (dunder) methods — the special methods that let your custom objects integrate naturally with Python's built-in syntax.