Abstract Classes

Intermediate ~25 min read

Abstract classes define interfaces that subclasses must implement. Using Python's abc module, you can create classes that cannot be instantiated directly and enforce that child classes implement specific methods. This is Python's way of creating formal contracts between classes.

What Are Abstract Classes?

Abstract class: A class that cannot be instantiated directly
Abstract method: A method with no implementation that must be overridden
Concrete method: A regular method with implementation (can be inherited)
Subclasses must implement ALL abstract methods to be instantiable

Abstract Class Basics

Inherit from ABC and use @abstractmethod to define methods that subclasses must implement. Trying to instantiate an incomplete class raises TypeError.

# Abstract Class Basics

print("=== Abstract Class Basics ===\n")

from abc import ABC, abstractmethod

# 1. Defining an abstract class
print("1. Abstract class with ABC:")

class Animal(ABC):
    """Abstract base class - cannot be instantiated."""

def __init__(self, name):
        self.name = name

@abstractmethod
    def speak(self):
        """Subclasses MUST implement this method."""
        pass

@abstractmethod
    def move(self):
        """Another abstract method."""
        pass

def describe(self):
        """Concrete method - inherited by subclasses."""
        return f"I am {self.name}"

# Try to instantiate abstract class
try:
    animal = Animal("Generic")
except TypeError as e:
    print(f"   Cannot instantiate Animal: {e}")
print()

# 2. Implementing abstract methods
print("2. Concrete classes implementing abstract methods:")

class Dog(Animal):
    def speak(self):
        return f"{self.name} says Woof!"

def move(self):
        return f"{self.name} runs on four legs"

class Bird(Animal):
    def speak(self):
        return f"{self.name} says Tweet!"

def move(self):
        return f"{self.name} flies through the air"

# These can be instantiated - all abstract methods implemented
dog = Dog("Buddy")
bird = Bird("Tweety")

print(f"   {dog.describe()}")
print(f"   {dog.speak()}")
print(f"   {dog.move()}")
print()
print(f"   {bird.describe()}")
print(f"   {bird.speak()}")
print()

# 3. Incomplete implementation fails
print("3. Must implement ALL abstract methods:")

class Fish(Animal):
    def speak(self):
        return f"{self.name} bubbles"
    # Missing move() method!

try:
    fish = Fish("Nemo")
except TypeError as e:
    print(f"   Cannot instantiate Fish: incomplete implementation")
print()

# 4. Abstract classes can have concrete methods
print("4. Mix of abstract and concrete methods:")

class Shape(ABC):
    def __init__(self, color):
        self.color = color

@abstractmethod
    def area(self):
        """Must implement."""
        pass

@abstractmethod
    def perimeter(self):
        """Must implement."""
        pass

def describe(self):
        """Concrete method - uses abstract methods."""
        return f"A {self.color} shape with area {self.area():.2f}"

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

def area(self):
        import math
        return math.pi * self.radius ** 2

def perimeter(self):
        import math
        return 2 * math.pi * self.radius

circle = Circle("red", 5)
print(f"   {circle.describe()}")
print(f"   Perimeter: {circle.perimeter():.2f}")

Output

Click Run to execute your code

Concrete Methods in Abstract Classes

Abstract classes can have concrete (implemented) methods too. These are inherited normally. Use this for shared functionality that all subclasses need, while still enforcing that specific methods must be customized.

Abstract Properties

You can also define abstract properties that subclasses must implement. Stack @property and @abstractmethod decorators (property first).

# Abstract Properties

print("=== Abstract Properties ===\n")

from abc import ABC, abstractmethod

# 1. Abstract property (getter only)
print("1. Abstract property:")

class Vehicle(ABC):
    @property
    @abstractmethod
    def max_speed(self):
        """Subclasses must define max_speed property."""
        pass

@property
    @abstractmethod
    def wheels(self):
        """Subclasses must define wheels property."""
        pass

def describe(self):
        return f"Vehicle with {self.wheels} wheels, max {self.max_speed} mph"

class Car(Vehicle):
    @property
    def max_speed(self):
        return 120

@property
    def wheels(self):
        return 4

class Motorcycle(Vehicle):
    @property
    def max_speed(self):
        return 150

@property
    def wheels(self):
        return 2

car = Car()
moto = Motorcycle()

print(f"   Car: {car.describe()}")
print(f"   Motorcycle: {moto.describe()}")
print()

# 2. Abstract property with setter
print("2. Abstract property with getter and setter:")

class Account(ABC):
    @property
    @abstractmethod
    def balance(self):
        """Get balance."""
        pass

@balance.setter
    @abstractmethod
    def balance(self, value):
        """Set balance."""
        pass

