Using abc Module for Abstract Classes in Python

Why Bother With Abstract Classes in Python? Let's Look at abc

If you've been writing Python for a while, you've probably reached that point where you're building a system and thinking, "I need all these classes to have the same methods, but I want them to work differently." That's where abstract classes come in, and Python's abc module is your toolbox for this job.

I remember when I first encountered this at PythonSkillset. We had a payment processing system, and every payment method (credit card, PayPal, bank transfer) needed a process_payment() method, but each one did it completely differently. Without abstract classes, we'd just cross our fingers and hope developers remembered to implement it. With abc, we could enforce this contract.

The Problem Abstract Classes Solve

Let's say you're building a notification system. You have email, SMS, and push notifications. Without abstract classes:

class EmailNotification:
    def send(self, message):
        print(f"Sending email: {message}")

class SMSNotification:
    def send(self, message):
        print(f"Sending SMS: {message}")

This works fine until someone new joins your team and creates a notification class but forgets to implement send(). Or worse, they name it dispatch() instead. Your code breaks silently.

Enter the abc Module

The abc module provides the ABC class and abstractmethod decorator. Here's how to redesign that notification system:

from abc import ABC, abstractmethod

class Notification(ABC):
    @abstractmethod
    def send(self, message):
        """Send a notification with the given message."""
        pass

    # This is just a class method, not abstract
    def log(self, message):
        with open('notification_log.txt', 'a') as f:
            f.write(f"{message}\n")

Now if someone tries to create a concrete notification class without implementing send(), Python will raise an error immediately:

class PushNotification(Notification):
    pass  # This will fail with TypeError

# Running this code:
# TypeError: Can't instantiate abstract class PushNotification 
# with abstract method send

And when they do implement it correctly:

class PushNotification(Notification):
    def send(self, message):
        # Actually send push notification
        notification_service.post(message)

    # The log() method is inherited automatically

Why This Matters in Real Projects

At PythonSkillset, we use abstract classes in several key places:

1. Plugin systems - When allowing third-party developers to extend our platform, abstract classes define exactly what methods they must implement.

2. Data source connectors - Whether connecting to PostgreSQL, MongoDB, or an API, every connector must implement connect(), disconnect(), and query().

3. Testing and mocking - Abstract classes make it crystal clear what interface a mock needs to provide.

Common Gotchas

Can I call super().__init__() in an abstract class? Yes, absolutely. Abstract classes can have __init__ methods, and you should call them from concrete classes:

class BaseAPI(ABC):
    def __init__(self, api_key):
        self.api_key = api_key
        self.base_url = "https://api.example.com"

    @abstractmethod
    def fetch_data(self, endpoint):
        pass

class WeatherAPI(BaseAPI):
    def __init__(self, api_key, city):
        super().__init__(api_key)  # Always call parent __init__
        self.city = city

    def fetch_data(self, endpoint):
        return requests.get(f"{self.base_url}/{endpoint}/{self.city}")

Can I have property abstractions? Yes, abstract properties work too:

class Vehicle(ABC):
    @property
    @abstractmethod
    def fuel_type(self):
        pass

class ElectricCar(Vehicle):
    @property
    def fuel_type(self):
        return "electricity"

When Not to Use Abstract Classes

Here's the honest truth: not everything needs to be abstract. If you're writing a small script or a one-off class, just use duck typing. Abstract classes shine when:

• Multiple developers work on the codebase
• You're building a framework or library others will extend
• You need formal documentation of interfaces
• You want to catch missing method implementations at instantiation time, not at runtime

The Bottom Line

Python's abc module gives you a way to enforce interfaces without sacrificing the language's flexibility. It's not about writing more code—it's about writing code that fails early and clearly when someone doesn't follow the pattern.

Start simple: next time you have two or three classes that share a method name, consider making an abstract base class. Your future self (and your teammates) will thank you when a missing method gets caught in seconds instead of hours of debugging.