Classes abstratas em Python: Um guia completo com exemplos

O módulo abc em Python

O módulo abc em Python oferece um suporte integrado robusto para classes abstratas. O módulo, que significa “Abstract Base Classes” (Classes Base Abstratas), dá aos programadores as ferramentas necessárias para criar classes abstratas, incluindo o decorador abstractmethod e a classe `ABC`. 

Ao definir métodos abstratos e exigir sua implementação em subclasses, essas ferramentas ajudam a manter a uniformidade e a conformidade com uma interface pré-determinada. Ao exigir a implementação de métodos essenciais em todas as classes derivadas e permitir a implementação parcial de funcionalidades comuns em classes base abstratas, o módulo também incentiva a melhoria dos padrões de design. 

Por isso, o módulo ABC é um componente essencial para organizar aplicativos Python escaláveis, robustos e estáveis.

Criando uma classe abstrata em Python

Dois componentes essenciais são apresentados no módulo ABC:

Classe Base Abstrata, ou ABC

A classe ABC é um recurso integrado do Python que serve como base fundamental para o desenvolvimento de classes abstratas. Você precisa herdar de ABC para definir uma classe abstrata. A classe é abstrata e não pode ser instanciada diretamente, como mostra essa herança. Ao servir como modelos, as classes abstratas garantem que qualquer subclasse concreta siga um conjunto de regras.

Você pode definir métodos abstratos dentro de uma classe abstrata usando o decorador abstractmethod. Qualquer subclasse concreta precisa implementar e substituir métodos abstratos, que são espaços reservados. Isso deixa o código consistente e previsível, garantindo que todas as classes derivadas ofereçam funcionalidade para os métodos designados. Uma ferramenta útil para exigir a implementação de métodos, ao mesmo tempo que dá flexibilidade às subclasses na forma como elas atendem a esses requisitos, é o decorador abstractmethod.

Aqui vai um exemplo básico:

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

    @abstractmethod
    def perimeter(self):
        pass

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14159 * self.radius ** 2

    def perimeter(self):
        return 2 * 3.14159 * self.radius

# Uncommenting the following line will raise an error because we’re missing method implementations
# shape = Shape() # TypeError: Can't instantiate abstract class Shape with abstract methods #area, perimeter

circle = Circle(5)
print(f"Area: {circle.area()}")
print(f"Perimeter: {circle.perimeter()}")

# Area: 78.53975
# Perimeter: 31.4159

Se você está procurando projetos Python mais práticos, dê uma olhada na nossa lista dos 60 melhores projetos Python para desenvolvedores de todos os níveis. 

Como o módulo abc faz a implementação do método

Qualquer subclasse de uma classe abstrata vai implementar os métodos decorados, graças ao decorador abstractmethod. Como precaução, impede que sejam criadas subclasses que não tenham as capacidades necessárias. 

O Python mostra um erro de TypeError quando tenta instanciar uma subclasse que não substitui todos os métodos abstratos. Essa aplicação rigorosa diminui a chance de erros e melhora a estabilidade do código, ajudando os desenvolvedores a identificar falhas de implementação logo no começo. 

Isso também garante que todas as subclasses concretas sigam o comportamento e o design pretendidos pela classe abstrata.

Por exemplo:

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height

    # Missing area and perimeter implementation

# This will raise an error
rectangle = Rectangle(5, 10)

# TypeError: Can't instantiate abstract class Rectangle with abstract methods area, perimeter

Métodos de classe abstrata em Python

Em Python, definir uma classe abstrata envolve usar o decorador abstractmethod e criar uma subclasse a partir de ABC. Ao fazer isso, os programadores podem preparar o terreno para outras classes, definindo os métodos que precisam ser usados. 

Aqui está um procedimento detalhado, passo a passo:

