Classes abstratas do Python: Um guia abrangente com exemplos

Um componente fundamental do desenvolvimento moderno de software é a programação orientada a objetos (OOP), que oferece aos programadores a capacidade de organizar o código de forma escalonável, modular e reutilizável. As classes abstratas são um dos vários conceitos de OOP essenciais para criar um modelo que outras classes possam usar. Esta postagem explicará as classes abstratas, seus benefícios e como você pode usar o módulo abc do Python para criá-las com sucesso.

Você é novo no Python? Saiba como trabalhar com módulos e pacotes, trabalhar com tipos de dados incorporados e escrever funções personalizadas.

O que é uma classe abstrata?

Outras classes usam uma classe abstrata como modelo. Embora não forneça sua implementação, ele especifica os métodos que suas subclasses devem usar. Isso permite que os programadores garantam que todas as subclasses sigam um contrato específico, impondo uma interface uniforme em várias implementações.

Por exemplo, uma classe abstrata como Shape poderia definir métodos como area e perimeter. A implementação dessas funções seria então fornecida para cada forma distinta, como um círculo ou retângulo.

Você quer levar suas habilidades de OOP para o próximo nível? Inscreva-se em nosso curso Programação orientada a objetos intermediária em Python. 

Por que usar classes abstratas em Python?

As classes abstratas são úteis quando você deseja:

• Impor a implementação do método: Os métodos de uma classe abstrata funcionam como um contrato, exigindo que cada subclasse forneça sua própria implementação. Isso reduz a possibilidade de implementações inconsistentes ou inexistentes, garantindo que a funcionalidade específica esteja presente em todas as classes derivadas.
• Incentivar a reutilização do código: as classes abstratas podem ter métodos concretos e abstratos. Os métodos concretos reduzem muito a duplicação de código e incentivam os princípios DRY (Do not Repeat Yourself, não se repita), fornecendo funcionalidade compartilhada que pode ser herdada por todas as subclasses.
• Melhore a legibilidade e a capacidade de manutenção: As classes abstratas ajudam os desenvolvedores a compreender melhor a estrutura e a funcionalidade do software, fornecendo uma estrutura consistente e transparente. Essa estrutura facilita a manutenção do código ao impor princípios de design como responsabilidade única e separação de responsabilidades.
• Incentivar o polimorfismo: As classes abstratas possibilitam que você escreva um código geral que funcione bem com uma variedade de subclasses. Os desenvolvedores podem criar funções ou métodos que podem lidar com qualquer subclasse da classe abstrata graças a essa flexibilidade, o que aumenta a extensibilidade e a adaptabilidade do código a mudanças no futuro.

Você pode garantir que qualquer subclasse, como Dog ou Cat, implemente sua implementação do método speak, por exemplo, se você tiver uma classe abstrata Animal com um método abstrato speak. Como resultado dessa uniformidade, seu código se torna confiável e previsível.

Torne-se um desenvolvedor profissional de Python fazendo nosso curso Python Developer hoje mesmo. 

O módulo abc em Python

O módulo abc do Python oferece um forte suporte interno para classes abstratas. O módulo, que significa "Abstract Base Classes" (Classes básicas abstratas), fornece 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 você a manter a uniformidade e a conformidade com uma interface predeterminada. 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 básicas abstratas, o módulo também incentiva padrões de design aprimorados. 

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

Criando uma classe abstrata Python

Dois componentes essenciais são introduzidos 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ê deve herdar da ABC para definir uma classe abstrata. A classe é abstrata e não pode ser instanciada diretamente, conforme indicado por essa herança. Ao atuarem como modelos, as classes abstratas garantem que qualquer subclasse concreta obedeça a um conjunto de regras.

Você pode definir métodos abstratos dentro de uma classe abstrata usando o decorador abstractmethod. Qualquer subclasse concreta deve implementar e substituir métodos abstratos, que são espaços reservados. Isso torna 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 e, ao mesmo tempo, dar flexibilidade às subclasses na forma como elas atendem a esses requisitos é o decorador abstractmethod.

Aqui está 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ê estiver procurando por projetos Python mais práticos, confira nossa lista dos 60 principais projetos Python para desenvolvedores de todos os níveis. 

Como o módulo abc impõe a implementação do método

Qualquer subclasse de uma classe abstrata tem a garantia de implementar os métodos decorados graças ao decorador abstractmethod. Como precaução, ele impede a criação de subclasses que não tenham os recursos necessários. 

