Abstract Class in Python: Definition, Example, and Interface Comparison

Why can’t you directly create an object from some classes in Python—even when they look complete?That’s Python’s way of saying: this is an abstract class—finish it first.

An abstract class in Python is like a blueprint. You define the structure, but leave the implementation to its child classes. It’s Python’s way of enforcing a design without writing full code. If you’ve ever wondered what is abstract class in Python, or how it compares to interfaces, you’re in the right place.

In this blog, you’ll learn the role of abstract base classes in Python, how they differ from regular classes, and where they fit into real-world OOP (Object-Oriented Programming). We'll also break down the difference between abstract class and interface in Python, and show simple, clear abstract class examples in Python to solidify your understanding.

By the end, you’ll know how to use abstract class and interface in Python effectively—and where to apply them. Want to deepen your Python knowledge? Our Data Science Courses and Machine Learning Courses help you master these concepts in action.

What is an Abstract Class in Python?

An abstract class in Python is a class that cannot be instantiated directly. It is used to define a common structure or template for other classes.

Think of it as a blueprint—you define what methods must exist, but not how they work. Any class that inherits from it must implement those methods.

Python provides this through the abc module (abc stands for Abstract Base Class)

Let’s take an example to get a better understanding.

from abc import ABC, abstractmethod

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

class Dog(Animal):
    def sound(self):
        return "Bark"

class Cat(Animal):
    def sound(self):
        return "Meow"

# animal = Animal()  ❌ This will raise an error
dog = Dog()
print(dog.sound())

Output:

Bark

Why Use Abstract Base Classes in Python?

In Python, abstract base classes (ABCs) are used to define common methods that must be implemented in child classes. But why would you use abstract class in Python?

The key reason is that it provides a clear structure and ensures that all derived classes have the required methods, making your code more consistent and easier to maintain.

Without abstract base classes, you may end up with subclasses that don’t implement all necessary methods or behave inconsistently. An abstract method in Python ensures that any class inheriting from the abstract class must provide an implementation for that method, promoting code integrity.

This approach is essential when building complex systems where consistency across subclasses is important.

Looking to bridge the gap between Python practice and actual ML applications? A formal Data Science and Machine Learning course can help you apply these skills to real datasets and industry workflows.

• Master’s Degree in Artificial Intelligence and Data Science
• Generative AI Foundations Certificate Program

How Do Abstract Base Classes Work in Python?

Abstract Base Classes (ABCs) ensure that a base class defines methods that any subclass must implement.

Let’s take a look at an example:

from abc import ABC, abstractmethod

# Create an abstract base class

class Shape(ABC):
    @abstractmethod
    def area(self):
        pass
    @abstractmethod
    def perimeter(self):
        pass
# Create a class inheriting from Shape
class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height
    # Implement the abstract methods
    def area(self):
        return self.width * self.height    
    def perimeter(self):
        return 2 * (self.width + self.height)
# Create a Rectangle object
rect = Rectangle(5, 10)
# Output the area and perimeter
print(f"Area of Rectangle: {rect.area()}")
print(f"Perimeter of Rectangle: {rect.perimeter()}")

Output:

Area of Rectangle: 50

Perimeter of Rectangle: 30

Explanation:

1. Abstract Base Class Definition:

The Shape class is defined as an abstract class by inheriting from ABC. The area() and perimeter() methods are abstract methods because they are decorated with @abstractmethod. These methods have no implementation in the base class.

2. Subclass Implementation:

The Rectangle class inherits from Shape. It is required to implement the area() and perimeter() methods, as defined by the abstract class. This ensures that any class inheriting from Shape will have these essential methods.

3. Instantiating the Subclass:

We create an instance of Rectangle with width 5 and height 10. Since Rectangle has implemented the required abstract methods, we can successfully instantiate it and call the methods.

4. Output:

The program outputs the area (50) and perimeter (30) of the rectangle, as expected.

Why Is This Important?

