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 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

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.

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 1

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 um determinada classe abstrata será herdada. Isso é feito com o uso da herança de classe já visto.

Sintaxe

class nome_classe(nome_classe_abstrata)
    #corpo

Exemplo 2

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 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):
    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(nome_classe_abstrata1, nome_classe_abstrata2, nome_classe_abstrata1N)
    #corpo

Exemplo 5

from abc import ABC,abstractmethod

class interface1:
    @abstractmethod
    def metodo1(p):
        pass
    
class interface2:
    @abstractmethod
    def metodo2(p):
        pass

class classe2(interface1,interface2):
    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 e também mista com interfaces.

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