Clases y métodos abstractos

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

Piénselo como un formulario: Una clase abstracta es como el código de un formulario obligatorio donde algunos campos son requeridos (métodos abstractos) y otros son opcionales (métodos concretos). No puede enviar el formulario en sí; primero debe completar todos los campos obligatorios. De manera similar, no puede crear instancias de una clase abstracta hasta que todos los métodos abstractos se implementen 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 deben ser implementados por las subclases; estos son los "campos obligatorios" de su formulario. Los métodos regulares como describe() pueden tener implementaciones y se heredan tal cual; estos son los "campos pre-completados".

¿Por qué usar clases abstractas? Obligan a cumplir un contrato. Si creas una clase Shape, estás diciendo "cada forma DEBE ser capaz de calcular su área y perímetro". Esto evita errores donde podrías olvidar implementar métodos críticos.

Intenta crear una instancia de la clase abstracta:

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

Este error es intencional; es como intentar enviar un formulario vacío. ¡Python está diciendo "Aún no has completado los campos obligatorios (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 requeridos": hemos implementado tanto area() como perimeter(). La clase Circle es ahora una clase concreta y completa que puede ser instanciada.

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 seguir. Utiliza 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 consistencia y evita implementaciones incompletas.