class BankAccount(Account):
    def __init__(self, initial_balance=0):
        self._balance = initial_balance

@property
    def balance(self):
        return self._balance

@balance.setter
    def balance(self, value):
        if value < 0:
            raise ValueError("Balance cannot be negative")
        self._balance = value

account = BankAccount(100)
print(f"   Initial balance: ${account.balance}")
account.balance = 500
print(f"   New balance: ${account.balance}")
print()

# 3. Combining abstract methods and properties
print("3. Complete interface with methods and properties:")

class FileHandler(ABC):
    @property
    @abstractmethod
    def extension(self):
        """File extension this handler supports."""
        pass

@abstractmethod
    def read(self, filename):
        """Read file and return contents."""
        pass

@abstractmethod
    def write(self, filename, data):
        """Write data to file."""
        pass

def can_handle(self, filename):
        """Concrete method using abstract property."""
        return filename.endswith(self.extension)

class JSONHandler(FileHandler):
    @property
    def extension(self):
        return ".json"

def read(self, filename):
        return f"Reading JSON from {filename}"

def write(self, filename, data):
        return f"Writing JSON to {filename}"

class CSVHandler(FileHandler):
    @property
    def extension(self):
        return ".csv"

def read(self, filename):
        return f"Reading CSV from {filename}"

def write(self, filename, data):
        return f"Writing CSV to {filename}"

handlers = [JSONHandler(), CSVHandler()]
for handler in handlers:
    print(f"   Handler for {handler.extension}:")
    print(f"      Can handle 'data.json': {handler.can_handle('data.json')}")
    print(f"      Can handle 'data.csv': {handler.can_handle('data.csv')}")

Output

Click Run to execute your code

Decorator Order Matters

When combining decorators, @property must come before @abstractmethod:

@property
@abstractmethod
def name(self):
    pass

Practical Examples

Abstract classes are ideal for defining interfaces in plugin systems, database drivers, payment processors, and other extensible systems.

# Practical Abstract Class Examples

print("=== Practical Abstract Classes ===\n")

from abc import ABC, abstractmethod

# 1. Database interface
print("1. Database interface pattern:")

class Database(ABC):
    """Abstract interface for database operations."""

@abstractmethod
    def connect(self):
        pass

@abstractmethod
    def execute(self, query):
        pass

@abstractmethod
    def close(self):
        pass

def query(self, sql):
        """Template method using abstract methods."""
        self.connect()
        result = self.execute(sql)
        self.close()
        return result

class SQLiteDB(Database):
    def connect(self):
        print("   Connecting to SQLite...")

def execute(self, query):
        print(f"   Executing: {query}")
        return ["row1", "row2"]

def close(self):
        print("   Closing SQLite connection")

class PostgresDB(Database):
    def connect(self):
        print("   Connecting to PostgreSQL...")

def execute(self, query):
        print(f"   Executing: {query}")
        return ["row1", "row2", "row3"]

def close(self):
        print("   Closing PostgreSQL connection")

# Use any database - same interface!
for db in [SQLiteDB(), PostgresDB()]:
    print(f"   Using {db.__class__.__name__}:")
    db.query("SELECT * FROM users")
    print()

# 2. Payment processor
print("2. Payment processor interface:")

class PaymentProcessor(ABC):
    @abstractmethod
    def process_payment(self, amount):
        pass

@abstractmethod
    def refund(self, transaction_id):
        pass

@property
    @abstractmethod
    def name(self):
        pass

class StripeProcessor(PaymentProcessor):
    @property
    def name(self):
        return "Stripe"

def process_payment(self, amount):
        return f"   {self.name}: Charged ${amount}"

def refund(self, transaction_id):
        return f"   {self.name}: Refunded {transaction_id}"

class PayPalProcessor(PaymentProcessor):
    @property
    def name(self):
        return "PayPal"

def process_payment(self, amount):
        return f"   {self.name}: Processed ${amount}"

def refund(self, transaction_id):
        return f"   {self.name}: Reversed {transaction_id}"

def checkout(processor, amount):
    """Works with any payment processor."""
    print(processor.process_payment(amount))

checkout(StripeProcessor(), 99.99)
checkout(PayPalProcessor(), 49.99)
print()

# 3. Plugin system
print("3. Plugin system:")

class Plugin(ABC):
    @property
    @abstractmethod
    def name(self):
        pass

@abstractmethod
    def activate(self):
        pass

@abstractmethod
    def execute(self, data):
        pass

class LoggerPlugin(Plugin):
    @property
    def name(self):
        return "Logger"

def activate(self):
        print(f"   [{self.name}] Activated")

def execute(self, data):
        print(f"   [{self.name}] Processing: {data}")