• The key benefit of using an abstract class with abstract methods is that it ensures all derived classes implement the necessary methods. Without this, subclasses could be incomplete, which could lead to errors when the code is run.
• The abstract base class sets a clear contract for subclasses. Each subclass must adhere to this contract by implementing all abstract methods. This ensures that subclasses are consistent and follow the same structure.
• Abstract base classes help organize your code by grouping related methods in a central location (the abstract class). They also make your code easier to extend.

Also Read: Abstract Class in Java and Methods [With Examples]

Understanding Abstract Properties in Python

In Python, abstract properties allow you to define properties in an abstract class that any subclass must implement. Like abstract methods, abstract properties are defined without implementation in the base class, but they must be given concrete implementations in the derived classes.

Abstract properties provide a way to enforce a consistent structure in your classes.

Let’s look at an example:

from abc import ABC, abstractmethod

# Create an abstract class

class Animal(ABC):
    @property
    @abstractmethod
    def sound(self):
        pass 
# Create a subclass of Animal
class Dog(Animal):
    def __init__(self, name):
        self._name = name
    # Implement the abstract property
    @property
    def sound(self):
        return "Bark"
# Create another subclass of Animal
class Cat(Animal):
    def __init__(self, name):
        self._name = name
    # Implement the abstract property
    @property
    def sound(self):
        return "Meow" 
# Instantiate Dog and Cat
dog = Dog("Buddy")
cat = Cat("Whiskers")
# Output the sounds
print(f"The sound of {dog._name} is: {dog.sound}")
print(f"The sound of {cat._name} is: {cat.sound}") 

Output:

The sound of Buddy is: Bark

The sound of Whiskers is: Meow

Explanation:

1. Abstract Class Definition:
2. • Animal is defined as an abstract class by inheriting from ABC. The sound property is decorated with both @property and @abstractmethod, making it an abstract property.
   • An abstract property is similar to an abstract method, but it is used to manage an attribute that will be defined in subclasses.
2. Subclass Implementation:
3. • Both Dog and Cat inherit from Animal. They each implement the sound property with their own specific behavior (Bark for Dog and Meow for Cat).
   • The @property decorator allows the sound method to be accessed as an attribute rather than a method call.
3. Instantiation and Output:
4. • We create instances of Dog and Cat, then access their sound properties. The respective sounds are printed to the screen.

Why Use Abstract Properties?

• Abstract properties ensure that every subclass defines its own version of the property. This is particularly useful for managing attributes that may have different implementations depending on the subclass.
• Just like abstract methods, abstract properties ensure that derived classes provide their own functionality for crucial attributes, preventing errors or missing implementations.
• Abstract properties improve code organization by forcing subclasses to define specific attributes. This can be helpful in large systems where different subclasses are expected to adhere to a common interface.

Concrete Methods in Abstract Base Classes

In Python, abstract base classes (ABCs) can also contain concrete methods—methods that are completely implemented in the abstract class itself.

The presence of concrete methods in an abstract class allows for a blend of enforced structure and reusable code.

Let’s look at an example:

from abc import ABC, abstractmethod

# Create an abstract class with both abstract and concrete methods

class Animal(ABC):
    @abstractmethod
    def sound(self):
        pass 
 # Concrete method
    def describe(self):
        return "This is an animal."
# Create a subclass of Animal
class Dog(Animal):
    def __init__(self, name):
        self._name = name
    # Implement the abstract method
    def sound(self):
        return "Bark"
# Create another subclass of Animal
class Cat(Animal):
    def __init__(self, name):
        self._name = name
    # Implement the abstract method
    def sound(self):
        return "Meow"
# Instantiate Dog and Cat
dog = Dog("Buddy")
cat = Cat("Whiskers") 
# Output the sounds and descriptions
print(f"The sound of {dog._name} is: {dog.sound()}")
print(dog.describe())  # Using the concrete method from Animal
print(f"The sound of {cat._name} is: {cat.sound()}")
print(cat.describe())  # Using the concrete method from Animal 

