Abstraction In Python

20th February 2026 by Tanishq Chavan

Python C C++ Javascript React JS

Python Abstraction: Comprehensive Theory

Abstraction is the process of hiding the complex implementation details and showing only the necessary features of an object. It focuses on what an object does instead of how it does it.

In Python, abstraction is achieved by using Abstract Base Classes (ABCs).

1. What is an Abstract Class?

An abstract class is a class that cannot be instantiated. It serves as a blueprint for other classes. You can think of it as a set of rules that every subclass must follow.

abc Python doesn't provide abstract classes by default. We need to import the abc (Abstract Base Class) module to create them.

To make a class abstract, it must inherit from ABC and contain at least one method decorated with @abstractmethod.

from abc import ABC, abstractmethod

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

    @abstractmethod
    def perimeter(self):
        pass

3. Why Can't We Instantiate Abstract Classes?

If you try to create an object of an abstract class, Python will raise a TypeError.

# s = Shape() # This will raise: TypeError: Can't instantiate abstract class Shape...

This is because Shape is incomplete—it doesn't "know" how to calculate its own area without being a specific shape (like a Circle or Square).

4. Implementing the Blueprint (Subclasses)

When a class inherits from an abstract class, it must provide implementations for all abstract methods. If it fails to do so, it also becomes an abstract class and cannot be instantiated.

import math

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

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

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

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

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

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

# Now we can create objects
c = Circle(5)
print(f"Circle Area: {c.area():.2f}")

5. Benefits of Abstraction

Enforces Structure: Ensures that all child classes maintain a consistent API.
Reduces Complexity: Users of the class don't need to understand the internal logic, just the interface.
Improved Maintainability: Changes to the high-level design can be managed in one place (the abstract base class).

6. Real-World Analogy

Think of a TV Remote Control.