O Python informa um TypeError quando você tenta instanciar uma subclasse se ela não substituir todos os métodos abstratos. Essa aplicação rigorosa reduz a probabilidade de defeitos e melhora a estabilidade do código, ajudando os desenvolvedores a identificar antecipadamente as falhas de implementação. 

Ele também garante que todas as subclasses concretas sigam o comportamento e o design pretendidos da 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, a definição de uma classe abstrata implica o uso do decorador abstractmethod e a subclasse de ABC. Ao fazer isso, os programadores podem estabelecer as bases para outras classes, definindo os métodos que precisam ser usados. 

Aqui você encontra um procedimento completo e passo a passo:

• Traga os módulos necessários: A importação de ABC e abstractmethod do móduloABC deve ser feita primeiro. Para definir classes e métodos abstratos, essas ferramentas são necessárias.
• Construa 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, conforme indicado por essa herança.
• Defina métodos abstratos usando @abstractmethod: Para especificar quais métodos as subclasses devem substituir, use o decorador @abstractmethod. Em essência, esses métodos servem como espaços reservados, garantindo que todas as classes derivadas executem as operações necessárias.

Exemplo passo a passo da definição de uma classe abstrata

Aqui está um exemplo prático para você demonstrar:

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 em uma 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 ilustra como as classes abstratas permitem flexibilidade de implementação e, ao mesmo tempo, impõem uma interface consistente.

Exemplo de classe base abstrata em Python

Agora que já vimos como as classes básicas abstratas definem um contrato para as subclasses, vamos explorar como as classes concretas atendem a esses requisitos implementando todos os métodos abstratos.

Classe concreta herdando de uma classe abstrata

Uma subclasse que implementa todos os métodos abstratos de uma classe abstrata é chamada de classe concreta. Isso indica que a classe concreta fornece 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

Criação de instâncias e aplicação de regras

O Python impede que você instancie imediatamente uma classe abstrata. Como ele garante que qualquer subclasse gerada a partir da classe abstrata aderirá ao contrato necessário fornecido por seus métodos abstratos, esse é um aspecto essencial das classes abstratas. 

Por exemplo, um TypeError será gerado se você tentar instanciar appliance = Appliance()

Essa limitação garante que as classes abstratas funcionem apenas como projetos e estejam livres de abusos. O Python permite a criação de instâncias de WashingMachine e, ao mesmo tempo, mantém o contrato especificado em Appliance implementando todos os métodos abstratos em WashingMachine. Ao garantir que cada recurso especificado na classe abstrata seja completamente implementado 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 oferece suporte a propriedades abstratas usando os decoradores @property’ and @abstractmethod', permitindo que os desenvolvedores apliquem a consistência dos atributos juntamente 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 as propriedades que as subclasses devem declarar, além dos métodos. 

Para garantir que cada subclasse forneça sua implementação, as propriedades abstratas podem ser especificadas usando o decorador @property em combinação com @abstractmethod. Ao criar classes que precisam de atributos somente leitura ou computados que são essenciais para a operação da classe, esse método é especialmente útil.

Exemplo: classe abstrata com propriedades

Aqui está 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 as classes abstratas do Python

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

• Ao projetar estruturas ou bibliotecas em que um determinado comportamento precisa ser imposto: Em sistemas complicados, as classes abstratas podem estabelecer um conjunto unificado de diretrizes ou interfaces às quais todas as subclasses devem aderir, garantindo a consistência e reduzindo os erros.
• Implementação de APIs consistentes em todas as 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 a biblioteca, definindo métodos abstratos.
• Fornecimento de 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 compartilhados na classe abstrata, essa estrutura incentiva a reutilização e minimiza a duplicação.

Práticas recomendadas

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

Se cada método puder ter uma implementação padrão, não use classes abstratas. Em determinadas situações, uma classe base concreta pode ser uma opção melhor para reduzir a complexidade e, ao mesmo tempo, preservar a capacidade de reutilizar a funcionalidade compartilhada.

Certifique-se de que as classes abstratas sejam claras e simples, definindo apenas os atributos e métodos mais importantes. Pode ser um desafio construir 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 de fácil manutenção. Você pode promover clareza, reutilização e extensibilidade em seus aplicativos definindo classes abstratas e impondo 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 no qual você está trabalhando.

Se você estiver projetando programas robustos orientados a objetos, impondo interfaces consistentes ou criando aplicativos escalonáveis, o domínio das classes abstratas do Python aumenta sua capacidade de escrever códigos eficientes e de fácil manutenção. Aumente seu conhecimento de Python hoje mesmo com nosso abrangente trilha de habilidades Python Fundamentals.