Understanding Abstract Classes and Abstract Methods in Python

Welcome back! Previously, you delved into polymorphism and learned how to create more flexible code structures using classes and inheritance. In this session, we will take a step further and explore a crucial aspect of Object-Oriented Programming in Python: abstract classes and abstract methods.

An abstract class is a class that cannot be instantiated directly. Think of it as a blueprint for other classes. It often includes one or more abstract methods. A class that inherits from an abstract class must implement all its abstract methods.

In Python, the abc (Abstract Base Classes) module provides tools for defining abstract base classes. An abstract base class is a class that cannot be instantiated directly and often includes one or more abstract methods. These classes serve as blueprints for other classes, enforcing a consistent interface for a group of derived classes. By defining common behavior in abstract base classes, we ensure that derived classes follow the same protocol, making our code more predictable and robust.

Example:

from abc import ABC, abstractmethod

class Animal(ABC):
    @abstractmethod
    def sound(self):
        pass

In this snippet, Animal is an abstract class with an abstract method sound. You cannot create an instance of Animal, but you can inherit from it. Any subclass of Animal must thereby implement the sound method.

When you define an abstract method within an abstract class, it acts as a placeholder without any implementation, serving as a rule that subclasses must follow. These methods establish a required interface, ensuring that any subclass provides its specific implementation. This approach enforces consistency across subclasses while allowing each to fulfill the required behavior uniquely, promoting organized and reliable code.

By mastering abstract classes and abstract methods, you'll be able to easily add new types of derived classes without modifying existing code — a key principle of software design. For example, consider the following implementation, where you adhere to the defined interface without any modifications to the existing Shape class:

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 3.14159 * self.radius * self.radius
    
    def perimeter(self):
        return 2 * 3.14159 * self.radius

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height
    
    def area(self):
        return self.width * self.height
    
    def perimeter(self):
        return 2 * (self.width + self.height)

if __name__ == "__main__":
    circle = Circle(5)
    rectangle = Rectangle(4, 6)

    print(f"Circle Area: {circle.area()}, Perimeter: {circle.perimeter()}")
    # Output: Circle Area: 78.53975, Perimeter: 31.4159
    print(f"Rectangle Area: {rectangle.area()}, Perimeter: {rectangle.perimeter()}")
    # Output: Rectangle Area: 24, Perimeter: 20

Here, the Shape class is an abstract class that sets a blueprint with two abstract methods: area and perimeter. Subclasses must implement these methods. The Circle class inherits from Shape, using its constructor to initialize the radius and providing specific implementations for calculating the circle's area and perimeter based on the radius. The Rectangle class also inherits from Shape, initializing its width and height in the constructor, and implementing methods to compute its area and perimeter.

In the __main__ block, instances of Circle and Rectangle are created, and their areas and perimeters are printed, demonstrating the concrete implementations in each subclass. Importantly, the Shape class cannot be instantiated directly; only its subclasses with concrete method implementations can be instantiated. This ensures a consistent interface, enhancing code maintainability and readability by enforcing a structured and predictable way of defining shapes.