Aprende Why Abstract Base Classes Exist

Desliza para mostrar el menú

Python is a duck-typed language – if an object has the right methods, it works, regardless of its type. This is powerful but creates a problem: how do you enforce a contract? How do you guarantee that every class in a hierarchy implements the methods it is supposed to? Abstract Base Classes (ABCs) are Python's answer.

The Problem with Duck Typing Alone

Without ABCs, nothing prevents a developer from creating an incomplete subclass that is missing required methods. The error only appears at runtime, deep inside execution:


              12345678910111213141516
            
# Missing method discovered only at runtime – too late
class DataExporter:
    def export(self, data):
        raise NotImplementedError("Subclasses must implement export()")

class CsvExporter(DataExporter):
    def export(self, data):
        return ",".join(str(item) for item in data)

class JsonExporter(DataExporter):
    pass  # Forgot to implement export()

exporters = [CsvExporter(), JsonExporter()]

for exporter in exporters:
    print(exporter.export([1, 2, 3]))  # Crashes on JsonExporter

The crash happens at the call site, not when JsonExporter is defined. In a large codebase, this can be buried inside a rarely-executed code path.

What ABCs Provide

ABCs shift the error from runtime to class definition time. If a subclass of an ABC does not implement all abstract methods, instantiating it raises TypeError immediately:


              1234567891011121314151617
            
from abc import ABC, abstractmethod

# Abstract base class with a required interface
class DataExporter(ABC):
    @abstractmethod
    def export(self, data):
        pass

class CsvExporter(DataExporter):
    def export(self, data):
        return ",".join(str(item) for item in data)

class JsonExporter(DataExporter):
    pass  # Missing export()

csv_exporter = CsvExporter()          # Works fine
json_exporter = JsonExporter()        # TypeError immediately

JsonExporter cannot be instantiated until export() is implemented. The error is clear, immediate, and points directly at the problem.

ABCs as Formal Interfaces

ABCs serve as formal contracts between the base class author and subclass implementors. They communicate: "any class that inherits from me must implement these methods." This is especially valuable in:

Plugin systems where third-party code provides implementations;
Large teams where different developers implement different parts of a hierarchy;
Library design where you want to guarantee that user-provided classes behave correctly.

ABCs in the Standard Library

Python's standard library uses ABCs extensively. The collections.abc module defines ABCs for container types – Iterable, Mapping, Sequence, MutableMapping, and many more:


              123456
            
from collections.abc import Iterable, Mapping

# Checking whether objects satisfy an ABC interface
print(isinstance([1, 2, 3], Iterable))       # True
print(isinstance({"key": "value"}, Mapping)) # True
print(isinstance(42, Iterable))              # False

These ABCs are not just for type checking – they also provide mixin methods. A class that implements __iter__ and __next__ automatically gets __contains__, __reversed__, and other methods for free when it inherits from the right ABC.

¿Todo estuvo claro?

¡Gracias por tus comentarios!

Sección 1. Capítulo 1

Pregunte a AI

Pregunte lo que quiera o pruebe una de las preguntas sugeridas para comenzar nuestra charla

Sección 1. Capítulo 1