Outra forma, além do uso de interface, de aplicar a abstração utilizando a linguagem Python, é com auxílio de classe abstrata.

Interfaces não possuem implementação, em contrapartida classes concretas possuem implementação. Uma classe abstrata é a junção das características de interface e classe concreta permitindo, por exemplo, ter métodos implementados e também métodos abstratos a serem implementados.

Características

1. Possue implementação
2. Possue métodos concretos e abstratos
3. Não possue construtor
4. Não pode ser instanciada

Para auxiliar na utilização de classes abstratas em Python, precisamos importar os módulos ABC e abstracmethod:

Sintaxe

from abc import ABC, abstractmethod

Diferente de linguagens como C# e Java, Python não possui uma palavra reservada abstract para declaração de classe abstrata.

Sintaxe

class classe_abstrata
    pass

Exemplo 1

from abc import ABC, abstractmethod

class classe_abstrata:
      pass

O corpo de uma classe abstrata pode conter métodos abstratos e também métodos concretos ou com implementação. Os métodos abstratos, assim como em interfaces, são marcado com o decorador @abstractmethod:

Sintaxe

class classe_abstrata: 

    @abstractmethod
    def nome_metodo1()
            pass

    @abstractmethod
    def nome_metodo2(<parametros>)
            pass

    def nome_metodoN(<parametros>)
        #corpo método concreto    

O uso do comando pass nos métodos abstratos é obrigatório, pois esses métodos não possuem implementação.

Exemplo 2

from abc import ABC,abstractmethod

class abstrata:
    @abstractmethod
    def metodo1(p):
        pass
    
    @abstractmethod
    def metodo2(p,q):
        pass

    def metodo3(p)
        print(p)

Saída

-

Os métodos concreto de uma classe abstrata são métodos de classe comuns que já foram vistos em POO: Métodos que possuem características semelhantes as funções estudas em Python: Funções.

Para que seja possível o uso herança de uma classe abstrata, precisamos criar uma classe e informar que uma determinada classe abstrata será herdada. Isso é feito com o uso da herança de classe já visto.

Sintaxe

class nome_classe(classe_abstrata):
    #corpo

Exemplo 3

from abc import ABC,abstractmethod

class abstrata:
    @abstractmethod
    def metodo1(self,p): #método abstrato
        pass
    
    def metodo2(self):   #método concreto
        print("metodo2")
        
class classe(abstrata): #herança de classe abstrata
    pass

Saída

-

A implementação dos métodos de uma classe abstrata é feita normalmente com qualquer nos métodos já exemplificados.

Os nomes dos parâmetros utilizados pelos métodos implementados não precisam necessariamente coincidir com os nomes declarados na assinatura dos métodos.

Exemplo 4

from abc import ABC,abstractmethod

class abstrata:
    @abstractmethod
    def metodo1(self,p): #método abstrato
        pass
    
    def metodo2(self):   #método concreto
        print("metodo2")
        
        
class classe(abstrata):
    def metodo1(self,p): #método abstrato implementado
        print(p)

obj = classe()
obj.metodo1(999)
obj.metodo2()

Saída

1

Com o uso de classe abstrata, podemos ter N classes herdando de uma mesma classe abstrata realizando as mesmas tarefas de forma diferente de acordo com suas necessidades.

Exemplo 4

from abc import ABC,abstractmethod

class abstrata:
    @abstractmethod
    def metodo1(self,p): #método abstrato
        pass
    
    def metodo2(self):   #método concreto
        print("metodo2")
        
        
class classe1(abstrata):
    def metodo1(self,p): #método abstrato implementado
        print(p)

class classe2(abstrata):
    def metodo1(self,p): #método abstrato implementado
        print(p*p)
        
obj = classe1()
obj.metodo1(100)
obj = classe2()
obj.metodo1(2)

Saída

100
4

Para que seja possível o uso de mais de uma interface, precisamos criar uma classe e informar que quais classes abstratas serão herdadas.

Sintaxe

class nome_classe( classe_abstrata1, ... , classe_abstrata1N ):
    #corpo

Exemplo 5

from abc import ABC,abstractmethod

class classe_abstrata:
    @abstractmethod
    def metodo1(p):
        pass
    
class classe_abstrata2:
    @abstractmethod
    def metodo2(p):
        pass

class classe2(classe_abstrata,classe_abstrata2):
    def metodo1(self,p):
        print(p)
        
    def metodo2(self,p):
        print(p*p)


obj = classe2()
obj.metodo1(1)
obj.metodo2(2)

Saída

1
4

A linguagem Python permite também que a herança múltipla de classe abstrata, conscreta e interfaces.

Sintaxe

class nome_classe( classe_abstrata, classe_concreta , interface ):
    #corpo

Exemplo 6

from abc import ABC,abstractmethod

class abstrata:
    @abstractmethod
    def metodo1(self): #método abstrato
        pass
    
    def metodo2(self):   #método concreto
        print("metodo2")

class classe:
    def metodo3(self): #método abstrato
        print("metodo3")
    
    def metodo4(self):   #método concreto
        print("metodo4")

class interface:
    @abstractmethod
    def metodo5(p):
        pass
    
class classe1(abstrata, classe, interface):
    def metodo1(self): #método abstrato implementado
        print("metodo1")

    def metodo5(self): #método abstrato implementado
        print("metodo5")

obj = classe1()
obj.metodo1()
obj.metodo2()
obj.metodo3()
obj.metodo4()
obj.metodo5()

Saída

metodo1
metodo2
metodo3
metodo4
metodo5

1. 12/09/2025 - revisão 2 - Ajustes: navegação 'Próximo', pontuais, target de links, Ex. 5, sintaxes e objetivos'
2. 19/09/2024 - revisão 1 - correção em: sintaxes de 'Classe Abstrata', Ex. 1; ajustes gramaticais; outros ajustes
3. 20/02/2024 - versão inicial