Clases abstractas en Python

Una clase abstracta puede considerarse como un modelo para otras clases. Le permite crear un conjunto de métodos que deben crearse dentro de cualquier clase secundaria creada a partir de la clase abstracta. Una clase que contiene uno o más métodos abstractos se denomina clase abstracta. Un método abstracto es un método que tiene una declaración pero no tiene una implementación. Mientras diseñamos unidades funcionales grandes, usamos una clase abstracta. Cuando queremos proporcionar una interfaz común para diferentes implementaciones de un componente, usamos una clase abstracta. 
  
Por qué usar clases base abstractas: 
Al definir una clase base abstracta, puede definir una interfaz de programa de aplicación (API) común para un conjunto de subclases. Esta capacidad es especialmente útil en situaciones en las que un tercero proporcionará implementaciones, como con complementos, pero también puede ayudarlo cuando trabaja en un equipo grande o con una gran base de código donde es difícil tener en cuenta todas las clases. o no es posible. 
  
Cómo funcionan las clases de base abstracta: 
de forma predeterminada, Python no proporciona clases abstractas. Python viene con un módulo que proporciona la base para definir clases de base abstracta (ABC) y ese nombre de módulo es ABC. A B Cfunciona decorando métodos de la clase base como abstractos y luego registrando clases concretas como implementaciones de la base abstracta. Un método se vuelve abstracto cuando está decorado con la palabra clave @abstractmethod. Por ejemplo –
 

Código 1:

# Python program showing
# abstract base class work
 
from abc import ABC, abstractmethod
 
class Polygon(ABC):
 
    @abstractmethod
    def noofsides(self):
        pass
 
class Triangle(Polygon):
 
    # overriding abstract method
    def noofsides(self):
        print("I have 3 sides")
 
class Pentagon(Polygon):
 
    # overriding abstract method
    def noofsides(self):
        print("I have 5 sides")
 
class Hexagon(Polygon):
 
    # overriding abstract method
    def noofsides(self):
        print("I have 6 sides")
 
class Quadrilateral(Polygon):
 
    # overriding abstract method
    def noofsides(self):
        print("I have 4 sides")
 
# Driver code
R = Triangle()
R.noofsides()
 
K = Quadrilateral()
K.noofsides()
 
R = Pentagon()
R.noofsides()
 
K = Hexagon()
K.noofsides()

Producción: 
 

I have 3 sides
I have 4 sides
I have 5 sides
I have 6 sides

  
Código 2: 

# Python program showing
# abstract base class work
 
from abc import ABC, abstractmethod
class Animal(ABC):
 
    def move(self):
        pass
 
class Human(Animal):
 
    def move(self):
        print("I can walk and run")
 
class Snake(Animal):
 
    def move(self):
        print("I can crawl")
 
class Dog(Animal):
 
    def move(self):
        print("I can bark")
 
class Lion(Animal):
 
    def move(self):
        print("I can roar")
         
# Driver code
R = Human()
R.move()
 
K = Snake()
K.move()
 
R = Dog()
R.move()
 
K = Lion()
K.move()

Producción: 
 

I can walk and run
I can crawl
I can bark
I can roar

  
Implementación a través de subclases: 
al subclasificar directamente desde la base, podemos evitar la necesidad de registrar la clase explícitamente. En este caso, la gestión de clases de Python se utiliza para reconocer que PluginImplementation implementa la PluginBase abstracta. 
 

# Python program showing
# implementation of abstract
# class through subclassing
 
import abc
 
class parent:      
    def geeks(self):
        pass
 
class child(parent):
    def geeks(self):
        print("child class")
 
# Driver code
print( issubclass(child, parent))
print( isinstance(child(), parent))

Producción: 
 

True
True

Un efecto secundario del uso de subclases directas es que es posible encontrar todas las implementaciones de su complemento solicitando a la clase base la lista de clases conocidas derivadas de ella. 
  
Métodos concretos en clases base abstractas: 
las clases concretas contienen solo métodos concretos (normales), mientras que las clases abstractas pueden contener tanto métodos concretos como métodos abstractos. La clase concreta proporciona una implementación de métodos abstractos, la clase base abstracta también puede proporcionar una implementación invocando los métodos a través de super(). 
 

Veamos el ejemplo para invocar el método usando super():  

# Python program invoking a
# method using super()
 
import abc
from abc import ABC, abstractmethod
 
class R(ABC):
    def rk(self):
        print("Abstract Base Class")
 
class K(R):
    def rk(self):
        super().rk()
        print("subclass ")
 
# Driver code
r = K()
r.rk()

Producción: 
 

Abstract Base Class
subclass

En el programa anterior, podemos invocar los métodos en clases abstractas usando super(). 
  
Propiedades 
abstractas: las clases abstractas incluyen atributos además de métodos, puede requerir los atributos en clases concretas definiéndolos con @abstractproperty. 
 

# Python program showing
# abstract properties
 
import abc
from abc import ABC, abstractmethod
 
class parent(ABC):
    @abc.abstractproperty
    def geeks(self):
        return "parent class"
class child(parent):
      
    @property
    def geeks(self):
        return "child class"
  
  
try:
    r =parent()
    print( r.geeks)
except Exception as err:
    print (err)
  
r = child()
print (r.geeks)

Producción: 
 

Can't instantiate abstract class parent with abstract methods geeks
child class

En el ejemplo anterior, no se puede crear una instancia de la clase Base porque solo tiene una versión abstracta del método captador de propiedades. 
  
Instanciación de clase 
abstracta: las clases abstractas están incompletas porque tienen métodos que no tienen nadie. Si Python permite crear un objeto para clases abstractas, entonces use ese objeto si alguien llama al método abstracto, pero no hay una implementación real para invocar. Así que usamos una clase abstracta como plantilla y, de acuerdo con la necesidad, la ampliamos y construimos sobre ella antes de que podamos usarla. Debido al hecho, una clase abstracta no es una clase concreta, no se puede instanciar. Cuando creamos un objeto para la clase abstracta, genera un error . 
 

# Python program showing
# abstract class cannot
# be an instantiation
from abc import ABC,abstractmethod
 
class Animal(ABC):
    @abstractmethod
    def move(self):
        pass
class Human(Animal):
    def move(self):
        print("I can walk and run")
 
class Snake(Animal):
    def move(self):
        print("I can crawl")
 
class Dog(Animal):
    def move(self):
        print("I can bark")
 
class Lion(Animal):
    def move(self):
        print("I can roar")
 
c=Animal()

Producción: 
 

Traceback (most recent call last):
  File "/home/ffe4267d930f204512b7f501bb1bc489.py", line 19, in 
    c=Animal()
TypeError: Can't instantiate abstract class Animal with abstract methods move