Skip to main content

Abstraction: Abstract Classes and Abstract Methods

We have now covered three major pillars of Object-Oriented Programming: Encapsulation, Inheritance, and Polymorphism. The final pillar we will discuss is Abstraction.

Abstraction is the concept of hiding complex implementation details and showing only the necessary features of an object. It helps us manage complexity by creating a simplified, high-level interface. In Python, abstraction is formally achieved through Abstract Base Classes (ABCs).

📚 Prerequisites​

You should have a strong understanding of classes and inheritance.

🎯 Article Outline: What You'll Master​

In this article, you will learn:

  • ✅ The Concept of Abstraction: Understand what it means to create a blueprint for other classes.
  • ✅ The abc Module: How to use the ABC class and the @abstractmethod decorator to create abstract classes.
  • ✅ Enforcing an Interface: See how an abstract class forces its subclasses to implement specific methods.
  • ✅ Why Abstract Classes Cannot Be Instantiated: Understand the purpose of a class that only serves as a template.

🧠 Section 1: What is Abstraction?​

Think of a TV remote control. It's a great example of abstraction. It has a simple interface (power button, volume up/down, channel buttons) that lets you interact with a very complex device (the TV). You don't need to know anything about the TV's internal circuitry or how it receives signals. The complexity is hidden, and you are presented with only the essential controls.

In OOP, an Abstract Base Class (ABC) is like the design for that remote control. It defines what buttons must exist, but it doesn't implement the internal logic for them. It serves as a contract or a blueprint. Any class that inherits from it must provide an implementation for the required buttons (methods).

💻 Section 2: The abc Module​

Python provides the abc module to formalize the process of creating abstract classes. The two key components we'll use are:

  • ABC: A helper class that you inherit from to make your class an abstract base class.
  • @abstractmethod: A decorator that you place over a method to declare it as abstract. An abstract method has a declaration but no implementation.

Let's create an abstract Shape class. A "shape" is a concept; you can't have just a "shape," you have a specific shape like a circle or a square. This makes it a perfect candidate for an ABC.

# abc_example.py

from abc import ABC, abstractmethod

# To create an ABC, you inherit from the ABC class
class Shape(ABC):
    """
    An abstract base class for all shapes.
    It defines the interface that all concrete shapes must implement.
    """
    def __init__(self, name):
        self.name = name

    # This decorator marks 'area' as an abstract method
    @abstractmethod
    def area(self):
        """Calculate and return the area of the shape."""
        pass # Abstract methods have no implementation in the base class

    # This is also an abstract method
    @abstractmethod
    def perimeter(self):
        """Calculate and return the perimeter of the shape."""
        pass

Key Rule: You cannot create an instance of an abstract class. The following code would raise a TypeError:

# This will fail!
# my_shape = Shape("Generic Shape")

This is because Shape is an incomplete blueprint. It promises that its children will have area() and perimeter() methods, but it doesn't know how to perform those calculations itself.

🛠️ Section 3: Implementing the Abstract Class​

The purpose of an ABC is to be inherited by other classes, which are called concrete classes. A concrete class must provide an implementation for all of the abstract methods defined in its parent ABC.

Let's create two concrete classes, Circle and Square, that inherit from Shape.

import math

class Circle(Shape):
    def __init__(self, radius):
        # Call the parent's __init__
        super().__init__("Circle")
        self.radius = radius

    # We MUST implement the 'area' method
    def area(self):
        return math.pi * (self.radius ** 2)

    # We MUST also implement the 'perimeter' method
    def perimeter(self):
        return 2 * math.pi * self.radius

class Square(Shape):
    def __init__(self, side_length):
        super().__init__("Square")
        self.side_length = side_length

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

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

If we were to forget to implement perimeter in the Square class, for example, Python would raise a TypeError the moment we tried to create a Square object (my_square = Square(5)). This enforcement is what makes ABCs so powerful for building reliable and predictable systems.

Now we can use our concrete classes:

# --- Using our concrete classes ---
my_circle = Circle(10)
my_square = Square(5)

shapes = [my_circle, my_square]

for shape in shapes:
    print(f"--- {shape.name} ---")
    print(f"Area: {shape.area():.2f}")
    print(f"Perimeter: {shape.perimeter():.2f}")
    print("-" * (len(shape.name) + 8))

This also beautifully demonstrates polymorphism. Our loop treats every shape object the same, calling .area() and .perimeter() on them, because it trusts that any object inheriting from Shape is guaranteed to have those methods.

✨ Conclusion & Key Takeaways​

Abstraction allows us to define a clear, required interface for a family of classes. By using Abstract Base Classes, you create a contract that ensures consistency and predictability across your codebase, making it easier to manage complexity and build large-scale applications.

Let's summarize the key takeaways:

  • Abstraction Hides Complexity: It provides a simple interface to a complex system.
  • Abstract Base Classes (ABCs) are Blueprints: They define methods and properties that subclasses are required to implement.
  • You Cannot Instantiate an ABC: An ABC is an incomplete template and cannot be turned into an object directly.
  • Use abc.ABC and @abstractmethod: These are the tools for creating abstract classes and methods in Python.
  • ABCs Enforce a Contract: They guarantee that any concrete subclass will have a specific set of methods, which is great for building reliable systems.

➡️ Next Steps​

You have now been introduced to the four major pillars of Object-Oriented Programming. Next, we'll explore another important OOP concept: "Interfaces in Python," and see how they relate to the idea of abstraction.

Happy coding!