ABC Deep Dive - Abstract Base Classes

Introduction

The abc (Abstract Base Class) module provides infrastructure for defining abstract base classes. Abstract classes define methods that subclasses must implement.

Basic Abstract Class

from abc import ABC, abstractmethod

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

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius
    
    def area(self):
        return 3.14 * self.radius ** 2
    
    def perimeter(self):
        return 2 * 3.14 * self.radius

Abstract Property

from abc import ABC, abstractproperty

class Animal(ABC):
    @abstractproperty
    def species(self):
        pass
    
    @property
    def alive(self):
        return True

class Dog(Animal):
    @property
    def species(self):
        return "Canis familiaris"

Register Implementation

from abc import ABC

class Printable(ABC):
    @abstractmethod
    def print(self):
        pass

class StringHandler:
    def print(self):
        print("Printing string")

# Register without inheritance
Printable.register(StringHandler)

handler = StringHandler()
isinstance(handler, Printable)  # True

Multiple Inheritance

from abc import ABC, abstractmethod

class Reader(ABC):
    @abstractmethod
    def read(self):
        pass

class Writer(ABC):
    @abstractmethod
    def write(self):
        pass

class FileHandler(Reader, Writer):
    def read(self):
        pass
    
    def write(self):
        pass

Abstract Methods with Implementation

from abc import ABC, abstractmethod

class BaseParser(ABC):
    @abstractmethod
    def parse(self, data):
        pass
    
    def validate(self, data):
        return True

class JSONParser(BaseParser):
    def parse(self, data):
        return json.loads(data)

Practice Problems

1. Create an abstract base class for different file formats
2. Implement abstract property
3. Use register() for existing classes
4. Create abstract class with non-abstract methods
5. Build abstract factory pattern