1.3. Abstract Base Classes (ABCs) and Interfaces

from abc import ABC, abstractmethod
class Shape(ABC):
    @abstractmethod
    def area(self):
        pass
    @abstractmethod
    def perimeter(self):
        pass

An Abstract Base Class (ABC) in Python is a type of class that cannot be instantiated on its own and is designed to be subclassed. It includes abstract methods, which are methods that are declared but contain no implementation. In the example, the Shape class is defined as an ABC, and it has two abstract methods: area and perimeter. Any subclass deriving from Shape is required to provide implementations for these methods.

You can think of an ABC as a blueprint for a house. The blueprint defines features such as rooms, windows, and doors but does not itself produce a physical house. Just like builders must follow the blueprint to create houses, subclasses must implement the abstract methods to create specific shapes.

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)

In this chunk, we see how the Rectangle class implements the abstract methods from the Shape base class. The Rectangle class defines its own constructor to initialize its attributes (width and height) and provides concrete implementations for the area and perimeter methods. This is called 'method overriding', where a subclass provides a specific implementation of a method defined in its parent class.

Imagine that the Shape class is like a general instruction, such as 'create a shape.' When we create a Rectangle, it's as if we are specifying exactly how to create that shape. Just like a gardener has general instructions for growing plants but must follow specific methods for each type of plant (like watering or sunlight requirements), a Rectangle must specify how it calculates its area and perimeter.

s = Shape()  # TypeError: Can't instantiate abstract class Shape with abstract methods area, perimeter

This line demonstrates the enforcement of abstract methods in Python. If you try to create an instance of the Shape class directly, Python raises a TypeError because Shape has abstract methods that are not implemented. This behavior ensures that developers cannot use abstract classes directly; they must create subclass instances instead, thereby ensuring that all necessary methods are properly defined.

Think of an abstract class like a recipe that is incomplete. If you tried to make the dish using just the recipe without any specific instructions, it wouldn’t be possible to create the dish. Similarly, without implementing the abstract methods, you cannot create an instance of the Shape class; you need to complete the recipe (define the classes) before cooking.

ABCs improve code reliability and make large projects easier to maintain by enforcing consistent interfaces.

Abstract Base Classes serve the purpose of interfaces in Python, as they provide a means to define method signatures that subclasses are obligated to implement. This characteristic helps create a consistent and predictable programming environment, particularly in large codebases where many developers might contribute. By ensuring that certain methods exist in every subclass, ABCs help maintain reliability across different parts of a program.

You can think of ABCs as a set of rules for how a team must work on a project. Just as a team will have guidelines to ensure everyone's work aligns (like deadlines and formats), ABCs provide a structure so that every subclass follows the same method signatures, making the code easier to understand and maintain.

--