class ValidatorPlugin(Plugin):
    @property
    def name(self):
        return "Validator"

def activate(self):
        print(f"   [{self.name}] Activated")

def execute(self, data):
        is_valid = len(data) > 0
        print(f"   [{self.name}] Valid: {is_valid}")

# Plugin manager
plugins = [LoggerPlugin(), ValidatorPlugin()]
for plugin in plugins:
    plugin.activate()

for plugin in plugins:
    plugin.execute("test data")

Output

Click Run to execute your code

Template Method Pattern

Abstract classes enable the Template Method pattern: define the skeleton of an algorithm in a concrete method, calling abstract methods that subclasses customize. The abstract class controls the flow while subclasses provide specific behavior.

Abstract Classes vs Duck Typing

Python offers both explicit interfaces (ABC) and implicit interfaces (duck typing). Understanding when to use each is key to Pythonic design.

# Abstract Classes vs Duck Typing

print("=== Abstract Classes vs Duck Typing ===\n")

from abc import ABC, abstractmethod

# 1. Duck typing approach (no ABC)
print("1. Duck typing - no explicit interface:")

class DuckTypedDog:
    def speak(self):
        return "Woof!"

class DuckTypedCat:
    def speak(self):
        return "Meow!"

class DuckTypedRobot:
    def speak(self):
        return "Beep!"

def make_it_speak_duck(animal):
    """Works with anything that has speak() method."""
    print(f"   {animal.speak()}")

# Works with any object that has speak()
for obj in [DuckTypedDog(), DuckTypedCat(), DuckTypedRobot()]:
    make_it_speak_duck(obj)
print()

# 2. Abstract class approach
print("2. Abstract class - explicit interface:")

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

class ABCDog(Animal):
    def speak(self):
        return "Woof!"

class ABCCat(Animal):
    def speak(self):
        return "Meow!"

# Robot doesn't inherit from Animal
class ABCRobot:
    def speak(self):
        return "Beep!"

def make_it_speak_abc(animal: Animal):
    """Type hint shows expected interface."""
    print(f"   {animal.speak()}")

for obj in [ABCDog(), ABCCat()]:
    make_it_speak_abc(obj)
# ABCRobot works too (Python doesn't enforce type hints)
# but it's clear it doesn't follow the Animal contract
print()

# 3. When to use each approach
print("3. When to use Abstract Classes:")
print("""
   USE ABC when:
   - Defining a formal API/contract
   - Working in a team that needs clear interfaces
   - Building a framework or library
   - Want compile-time-like errors for missing methods
   - Need abstract properties, not just methods
   - Using type checkers like mypy

Example: Plugin systems, database drivers, payment processors
""")

print("4. When to use Duck Typing:")
print("""
   USE Duck Typing when:
   - Simple, informal interfaces
   - Working with built-in types (file-like, iterable)
   - Maximum flexibility needed
   - Following Python's "we're all consenting adults" philosophy
   - Objects from different libraries/sources

Example: Anything with read(), anything with __iter__()
""")

# 4. Hybrid approach
print("5. Hybrid: Protocol (Python 3.8+):")
print("""
   from typing import Protocol

class Speakable(Protocol):
       def speak(self) -> str: ...

# Now you get:
   # - Type checking benefits
   # - No need to inherit from Protocol
   # - Best of both worlds!
""")

# 5. Practical comparison
print("6. Practical example:")

class FileWriter(ABC):
    """ABC for formal file writing interface."""

@abstractmethod
    def write(self, data: str) -> None:
        pass

@abstractmethod
    def close(self) -> None:
        pass

class CSVWriter(FileWriter):
    def __init__(self, filename):
        self.filename = filename
        self.buffer = []

def write(self, data):
        self.buffer.append(data)
        print(f"   CSVWriter: wrote '{data}'")

def close(self):
        print(f"   CSVWriter: saved {len(self.buffer)} rows to {self.filename}")

# Duck-typed version - no ABC needed
class SimpleLogger:
    """Follows same interface but doesn't inherit ABC."""
    def write(self, data):
        print(f"   SimpleLogger: {data}")

def close(self):
        print("   SimpleLogger: closed")

def save_data(writer, data):
    """Works with any writer - ABC or duck-typed."""
    for item in data:
        writer.write(item)
    writer.close()

print("   Using ABC-based writer:")
save_data(CSVWriter("output.csv"), ["row1", "row2"])
print()
print("   Using duck-typed writer:")
save_data(SimpleLogger(), ["log1", "log2"])

Output

Click Run to execute your code

typing.Protocol (Python 3.8+)

For the best of both worlds, consider Protocol from the typing module. It provides structural subtyping (duck typing) with type checker support - no inheritance required, but still documents the expected interface.

