Python Abstract Base Classes (ABC) Tutorial – Abstract Classes and Methods Explained

Python Abstract Base Classes (ABC)

In Object-Oriented Programming (OOP), there are situations where you want to define a common structure for multiple classes but prevent direct instantiation of the base class.

Python provides Abstract Base Classes (ABCs) for this purpose.

Abstract Base Classes help developers:

• Define common interfaces
• Enforce method implementation
• Improve code organization
• Build scalable applications
• Follow OOP best practices

---

What is an Abstract Base Class?

An Abstract Base Class (ABC) is a class that cannot be instantiated directly and is designed to be inherited by other classes.

It serves as a blueprint for derived classes.

Example Concept

Animal (Abstract Class)
   |
   ├── Dog
   ├── Cat
   └── Bird

Each subclass must implement the methods defined in the abstract class.

---

Why Use Abstract Base Classes?

ABCs help:

• Enforce consistency
• Define required methods
• Reduce duplicate code
• Improve maintainability
• Support polymorphism

---

The abc Module

Python provides the built-in abc module.

from abc import ABC, abstractmethod

---

Creating an Abstract Class

from abc import ABC, abstractmethod

class Shape(ABC):

    @abstractmethod
    def area(self):
        pass

---

Explanation

• ABC makes the class abstract
• @abstractmethod marks methods that must be implemented

---

Attempting to Create an Object

shape = Shape()

Output

TypeError:
Can't instantiate abstract class Shape

---

Implementing an Abstract Method

from abc import ABC, abstractmethod

class Shape(ABC):

    @abstractmethod
    def area(self):
        pass

class Circle(Shape):

    def area(self):
        return "Calculating Circle Area"

circle = Circle()

print(circle.area())

Output

Calculating Circle Area

---

Multiple Abstract Methods

from abc import ABC, abstractmethod

class Vehicle(ABC):

    @abstractmethod
    def start(self):
        pass

    @abstractmethod
    def stop(self):
        pass

---

Implementing All Methods

class Car(Vehicle):

    def start(self):
        print("Car Started")

    def stop(self):
        print("Car Stopped")

---

Missing Abstract Methods

class Bike(Vehicle):

    def start(self):
        print("Bike Started")

Output

TypeError:
Can't instantiate abstract class Bike

Because stop() is not implemented.

---

Abstract Class with Concrete Methods

Abstract classes can contain normal methods.

from abc import ABC, abstractmethod

class Animal(ABC):

    @abstractmethod
    def sound(self):
        pass

    def sleep(self):
        print("Animal Sleeping")

---

Example

class Dog(Animal):

    def sound(self):
        print("Bark")

dog = Dog()

dog.sound()
dog.sleep()

Output

Bark
Animal Sleeping

---

Abstract Properties

You can create abstract properties.

from abc import ABC, abstractmethod

class Employee(ABC):

    @property
    @abstractmethod
    def salary(self):
        pass

---

Implementing Abstract Property

class Developer(Employee):

    @property
    def salary(self):
        return 5000

---

ABC and Polymorphism

Abstract classes work well with polymorphism.

class Rectangle(Shape):

    def area(self):
        return "Rectangle Area"

class Triangle(Shape):

    def area(self):
        return "Triangle Area"

shapes = [Rectangle(), Triangle()]

for shape in shapes:
    print(shape.area())

---

Output

Rectangle Area
Triangle Area

---

Abstract Base Classes vs Regular Classes

Feature	Regular Class	Abstract Class
Can Create Objects	Yes	No
Abstract Methods	No	Yes
Blueprint Design	Limited	Strong
Interface Enforcement	No	Yes

---

Abstract Base Classes vs Interfaces

Python does not have traditional interfaces like Java.

ABCs are commonly used as interface-like structures.

class PaymentGateway(ABC):

    @abstractmethod
    def process_payment(self):
        pass

---

Real-World Applications

ABCs are used in:

• Payment systems
• Database drivers
• Game engines
• Web frameworks
• Plugin architectures
• API development

---

Advantages of Abstract Base Classes

• Better code structure
• Consistent implementation
• Supports polymorphism
• Easier maintenance
• Improved scalability

---

Best Practices

• Use ABCs for shared interfaces
• Keep abstract methods focused
• Use meaningful method names
• Avoid unnecessary abstraction
• Document abstract methods clearly

---

Common Mistakes

Instantiating an Abstract Class

shape = Shape()

This will raise an error.

---

Forgetting to Implement Methods

class Child(Parent):
    pass

All abstract methods must be implemented.

---

Summary

Abstract Base Classes provide a powerful way to define interfaces and enforce method implementation in Python. They improve code consistency, maintainability, and support advanced object-oriented programming concepts.

---

Conclusion

Python Abstract Base Classes are essential for designing scalable and maintainable applications. By using the abc module, developers can create clear contracts between classes and ensure that derived classes implement required functionality properly.