Clases y métodos abstractos

Las clases abstractas son clases que no se pueden instanciar directamente y contienen métodos abstractos que deben implementar las subclases.

Piensa en ello como si fuera un formulario: Una clase abstracta es como un formulario obligatorio en el que algunos campos son obligatorios (métodos abstractos) y otros son opcionales (métodos concretos). No puedes enviar el formulario en sí; primero debes rellenar todos los campos obligatorios. Del mismo modo, no puedes crear instancias de una clase abstracta hasta que todos los métodos abstractos estén implementados en una subclase.

Importa el módulo abc para crear clases abstractas:

from abc import ABC, abstractmethod

Crea una clase abstracta con métodos abstractos:

class Shape(ABC):
    @abstractmethod
    def area(self):
        pass
    
    @abstractmethod
    def perimeter(self):
        pass
    
    def describe(self):
        return "This is a shape"  # Método concreto (tiene implementación)

El decorador @abstractmethod marca los métodos que las subclases deben implementar: estos son los «campos obligatorios» de tu formulario. Los métodos normales como describe() pueden tener implementaciones y se heredan tal cual: estos son los «campos rellenados previamente».

¿Por qué usar clases abstractas? Imponen un contrato. Si creas una clase Shape, estás diciendo: «toda forma DEBE poder calcular su área y su perímetro». Esto evita errores en los que podrías olvidar implementar métodos esenciales.

Intenta crear una instancia de la clase abstracta:

# Esto provocará un error:
# shape = Shape()  # TypeError: Can't instantiate abstract class

Este error es intencional: es como intentar enviar un formulario vacío. Python te está diciendo: «¡Todavía no has rellenado los campos obligatorios (los métodos area y perimeter)!»

Crea una subclase concreta que implemente todos los métodos abstractos:

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

Ahora hemos «completado todos los campos obligatorios»: hemos implementado tanto area() como perimeter(). La clase Circle ahora es una clase concreta completa que se puede instanciar.

Ahora puedes crear instancias de la clase concreta:

circle = Circle(5)
print(circle.area())
print(circle.perimeter())
print(circle.describe())  # Método concreto heredado

Crea otra subclase concreta:

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height
    
    def area(self):
        return self.width  self.height
    
    def perimeter(self):
        return 2 * (self.width + self.height)

rectangle = Rectangle(4, 6)
print(rectangle.area())
print(rectangle.perimeter())

Salida:

78.5
31.400000000000002
This is a shape
24
20

Las clases abstractas definen un contrato que las subclases deben cumplir. Usa ABC y @abstractmethod para crear clases abstractas. Las subclases deben implementar todos los métodos abstractos o también serán abstractas. Esto garantiza la coherencia y evita implementaciones incompletas.