Output:

The sound of Buddy is: Bark

This is an animal.

The sound of Whiskers is: Meow

This is an animal.

Explanation:

1. Abstract Class Definition:
2. • Animal is defined as an abstract base class. It contains both an abstract method (sound()) and a concrete method (describe()).
   • The abstract method sound() enforces that subclasses must provide their own implementation of this method.
   • The concrete method describe() provides a default implementation that all subclasses can use.
2. Subclass Implementation:
3. • Both Dog and Cat inherit from Animal. They each implement the sound() method, which is required because it's abstract.
   • However, both subclasses can also use the describe() method directly without needing to override it, as it is a concrete method already provided in the base class.
3. Instantiation and Output:
4. • When we create instances of Dog and Cat, we call the sound() method, which is implemented by each subclass.
   • We also call the describe() method, which is inherited directly from the Animal class. This demonstrates the use of a concrete method.

Why Use Concrete Methods in Abstract Classes?

1. Concrete methods allow you to define common functionality that all subclasses can reuse.
2. While abstract methods enforce certain functionality in subclasses, concrete methods provide flexibility. Subclasses can either use the default behavior or override the method if necessary.
3. By using concrete methods in abstract classes, you ensure that common functionality is centralized and can be shared across multiple subclasses, resulting in cleaner and more maintainable code.

Abstract Class in Python Instantiation

In Python, an abstract class cannot be instantiated directly. Attempting to do so will result in a TypeError. This behavior exists because abstract classes are designed to be inherited by other classes, not used as stand-alone objects. Abstract classes provide a blueprint for subclasses, enforcing the implementation of abstract methods and properties. This ensures that derived classes are consistent and complete.

Let’s look at an example:

from abc import ABC, abstractmethod

# Define an abstract base class

class Animal(ABC):
    @abstractmethod
    def sound(self):
        pass 
# Try to instantiate the abstract class
try:
    animal = Animal()  # This will raise a TypeError
except TypeError as e:
    print(f"Error: {e}")

Output:

Error: Can't instantiate abstract class Animal with abstract methods sound

Explanation:

1. Abstract Class Definition:
2. • The Animal class is an abstract class, with an abstract method sound() that has no implementation in the base class. The @abstractmethod decorator ensures that any class inheriting from Animal must implement this method.
2. Attempting Instantiation:
3. • When we try to instantiate Animal directly with animal = Animal(), Python raises a TypeError. This is because you cannot create instances of abstract classes that have unimplemented abstract methods.
3. Error Message:
4. • The error message clearly indicates that the class cannot be instantiated because it still contains abstract methods that need to be implemented by a subclass.

Instantiating a Concrete Subclass

In order to work with abstract classes, you need to define a subclass that implements all abstract methods. This subclass can then be instantiated.

# Create a subclass of Animal

class Dog(Animal):
    def sound(self):
        return "Bark"
# Instantiate the Dog class
dog = Dog()
print(dog.sound())

Output:

Bark

Explanation:

1. Concrete Subclass Definition:
2. • Dog inherits from Animal and implements the sound() method, providing the required functionality for the abstract method.
2. Instantiation of Concrete Subclass:
3. • Unlike Animal, we can instantiate Dog because it has provided implementations for all abstract methods. In this case, the sound() method returns "Bark" when called.

Why Can’t We Instantiate an Abstract Class?

1. Enforcing Consistency:
2. • Abstract classes are meant to serve as blueprints for other classes. By preventing direct instantiation, Python ensures that an abstract class cannot be used before a subclass fully implements it.
2. Preventing Incomplete Objects:
3. • Abstract methods represent important functionality that the subclass must define. Instantiating an abstract class without implementing these methods would result in incomplete and potentially buggy objects.
3. Design and Organization:
4. • Abstract classes help organize code by allowing you to define common interfaces for related classes while leaving the details to the subclasses. This structure avoids unnecessary duplication and keeps code organized.

