Clases abstractas — Python: Profundizando en las clases

• ¿Qué es una clase abstracta?
• Combinar varias abstracciones
• ¿Cuándo usar clases abstractas?
• ¿Qué pasa si no implementamos los métodos abstractos?
• Tabla de conceptos clave

Las clases abstractas son un concepto que facilita la organización de programas con clases e herencia. Imagina que estamos diseñando una aplicación web con varios tipos de elementos HTML, como botones o cuadros de texto. En lugar de repetir código para cada uno, creamos una clase base que sirva como plano general.

Pero, ¿cómo evitamos que alguien cree una instancia de esa clase base directamente, sin usar un elemento específico como un <button> o un <input>? Ahí es donde las clases abstractas juegan un papel crucial.

¿Qué es una clase abstracta?

En Python, usamos el módulo abc (Abstract Base Classes) para crear clases abstractas.

Miremos este ejemplo:

from abc import ABC, abstractmethod  # Importamos lo necesario para clases abstractas

# Definimos una clase base abstracta
class HTMLElement(ABC):
    def __init__(self, attributes={}):
        self.attributes = attributes

    @abstractmethod
    def get_attribute(self, key):
        pass  # Este método debe ser implementado por las clases hijas

Explicación:

• ABC significa "Abstract Base Class".
• Usamos el decorador @abstractmethod para indicar que este método get_attribute debe ser programado en los hijos.
• Tratamos de crear un HTMLElement directamente y... error. ¡No se puede!

Combinar varias abstracciones

¿Qué pasa si queremos que ciertos métodos específicos como str() (el que convierte objetos en texto) también sean obligatorios?

Podemos combinar varias clases abstractas. Acá un ejemplo:

from abc import ABC, abstractmethod

class Showable(ABC):
    @abstractmethod
    def __str__(self):
        pass  # Las clases que hereden esto deben definir __str__

Ahora podemos hacer que HTMLElement también herede de Showable:

class HTMLElement(Showable):
    def __init__(self, attributes={}):
        self.attributes = attributes

    def get_attribute(self, key):
        return self.attributes.get(key)

    def __str__(self):
        return f"HTMLElement con atributos: {self.attributes}"

Este HTMLElement completa todos los métodos requeridos, así que sí se puede usar para crear objetos. Si se omite str, Python lanzará un error cuando intentemos crear una instancia.

¿Cuándo usar clases abstractas?

No siempre las necesitamos. Pero hay situaciones donde son útiles, como:

• Cuando queremos definir una estructura común para varias clases.
• Cuando queremos asegurarnos de que todas las clases hijas sigan ciertas reglas (por ejemplo, que todas tengan el método str).
• Cuando estamos diseñando librerías o componentes reutilizables.

Un ejemplo práctico en el mundo real sería un sistema de archivo donde todos los documentos deben poder guardar e imprimir. Podríamos tener una clase abstracta Documento con métodos guardar() e imprimir() y luego clases hijas como PDF, Word, Excel, etc., cada una con su propia forma de hacer estas acciones.

¿Qué pasa si no implementamos los métodos abstractos?

Es importante saber que si una clase hija no implementa todos los métodos abstractos de su clase madre, no se puede crear una instancia de esa clase. Veamos un ejemplo de lo que NO está completo:

class Boton(HTMLElement):
    pass  # No implementa __str__, así que Python lanza un error al usar Boton()

Al ejecutar esto, obtendremos un error parecido a:

TypeError: Can't instantiate abstract class Boton with abstract method __str__

Tabla de conceptos clave