• Inclua os módulos necessários: Importar ABC e abstractmethod do móduloABC deve vir primeiro. Para definir classes e métodos abstratos, essas ferramentas são necessárias.
• Crie uma classe com base em ABC: Crie uma nova classe e defina ABC como seu herdeiro. A classe é abstrata e não pode ser instanciada diretamente, como mostra essa herança.
• Defina métodos abstratos usando @abstractmethod: Para especificar quais métodos as subclasses devem substituir, use o decorador ` @abstractmethod `. Basicamente, esses métodos são como espaços reservados, garantindo que todas as classes derivadas façam as operações necessárias.

Exemplo passo a passo de como definir uma classe abstrata

Aqui vai um exemplo prático pra mostrar como funciona:

from abc import ABC, abstractmethod

class Vehicle(ABC):
    @abstractmethod
    def start_engine(self):
        pass

    @abstractmethod
    def stop_engine(self):
        pass

class Car(Vehicle):
    def start_engine(self):
        print("Car engine started")

    def stop_engine(self):
        print("Car engine stopped")

# Instantiating the abstract class directly will raise an error
# vehicle = Vehicle()

car = Car()
car.start_engine()
car.stop_engine()

# Car engine started
# Car engine stopped

Isso garante que as funções start_engine e stop_engine sejam implementadas por qualquer subclasse de `Vehicle`.

Exemplo prático: implementação de classe abstrata

Dá uma olhada numa ilustração mais detalhada usando uma classe Vehicle:

from abc import ABC, abstractmethod

class Vehicle(ABC):
    def __init__(self, brand):
        self.brand = brand

    @abstractmethod
    def start_engine(self):
        pass

    @abstractmethod
    def stop_engine(self):
        pass

class Motorcycle(Vehicle):
    def start_engine(self):
        print(f"{self.brand} motorcycle engine started")

    def stop_engine(self):
        print(f"{self.brand} motorcycle engine stopped")

motorcycle = Motorcycle("Yamaha")
motorcycle.start_engine()
motorcycle.stop_engine()
# Yamaha motorcycle engine started
# Yamaha motorcycle engine stopped

Isso mostra como as classes abstratas dão flexibilidade de implementação e, ao mesmo tempo, garantem uma interface consistente.

Exemplo de classe base abstrata em Python

Agora que vimos como as classes base abstratas definem um contrato para as subclasses, vamos ver como as classes concretas cumprem esses requisitos implementando todos os métodos abstratos.

Classe concreta herdada de uma classe abstrata

Uma subclasse que implementa todos os métodos abstratos de uma classe abstrata é chamada de classe concreta. Isso mostra que a classe concreta oferece implementações específicas para todos os métodos necessários, cumprindo assim o contrato estabelecido pela classe abstrata. 

Por exemplo:

from abc import ABC, abstractmethod

class Appliance(ABC):
    @abstractmethod
    def turn_on(self):
        pass

    @abstractmethod
    def turn_off(self):
        pass

class WashingMachine(Appliance):
    def turn_on(self):
        print("Washing machine is now ON")

    def turn_off(self):
        print("Washing machine is now OFF")

machine = WashingMachine()
machine.turn_on()
machine.turn_off()

# Washing machine is now ON
# Washing machine is now OFF

Criando instâncias e aplicando regras

Python não deixa você instanciar uma classe abstrata na hora. Isso é super importante nas classes abstratas, porque garante que qualquer subclasse gerada a partir da classe abstrata vai seguir o contrato necessário fornecido pelos seus métodos abstratos. 

Por exemplo, uma exceção TypeError vai ser lançada se você tentar instanciar appliance = Appliance()

Essa limitação garante que as classes abstratas funcionem apenas como modelos e não sejam usadas de forma errada. Python permite a criação de instâncias de WashingMachine, mantendo o contrato especificado em Appliance, implementando todos os métodos abstratos em WashingMachine. Garantindo que todos os recursos especificados na classe abstrata sejam totalmente implementados em suas subclasses concretas, essa aplicação melhora a integridade da base de código.