Difference Between Abstract Class and Interface in Python

Want to know more? Explore our blog on: Abstract Class and Interface.

Now, it’s time for some practice and test your learning about Abstract class in Python

MCQs Related to Abstract Class in Python

1. Which module is used to define an abstract class in Python?

a) abc

b) abstract

c) interface

d) baseclass

2. What does ABC stand for in the context of Python OOP?

a) Abstract Base Class

b) Abstract Built-in Class

c) Absolute Base Class

d) Advanced Base Component

3. What happens if you instantiate an abstract class with abstract methods?

a) Runs normally

b) Syntax warning

c) Raises TypeError

d) Returns None

4. Which decorator is used to define an abstract method?

a) @classmethod

b) @staticmethod

c) @abstractmethod

d) @method

5. What is the purpose of an abstract class in Python?

a) It provides memory optimization

b) It allows defining methods without implementation

c) It defines static methods only

d) It prevents inheritance

6. Which of the following is true about abstract methods in Python?

a) They must be defined in all subclasses

b) They can be left unimplemented

c) They require the super() call

d) They can’t be overridden

7. How do abstract classes differ from interfaces in Python?

a) Interfaces allow constructors

b) Abstract classes can have implemented methods

c) Interfaces support private methods

d) Interfaces allow multiple inheritance only

8. What will happen if a subclass does not implement all abstract methods of its base class?

a) It works with default behavior

b) It raises NotImplementedError

c) It remains abstract and can't be instantiated

d) It compiles but fails at runtime

9. You define an abstract class with one method marked with @abstractmethod. Your subclass overrides it. What will happen if you forget to use the decorator?

a) Subclass won't work

b) It behaves like a normal method

c) Python raises an error

d) Abstract class turns into an interface

10. You want to create a template class with common logic and force specific behavior in subclasses. What should you use?

a) Abstract class

b) Regular class

c) Static method

d) Class method

FAQs

1. What is an abstract class in Python?

An abstract class in Python is a class that cannot be instantiated directly. It can include abstract methods that any subclass must implement.

2. What is the purpose of abstract methods in Python?

An abstract method in Python is a method declared in an abstract class that does not have an implementation. Subclasses must implement this method.

3. Can we instantiate an abstract class in Python?

No, you cannot instantiate an abstract class in Python example directly. It must be inherited, and its abstract methods must be implemented before instantiation.

4. How do abstract classes help in Python?

Abstract classes in Python help enforce a structure for subclasses, ensuring that all required methods are implemented making code more organized and maintainable.

5. What happens if a subclass does not implement the abstract methods in Python?

If a subclass doesn't implement the abstract methods, Python will raise a TypeError, indicating that the subclass must define all abstract methods from its abstract class.

6. Can abstract classes have concrete methods in Python?

Yes, abstract classes can have concrete methods, which are fully implemented methods that can be used by subclasses, in addition to abstract methods that must be overridden.

7. How does Python treat abstract classes?

Python treats abstract classes as a blueprint for other classes. They cannot be instantiated on their own and must be extended by other classes that provide concrete implementations.

8. What is the difference between an abstract class and an interface in Python?

While both define a contract for subclasses, an abstract class in Python example can include method implementations, whereas an interface only specifies methods to be implemented with no implementation.

9. Can an abstract class have properties in Python?

Yes, an abstract class in Python example can have abstract properties, which must be implemented by the subclass, just like abstract methods.

10. Can an abstract class implement multiple interfaces in Python?

Yes, an abstract class can inherit from multiple interfaces or abstract classes in Python, allowing it to enforce the implementation of multiple sets of methods.

11. How can we implement an abstract class in Python with a constructor?

You can define a constructor in an abstract class in Python example like any other class. However, the constructor cannot be used directly until the class is subclassed and instantiated.

Take our Free Quiz on Python

Answer quick questions and assess your Python knowledge

Start Quiz