• Page Contents
• Page Summary

Introduction

In practice, code in abstract classes typically contains more than just the pass statement. Abstract classes serve as blueprints for derived classes, providing common attributes, methods, or properties that are meant to be implemented or extended by their subclasses.

While the abstract methods are indeed declared using @abstractmethod decorators with a pass statement in their implementation, the abstract class can have other concrete methods or properties that may provide default behavior or functionality shared among its subclasses.

Let's take the Shape example from earlier and expand it to include a concrete method in the abstract class:

from abc import ABC, abstractmethod, abstractproperty

class Shape(ABC):
    @abstractmethod
    def calculate_area(self):
        pass

    @abstractproperty
    def perimeter(self):
        pass

    def display_info(self):
        print(f"This is a {type(self).__name__} with area: {self.calculate_area()} and perimeter: {self.perimeter}.")

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def calculate_area(self):
        return 3.14 * self.radius ** 2

    @property
    def perimeter(self):
        return 2 * 3.14 * self.radius

class Square(Shape):
    def __init__(self, side):
        self.side = side

    def calculate_area(self):
        return self.side ** 2

    @property
    def perimeter(self):
        return 4 * self.side

In this example, Shape now includes a concrete method display_info() that provides default behavior for displaying information about a shape. It does not have the @abstractmethod decorator, so it doesn't need a pass statement in its implementation. However, it relies on the abstract methods calculate_area() and perimeter(), which are implemented in the Circle and Square subclasses.

In summary, while abstract classes often have abstract methods with pass statements, they can also have concrete methods or properties that provide default behaviors or functionalities shared by their subclasses. This combination of abstract and concrete methods in abstract classes helps structure the code and encourage code reusability.

More Reasons

Using only "pass" in abstract classes for the implementation of abstract methods (i.e., using @abstractmethod) is a recommended practice for several reasons:

• Clarity and Intent
  • "pass" implementation indicates that the method is meant to be overridden by subclasses, providing clarity to developers that the method's behavior is not defined in the abstract base class.
• Avoiding Errors
  • "pass" prevents accidental execution of the abstract method, which could lead to runtime errors or undesired behaviors. Instead, Python's abc module ensures that any attempt to create an instance of the abstract class without implementing the abstract method results in an error, enforcing the requirement for subclasses to provide the implementation.
• Future-Proofing
  • "pass" allows you to design the abstract class's interface without tying it to any specific implementation details. This future-proofs the class, making it more adaptable to changes and allowing derived classes to implement the method as needed, without the constraints of an existing implementation.
• Flexibility
  • The "pass" implementation allows derived classes to choose the most suitable approach for implementing the abstract method. Different subclasses may have unique implementations depending on their requirements, and using "pass" provides the freedom to make those choices.
• Separation of Concerns
  • Abstract classes serve as blueprints, defining the interface without going into implementation details. By using "pass," you separate the specification of the interface from the actual behavior, promoting better code organization and maintainability.
• Encourages Extensibility
  • By keeping abstract classes simple and focused on defining the interface, you encourage extensibility of the codebase. Developers can easily create new subclasses that conform to the abstract class's contract without being bound to specific internal implementations.
• Code Reusability
  • Using "pass" in abstract classes encourages the reuse of code across different subclasses. The abstract class provides a common structure and set of methods that derived classes can implement, leading to code that is more modular and easier to maintain.

In summary, using only "pass" in abstract classes for the implementation of abstract methods is a best practice that promotes clarity, safety, and flexibility. It enables clear separation of concerns and encourages code reusability and extensibility, leading to a well-designed and maintainable codebase.