Propriedades abstratas e inicialização

Com essa base, vamos nos aprofundar em como o Python suporta propriedades abstratas usando os decoradores @property e @abstractmethod, permitindo que os desenvolvedores garantam a consistência dos atributos junto com os métodos.

Usando propriedades abstratas em Python

As classes abstratas podem especificar propriedades que as subclasses devem implementar, além dos métodos. Esse recurso permite que os desenvolvedores imponham uma interface uniforme para propriedades que as subclasses devem declarar além dos métodos. 

Pra garantir que cada subclasse tenha sua implementação, dá pra especificar propriedades abstratas usando o decorador @property junto com @abstractmethod. Quando você está criando classes que precisam de atributos somente leitura ou calculados que são essenciais para o funcionamento da classe, esse método é super útil.

Exemplo: classe abstrata com propriedades

Aqui vai um exemplo:

from abc import ABC, abstractmethod

class Animal(ABC):
    @property
    @abstractmethod
    def sound(self):
        pass

class Bird(Animal):
    @property
    def sound(self):
        return "Chirp"

bird = Bird()
print(bird.sound)

# Chirp

A condição da classe abstrata Animal é atendida pelo recurso sound da classe Bird.

Quando usar classes abstratas em Python

As classes abstratas são ideais para cenários como:

• Ao projetar estruturas ou bibliotecas onde um comportamento específico precisa ser aplicado: Em sistemas complicados, as classes abstratas podem criar um conjunto unificado de diretrizes ou interfaces que todas as subclasses precisam seguir, garantindo consistência e reduzindo erros.
• Implementando APIs consistentes entre classes: Os desenvolvedores podem garantir que todas as classes derivadas ofereçam um meio padronizado e previsível de comunicação com o aplicativo ou biblioteca, definindo métodos abstratos.
• Fornecendo uma estrutura básica para uma hierarquia de classes: Uma hierarquia de classes relacionadas pode ser criada usando classes abstratas como guia. Ao permitir a personalização em subclasses e permitir que os desenvolvedores declarem comportamentos e características compartilhadas na classe abstrata, essa estrutura incentiva a reutilização e minimiza a duplicação.

Melhores práticas

Quando precisar criar um contrato preciso para subclasses, use classes abstratas. As classes abstratas são úteis quando você precisa aplicar uma estrutura ou comportamento específico a várias classes derivadas. Elas ajudam a garantir que todas as subclasses sigam um padrão de design, o que melhora a previsibilidade do código e facilita a manutenção.

Se cada método pode ter uma implementação padrão, não use classes abstratas. Em certas situações, uma classe base concreta pode ser uma opção melhor para reduzir a complexidade, mantendo a capacidade de reutilizar funcionalidades compartilhadas.

Certifique-se de que as classes abstratas sejam claras e simples, definindo apenas os atributos e métodos mais importantes. Pode ser complicado criar e manter uma classe abstrata se ela tiver muitos critérios. Em vez disso, concentre-se nos aspectos essenciais que as classes derivadas devem ter.

Conclusão

O kit de ferramentas OOP do Python inclui classes abstratas, que são uma ferramenta poderosa que permite aos programadores criar programas confiáveis e fáceis de manter. Você pode deixar suas aplicações mais claras, reutilizáveis e extensíveis definindo classes abstratas e aplicando uma interface uniforme nas subclasses com a ajuda do módulo ABC. É possível escrever um código melhor e mais confiável implementando classes abstratas, independentemente do tamanho do sistema em que você está trabalhando.

Se você está criando programas orientados a objetos robustos, implementando interfaces consistentes ou criando aplicativos escaláveis, dominar as classes abstratas do Python melhora sua capacidade de escrever código eficiente e fácil de manter. Melhore seus conhecimentos em Python hoje mesmo com nosso curso completo programa de habilidades Fundamentos do Python.