interfaces - ¿Es posible hacer clases abstractas en Python?

clases abstractas python

Question

¿Cómo puedo hacer un resumen de clase o método en Python?

Intenté redefinir __new__() así:

class F:
def __new__(cls):
raise Exception("Unable to create an instance of abstract class %s" %cls)

pero ahora si creo una clase G que hereda de F así:

class G(F):
pass

entonces tampoco puedo crear una instancia de G , ya que llama al método __new__ su súper clase.

¿Hay una mejor manera de definir una clase abstracta?

Answer 1

Éste estará trabajando en python 3.

from abc import ABCMeta, abstractmethod
class Abstract(metaclass=ABCMeta):
@abstractmethod
def foo(self):
pass
Abstract()
>>> TypeError: Can not instantiate abstract class Abstract with abstract methods foo

Answer 2

Aquí es una manera muy fácil sin tener que lidiar con el módulo ABC.

En el método __init__ de la clase que desea que sea una clase abstracta, puede verificar el "tipo" de sí mismo. Si el tipo de self es la clase base, entonces la persona que llama está intentando crear una instancia de la clase base, por lo que debe generar una excepción. Aquí hay un ejemplo simple:

class Base():
def __init__(self):
if type(self) is Base:
raise Exception(''Base is an abstract class and cannot be instantiated directly'')
# Any initialization code
print(''In the __init__ method of the Base class'')
class Sub(Base):
def __init__(self):
print(''In the __init__ method of the Sub class before calling __init__ of the Base class'')
super().__init__()
print(''In the __init__ method of the Sub class after calling __init__ of the Base class'')
subObj = Sub()
baseObj = Base()

Cuando se ejecuta, produce:

In the `__init__` method of the Sub class before calling `__init__` of the Base class
In the `__init__` method of the Base class
In the `__init__` method of the Sub class after calling `__init__` of the Base class
Traceback (most recent call last):
File "/Users/irvkalb/Desktop/Demo files/Abstract.py", line 16, in <module>
baseObj = Base()
File "/Users/irvkalb/Desktop/Demo files/Abstract.py", line 4, in `__init__`
raise Exception(''Base is an abstract class and cannot be instantiated directly'')
Exception: Base is an abstract class and cannot be instantiated directly

Esto muestra que puede crear una instancia de una subclase que hereda de una clase base, pero no puede crear una instancia de la clase base directamente.

Irv

Answer 3

En su fragmento de código, también puede resolver esto proporcionando una implementación para el método __new__ en la subclase, de la misma manera:

def G(F):
def __new__(cls):
# do something here

Pero esto es un truco y te aconsejo que no lo hagas, a menos que sepas lo que estás haciendo. Para casi todos los casos, le aconsejo que utilice el módulo abc , que otros me han sugerido.

También cuando creas una nueva clase (base), class MyBaseClass(object): object subclase, así: class MyBaseClass(object): Ya no sé si es tan importante, pero ayuda a mantener la coherencia de estilo en su código

Answer 4

La forma en que lo hizo la vieja escuela (antes de PEP 3119 ) es simplemente raise NotImplementedError en la clase abstracta cuando se llama a un método abstracto.

class Abstract(object):
def foo(self):
raise NotImplementedError(''subclasses must override foo()!'')
class Derived(Abstract):
def foo(self):
print ''Hooray!''
>>> d = Derived()
>>> d.foo()
Hooray!
>>> a = Abstract()
>>> a.foo()
Traceback (most recent call last): [...]

Esto no tiene las mismas propiedades agradables que el uso del módulo abc . Aún puede crear una instancia de la clase base abstracta, y no encontrará su error hasta que llame al método abstracto en tiempo de ejecución.

Pero si está tratando con un pequeño conjunto de clases simples, tal vez con unos pocos métodos abstractos, este enfoque es un poco más fácil que tratar de leer la documentación del abc .

Answer 5

La mayoría de las respuestas anteriores fueron correctas, pero aquí está la respuesta y el ejemplo para Python 3.7. Sí, puedes crear una clase abstracta y un método. Como recordatorio, a veces una clase debe definir un método que lógicamente pertenece a una clase, pero esa clase no puede especificar cómo implementar el método. Por ejemplo, en las siguientes clases para padres y bebés, ambos comen, pero la implementación será diferente para cada uno porque los bebés y los padres comen un tipo diferente de alimentos y la cantidad de veces que comen es diferente. Por lo tanto, las subclases de métodos de comer anulan a AbstractClass.eat.

ResumenClase, come metho

