Classes Abstratas em Python

Este artigo explica as classes abstratas em Python.

Explicaremos o mecanismo básico das classes abstratas usando o módulo abc, forneceremos exemplos práticos e descreveremos tudo com código ilustrativo.

YouTube Video

Classes Abstratas em Python

O módulo abc do Python (Abstract Base Classes) faz parte da biblioteca padrão e é usado para definir classes abstratas, fornecendo um modelo para os métodos que uma classe deve implementar. Usar este módulo aumenta a flexibilidade e a robustez no design de classes.

O que é uma Classe Abstrata?

Classes abstratas são usadas para definir uma interface comum para classes concretas (instanciáveis). Classes abstratas não podem ser instanciadas diretamente; uma implementação concreta deve ser fornecida nas classes derivadas (subclasses).

O módulo abc permite que você defina métodos ou propriedades abstratos e exija sua implementação nas classes herdeiras. Se pelo menos um método abstrato não for implementado, a classe não poderá ser instanciada.

Como Usar o Módulo abc

Para criar uma classe abstrata usando o módulo abc, herde da classe ABC e defina métodos abstratos usando o decorador @abstractmethod.

 1from abc import ABC, abstractmethod
 2
 3# Definition of the abstract base class
 4class Animal(ABC):
 5
 6    @abstractmethod
 7    def sound(self):
 8        pass
 9
10# Concrete implementation in the subclass
11class Dog(Animal):
12    def sound(self):
13        return "Woof!"
14
15class Cat(Animal):
16    def sound(self):
17        return "Meow!"

Aqui, a classe Animal é definida como uma classe abstrata e inclui um método abstrato chamado sound. Este método deve ser implementado concretamente nas subclasses. Dog e Cat herdam de Animal e cada um implementa o método sound.

Instanciando Classes Abstratas

Classes abstratas não podem ser instanciadas diretamente. Por exemplo, tentar instanciar diretamente a classe Animal resultará em um erro.

1animal = Animal()  # TypeError: Can't instantiate abstract class Animal with abstract methods sound

• Ao tentar instanciar uma classe abstrata, o Python determina que há métodos abstratos não implementados e gera um TypeError. Se todos os métodos abstratos necessários forem implementados na subclasse, a instância se torna possível.

Múltiplos Métodos Abstratos

Também é possível que uma classe tenha vários métodos abstratos. A menos que todos os métodos abstratos sejam implementados em uma subclasse, a classe permanecerá uma classe abstrata.

 1from abc import ABC, abstractmethod
 2
 3class Vehicle(ABC):
 4
 5    @abstractmethod
 6    def start_engine(self):
 7        pass
 8
 9    @abstractmethod
10    def stop_engine(self):
11        pass
12
13class Car(Vehicle):
14    def start_engine(self):
15        return "Car engine started"
16
17    def stop_engine(self):
18        return "Car engine stopped"

Neste exemplo, a classe Vehicle possui dois métodos abstratos, e a classe Car só pode ser instanciada após implementar ambos os métodos.

Definindo Propriedades Abstratas

O módulo abc suporta não apenas métodos abstratos, mas também propriedades abstratas. Isso permite impor a implementação de propriedades nas classes derivadas.

 1from abc import ABC, abstractmethod
 2
 3class Shape(ABC):
 4
 5    @property
 6    @abstractmethod
 7    def area(self):
 8        pass
 9
10class Circle(Shape):
11    def __init__(self, radius):
12        self.radius = radius
13
14    @property
15    def area(self):
16        return 3.14159 * (self.radius ** 2)

• Neste exemplo, a classe Shape possui uma propriedade abstrata area, e a subclasse Circle concretiza essa propriedade. Dessa forma, usar classes abstratas para impor a implementação de propriedades ajuda a manter a consistência do código.

Usando isinstance() e issubclass()

Ao utilizar classes abstratas, você pode confirmar relações de herança de classes com isinstance() ou issubclass(), melhorando a segurança e a flexibilidade do código.

 1from abc import ABC, abstractmethod
 2
 3# Definition of the abstract base class
 4class Animal(ABC):
 5
 6    @abstractmethod
 7    def sound(self):
 8        pass
 9
10# Concrete implementation in the subclass
11class Dog(Animal):
12    def sound(self):
13        return "Woof!"
14
15class Cat(Animal):
16    def sound(self):
17        return "Meow!"
18
19class Vehicle(ABC):
20
21    @abstractmethod
22    def start_engine(self):
23        pass
24
25    @abstractmethod
26    def stop_engine(self):
27        pass
28
29class Car(Vehicle):
30    def start_engine(self):
31        return "Car engine started"
32
33    def stop_engine(self):
34        return "Car engine stopped"
35
36print("Dog() is an Animal? -> ", isinstance(Dog(), Animal))   # True
37print("Dog is subclass of Animal? -> ", issubclass(Dog, Animal))  # True
38print("Cat() is a Vehicle? -> ", isinstance(Cat(), Vehicle))  # False

isinstance() é usado para verificar se um objeto é uma instância de uma classe específica, e issubclass() é usado para verificar se uma classe é uma subclasse de uma classe específica.

Resumo

Ao criar classes abstratas usando o módulo abc, você pode esclarecer a interface entre as classes e impor a implementação de métodos e propriedades obrigatórios. Isso ajuda a manter a consistência do código e reduz os erros, sendo particularmente útil para projetos de grande escala.

As classes abstratas são uma ferramenta importante no Python que suportam programação orientada a objetos flexível, aumentando a reutilização e a mantenibilidade das classes.

Você pode acompanhar o artigo acima usando o Visual Studio Code em nosso canal do YouTube. Por favor, confira também o canal do YouTube.

YouTube Video