Python Abstract Classes

last modified March 25, 2025

Abstract classes in Python are classes that cannot be instantiated and are designed to be inherited by other classes. They serve as blueprints for other classes, defining a common interface that subclasses must implement. Python provides the abc module to work with abstract base classes (ABCs).

Abstract classes are particularly useful when you want to define a common API for a group of related classes while enforcing certain methods to be implemented in subclasses. They help create more maintainable and predictable code by explicitly defining what methods subclasses should implement. The @abstractmethod decorator marks methods that must be overridden in concrete subclasses.

Creating a Basic Abstract Class

This example demonstrates how to create and use a simple abstract class in Python.

basic_abc.py

from abc import ABC, abstractmethod

class Shape(ABC):

    @abstractmethod
    def area(self):
        pass

    @abstractmethod
    def perimeter(self):
        pass

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)

rect = Rectangle(5, 10)
print(rect.area())      # Output: 50
print(rect.perimeter()) # Output: 30

# shape = Shape()  # Raises TypeError

The Shape class is an abstract base class that defines two abstract methods: area and perimeter. Any concrete subclass like Rectangle must implement these methods. Attempting to instantiate the abstract class directly raises a TypeError.

Abstract Properties

This example shows how to define abstract properties in an abstract class.

abstract_properties.py

from abc import ABC, abstractmethod

class Person(ABC):

    @property
    @abstractmethod
    def name(self):
        pass

    @abstractmethod
    def speak(self):
        pass

class Employee(Person):

    def __init__(self, first_name, last_name):
        self._name = f"{first_name} {last_name}"

    @property
    def name(self):
        return self._name

    def speak(self):
        return f"Hello, my name is {self.name}"

emp = Employee("John", "Doe")
print(emp.name)    # Output: John Doe
print(emp.speak()) # Output: Hello, my name is John Doe

Abstract properties combine the @property decorator with @abstractmethod to require concrete subclasses to implement specific properties. In this example, the Employee class implements both the abstract name property and the abstract speak method.

Abstract Class with Concrete Methods

This example demonstrates an abstract class that includes both abstract and concrete methods.

concrete_methods.py

from abc import ABC, abstractmethod

class Database(ABC):
    @abstractmethod
    def connect(self):
        pass

    @abstractmethod
    def query(self, sql):
        pass

    def execute(self, sql):
        conn = self.connect()
        result = self.query(sql)
        conn.close()
        return result

class MySQLDatabase(Database):
    def connect(self):
        print("Connecting to MySQL database")
        return "mysql_connection"

    def query(self, sql):
        print(f"Executing MySQL query: {sql}")
        return "query_results"

db = MySQLDatabase()
db.execute("SELECT * FROM users")

Abstract classes can include both abstract methods that subclasses must implement and concrete methods that provide shared functionality. In this example, the execute method is fully implemented in the abstract class but relies on abstract methods connect and query that subclasses must provide.

Registering Virtual Subclasses

This example shows how to register classes as virtual subclasses of an abstract base class without explicit inheritance.

virtual_subclasses.py

from abc import ABC, abstractmethod

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

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

Animal.register(Dog)  # Register Dog as virtual subclass

dog = Dog()
print(isinstance(dog, Animal))  # Output: True
print(issubclass(Dog, Animal))  # Output: True
print(dog.make_sound())         # Output: Woof!

The register method allows you to declare that a class implements an abstract base class without explicitly inheriting from it. The registered class must implement all abstract methods, but this isn't checked until you try to use the methods. This is useful when working with classes you can't modify or when using duck typing.

Abstract Class with Class Methods

This example demonstrates using abstract class methods in an abstract base class.

abstract_classmethods.py

from abc import ABC, abstractmethod

class Serializer(ABC):

    @classmethod
    @abstractmethod
    def serialize(cls, data):
        pass

    @classmethod
    @abstractmethod
    def deserialize(cls, serialized_data):
        pass

class JSONSerializer(Serializer):

    @classmethod
    def serialize(cls, data):
        return f"JSON: {data}"

    @classmethod
    def deserialize(cls, serialized_data):
        return serialized_data.replace("JSON: ", "")

print(JSONSerializer.serialize({"key": "value"}))  # Output: JSON: {'key': 'value'}

Abstract class methods are defined using both the @classmethod and @abstractmethod decorators. Subclasses must implement these class methods. This pattern is useful when you want to enforce a class-level API across related classes, such as different serialization formats in this example.

Multiple Inheritance with Abstract Classes

This example shows how abstract classes can be used in multiple inheritance.

multiple_inheritance.py

from abc import ABC, abstractmethod

class Readable(ABC):

    @abstractmethod
    def read(self):
        pass

class Writable(ABC):

    @abstractmethod
    def write(self, data):
        pass

class ReadWriteFile(Readable, Writable):

    def __init__(self, filename):
        self.filename = filename

    def read(self):
        return f"Reading from {self.filename}"

    def write(self, data):
        return f"Writing '{data}' to {self.filename}"

file = ReadWriteFile("example.txt")
print(file.read())            # Output: Reading from example.txt
print(file.write("Hello"))   # Output: Writing 'Hello' to example.txt

Abstract classes can be combined through multiple inheritance to create classes that implement multiple interfaces. The ReadWriteFile class inherits from both Readable and Writable abstract classes and implements all their abstract methods. This approach allows for flexible interface definitions while maintaining strict implementation requirements.

Best Practices for Abstract Classes

Use for API Definition: Abstract classes are ideal for defining clear APIs that subclasses must implement.
Keep Abstract Methods Minimal: Only mark methods as abstract when they're truly required for the class's purpose.
Document Intent: Clearly document why methods are abstract and what implementations should do.
Prefer Composition: Consider whether composition might be better than inheritance for your use case.
Test Subclasses: Verify that subclasses properly implement all abstract methods.

Source

Python abc Module Documentation

In this article, we have explored Python abstract classes and demonstrated their usage in object-oriented design through practical examples.

Author

My name is Jan Bodnar, and I am a passionate programmer with extensive programming experience. I have been writing programming articles since 2007. To date, I have authored over 1,400 articles and 8 e-books. I possess more than ten years of experience in teaching programming.

List all Python tutorials.

Ebooks