import abc
from abc import ABC, abstractmethod
class AbstractClass(ABC):
def __init__(self, value):
self.value = value
super().__init__()
@abstractmethod
def eat(self):
pass
class Parents(AbstractClass):
def eat(self):
return "eat solid food "+ str(self.value) + " times each day"
class Babies(AbstractClass):
def eat(self):
return "Milk only "+ str(self.value) + " times or more each day"
food = 3
mom = Parents(food)
print("moms ----------")
print(mom.eat())
infant = Babies(food)
print("infants ----------")
print(infant.eat())

SALIDA:

moms ----------
eat solid food 3 times each day
infants ----------
Milk only3 times or more each day

Answer 6

Sí, puede crear clases abstractas en python con el módulo abc (clases base abstractas).

Este sitio le ayudará con esto: http://docs.python.org/2/library/abc.html

Answer 7

Si puedes, usando el . abc . abc - módulo de clases base abstractas, aquí hay un ejemplo:

Python3.6

# importing abstract base classes module
import abc
class GetterSetter(abc.ABC):
''''''
ABSTRACT BASE CLASSES:
- An abstract base class is a kind of ''model'' for other classes to be defined.
- It is not designed to construct instances, but can be subclassed by regular classes
- Abstract classes can define interface, or methods that must be implemented by its subclasses.
''''''
# Abstract classes are not designed to be instantiated, only to be subclassed
# decorator for abstract class
@abc.abstractmethod
def set_val(self, input):
"""set the value in the instance"""
return
@abc.abstractmethod
def get_val(self):
"""Get and return a value from the instance..."""
return
# Inheriting from the above abstract class
class MyClass(GetterSetter):
# methods overriding in the GetterSetter
def set_val(self, input):
self.val = input
def get_val(self):
return self.val
# Instantiate
x = MyClass()
print(x) # prints the instance <__main__.MyClass object at 0x10218ee48>
x = GetterSetter() #throws error, abstract classes can''t be instantiated

Python2.x

import abc
class GetterSetter(object):
# meta class is used to define other classes
__metaclass__ = abc.ABCMeta
# decorator for abstract class
@abc.abstractmethod
def set_val(self, input):
"""set the value in the instance"""
return
@abc.abstractmethod
def get_val(self):
"""Get and return a value from the instance..."""
return
# Inheriting from the above abstract class
class MyClass(GetterSetter):
# methods overriding in the GetterSetter
def set_val(self, input):
self.val = input
def get_val(self):
return self.val
# Instantiate
x = GetterSetter()
print(x)
x = GetterSetter() #throws error, abstract classes can''t be instantiated

Answer 8

Solo una adición rápida a la respuesta de la vieja escuela de @ TimGilbert ... puede hacer que el método init () de su clase base abstracta genere una excepción y eso evitaría que se instanciara, ¿no?

>>> class Abstract(object):
... def __init__(self):
... raise NotImplementedError("You can''t instantiate this class!")
...
>>> a = Abstract()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 3, in __init__
NotImplementedError: You can''t instantiate this class!

Answer 9

También esto funciona y es simple:

class A_abstract(object):
def __init__(self):
# quite simple, old-school way.
if self.__class__.__name__ == "A_abstract":
raise NotImplementedError("You can''t instantiate this abstract class. Derive it, please.")
class B(A_abstract):
pass
b = B()
# here an exception is raised:
a = A_abstract()

Answer 10

Usa el módulo abc para crear clases abstractas. Utilice el decorador de métodos abstractos para declarar un método abstracto y declare un resumen de clase utilizando una de las tres formas, dependiendo de su versión de Python.

En Python 3.4 y superior, puedes heredar de ABC . En versiones anteriores de Python, debe especificar la metaclase de su clase como ABCMeta . La especificación de la metaclase tiene una sintaxis diferente en Python 3 y Python 2. Las tres posibilidades se muestran a continuación:

# Python 3.4+
from abc import ABC, abstractmethod
class Abstract(ABC):
@abstractmethod
def foo(self):
pass

# Python 3.0+
from abc import ABCMeta, abstractmethod
class Abstract(metaclass=ABCMeta):
@abstractmethod
def foo(self):
pass

# Python 2
from abc import ABCMeta, abstractmethod
class Abstract:
__metaclass__ = ABCMeta
@abstractmethod
def foo(self):
pass

Cualquiera que sea la forma que use, no podrá crear una instancia de una clase abstracta que tenga métodos abstractos, pero sí podrá crear una subclase que proporcione definiciones concretas de esos métodos:

>>> Abstract()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: Can''t instantiate abstract class Abstract with abstract methods foo
>>> class StillAbstract(Abstract):
... pass
...
>>> StillAbstract()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: Can''t instantiate abstract class StillAbstract with abstract methods foo
>>> class Concrete(Abstract):
... def foo(self):
... print(''Hello, World'')
...
>>> Concrete()
<__main__.Concrete object at 0x7fc935d28898>