Abstract Class in Python

An abstract class in Python is a class that cannot be instantiated directly. Instead, it serves as a blueprint for other classes. Abstract classes allow you to define methods that must be created within any child class built from the abstract class.

However, using an abstract class can be confusing for beginners, especially when understanding the purpose and implementation of abstract methods in Python. 

Without abstract classes, managing shared methods in multiple subclasses can become cumbersome and less organized.

In this guide, we'll explore how to use an abstract class in Python example, and walk you through the concept of abstract methods.  

By the end, you will have a basic understanding of how to implement abstract classes and methods, which will improve the organization and maintainability of your Python programs. 

“Enhance your Python skills further with our Data Science and Machine Learning courses from top universities — take the next step in your learning journey!”

Why Use Abstract Base Classes?

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. 

“Start your coding journey with our complimentary Python courses designed just for you — dive into Python programming fundamentals, explore key Python libraries, and engage with practical case studies!”

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: 50Perimeter 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: BarkThe 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: BarkThis is an animal.The sound of Whiskers is: MeowThis 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.

FAQs  

1. What is an abstract class in Python?

A. 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?

A. 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?

A. 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?

A. 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?

A. 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?

A. 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?

A. 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?

A. 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?

A. 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?

A. 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?

A. 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