Common Mistakes

1. Forgetting to inherit from ABC

# Wrong - @abstractmethod does nothing without ABC!
class Shape:
    @abstractmethod
    def area(self):
        pass

s = Shape()  # Works! No enforcement

# Correct - must inherit from ABC
from abc import ABC, abstractmethod

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

s = Shape()  # TypeError! Can't instantiate

2. Wrong decorator order for abstract properties

# Wrong order!
class Vehicle(ABC):
    @abstractmethod
    @property
    def speed(self):  # This won't work correctly
        pass

# Correct - @property first, then @abstractmethod
class Vehicle(ABC):
    @property
    @abstractmethod
    def speed(self):
        pass

3. Not implementing all abstract methods

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

    @abstractmethod
    def move(self): pass

# Incomplete - missing move()
class Dog(Animal):
    def speak(self):
        return "Woof"

d = Dog()  # TypeError: Can't instantiate - move() not implemented

# Complete - both methods implemented
class Dog(Animal):
    def speak(self):
        return "Woof"

    def move(self):
        return "Run"

4. Calling super() on abstract methods that raise NotImplementedError

# Problem - abstract method raises error
class Base(ABC):
    @abstractmethod
    def process(self):
        raise NotImplementedError

class Child(Base):
    def process(self):
        super().process()  # This raises NotImplementedError!
        return "processed"

# Better - abstract method with pass or documentation
class Base(ABC):
    @abstractmethod
    def process(self):
        """Process the data. Override in subclass."""
        pass  # or just docstring

5. Using ABC when duck typing would suffice

# Over-engineered - simple interface doesn't need ABC
class Printable(ABC):
    @abstractmethod
    def to_string(self): pass

# Pythonic - just document the expected interface
def print_item(item):
    """Print item. Item must have to_string() method."""
    print(item.to_string())

# ABC is best for complex interfaces, frameworks, or team codebases

Exercise: Notification System

Task: Create an abstract notification system with multiple notification types.

Requirements:

Abstract Notifier class with abstract send() and name property
Concrete notify() method that prints "[name] Sending..." then calls send()
EmailNotifier, SMSNotifier, PushNotifier implementations
notify_all() function to send to multiple notifiers

Output

Click Run to execute your code

Show Solution

from abc import ABC, abstractmethod

class Notifier(ABC):
    @property
    @abstractmethod
    def name(self):
        pass

    @abstractmethod
    def send(self, message):
        pass

    def notify(self, message):
        print(f"[{self.name}] Sending...")
        result = self.send(message)
        print(result)


class EmailNotifier(Notifier):
    def __init__(self, email_address):
        self.email_address = email_address

    @property
    def name(self):
        return "Email"

    def send(self, message):
        return f"Email sent to {self.email_address}: {message}"


class SMSNotifier(Notifier):
    def __init__(self, phone_number):
        self.phone_number = phone_number

    @property
    def name(self):
        return "SMS"

    def send(self, message):
        return f"SMS sent to {self.phone_number}: {message}"


class PushNotifier(Notifier):
    def __init__(self, device_id):
        self.device_id = device_id

    @property
    def name(self):
        return "Push"

    def send(self, message):
        return f"Push notification to device {self.device_id}: {message}"


def notify_all(notifiers, message):
    for notifier in notifiers:
        notifier.notify(message)


# Test
notifiers = [
    EmailNotifier("[email protected]"),
    SMSNotifier("+1234567890"),
    PushNotifier("device-abc-123")
]
notify_all(notifiers, "Your order has shipped!")

Summary

from abc import ABC, abstractmethod to use abstract classes
Inherit from ABC to make a class abstract
@abstractmethod marks methods that must be overridden
Can't instantiate abstract classes or classes with unimplemented abstract methods
Abstract classes can have concrete methods (template method pattern)
Use @property before @abstractmethod for abstract properties
Consider typing.Protocol for structural (duck) typing with type hints

What's Next?

Now that you understand abstract classes, learn about Dataclasses - Python's @dataclass decorator that automatically generates __init__, __repr__, __eq__, and more for data-holding classes.

Previous Properties

Next Dataclasses

What Are Abstract Classes?

Abstract Class Basics

Concrete Methods in Abstract Classes

Abstract Properties

Decorator Order Matters

Practical Examples

Template Method Pattern

Abstract Classes vs Duck Typing

typing.Protocol (Python 3.8+)

Common Mistakes

1. Forgetting to inherit from ABC

2. Wrong decorator order for abstract properties

3. Not implementing all abstract methods

4. Calling super() on abstract methods that raise NotImplementedError

5. Using ABC when duck typing would suffice

Exercise: Notification System

Summary

What's Next?

Enjoying these tutorials?