Abstract Classes and Interfaces in Python

Abstract classes and interfaces in Python allow developers to define a blueprint for other classes. They provide a way to enforce certain methods that must be implemented by subclasses, ensuring consistency in object-oriented programming.

What is an Abstract Class?

An abstract class in Python is a class that cannot be instantiated directly. Instead, it serves as a template for other classes. Abstract classes can define abstract methods, which must be implemented by subclasses.

What is an Interface?

In Python, interfaces are typically implemented using abstract classes. Unlike a regular class, an interface contains only method declarations without implementations. It enforces that any class implementing the interface must define all its methods.

Defining an Abstract Class

Abstract classes are created using the ABC (Abstract Base Class) module in Python. We use the @abstractmethod decorator to define methods that must be implemented in subclasses.

</>
Copy
from abc import ABC, abstractmethod

# Defining an abstract class
class Animal(ABC):

    @abstractmethod
    def make_sound(self):
        """Abstract method that must be implemented by subclasses"""
        pass

Here, the Animal class is an abstract class that defines an abstract method make_sound(). Any class that inherits from Animal must implement this method.

Implementing an Abstract Class

Subclasses must implement all abstract methods from the parent abstract class. Otherwise, Python will raise an error.

</>
Copy
from abc import ABC, abstractmethod

# Defining an abstract class
class Animal(ABC):

    @abstractmethod
    def make_sound(self):
        """Abstract method that must be implemented by subclasses"""
        pass

class Dog(Animal):
    
    def make_sound(self):
        return "Woof!"

# Instantiate the subclass
dog = Dog()
print(dog.make_sound())

Output:

Woof!

Here, Dog inherits from Animal and implements the make_sound() method. When we create an instance of Dog and call make_sound(), it returns “Woof!”.

Creating an Interface in Python

Python does not have a built-in interface keyword like Java or C#. Instead, we can use an abstract class to define an interface.

</>
Copy
from abc import ABC, abstractmethod

class Vehicle(ABC):
    
    @abstractmethod
    def start_engine(self):
        pass

    @abstractmethod
    def stop_engine(self):
        pass

Here, Vehicle acts as an interface by defining abstract methods that subclasses must implement.

Implementing an Interface

To implement an interface, a class must provide concrete implementations for all abstract methods.

</>
Copy
from abc import ABC, abstractmethod

class Vehicle(ABC):
    
    @abstractmethod
    def start_engine(self):
        pass

    @abstractmethod
    def stop_engine(self):
        pass

class Car(Vehicle):
    
    def start_engine(self):
        return "Car engine started."
    
    def stop_engine(self):
        return "Car engine stopped."

car = Car()
print(car.start_engine())
print(car.stop_engine())

Output:

Car engine started.
Car engine stopped.

Here, Car implements the Vehicle interface by defining both start_engine() and stop_engine(). If we try to create an instance of Car without defining these methods, Python will raise an error.

Handling Errors: Missing Method Implementation

If a subclass does not implement all abstract methods, Python raises a TypeError. Let’s see an example:

</>
Copy
from abc import ABC, abstractmethod

class Vehicle(ABC):
    
    @abstractmethod
    def start_engine(self):
        pass

    @abstractmethod
    def stop_engine(self):
        pass

class Bike(Vehicle):
    def start_engine(self):
        return "Bike engine started."

# Trying to instantiate Bike without implementing stop_engine()
try:
    bike = Bike()
except TypeError as e:
    print("Error:", e)

Output:

Error: Can't instantiate abstract class Bike without an implementation for abstract method 'stop_engine'

Since Bike does not implement stop_engine(), Python raises a TypeError, preventing instantiation.

Conclusion

Abstract classes and interfaces in Python help in designing structured and reusable code by enforcing method implementation rules. While Python does not have a built-in interface keyword, abstract base classes provide a similar functionality.