Métodos abstractos en Python

Question

Tengo problemas para usar la herencia con Python. Mientras que el concepto me parece demasiado fácil en Java, hasta ahora no he sido capaz de entenderlo en Python, lo cual me sorprende al menos.

que tienen un prototipo que sigue:

class Shape(): 
    def __init__(self, shape_name): 
     self.shape = shape_name 

class Rectangle(Shape): 
    def __init__(self, name): 
     self.shape = name 

En el código anterior, ¿cómo puedo hacer que un método abstracto que tendría que ser implementado para todas las subclases?

Answer 1

algo en este sentido, el uso de ABC

import abc 

class Shape(object): 
    __metaclass__ = abc.ABCMeta 

    @abc.abstractmethod 
    def method_to_implement(self, input): 
     """Method documentation""" 
     return 

También lea este buen tutorial: http://www.doughellmann.com/PyMOTW/abc/

También puede revisar zope.interface que fue utilizado antes de la introducción de ABC en pitón.

• http://pypi.python.org/pypi/zope.interface
• http://wiki.zope.org/Interfaces/FrontPage

Answer 2

Tiene que implementar una clase base abstracta (ABC).

Check python docs

Answer 3

Véase el abc module. Básicamente, defina __metaclass__ = abc.ABCMeta en la clase, luego decore cada método abstracto con @abc.abstractmethod. Las clases derivadas de esta clase no se pueden instanciar a menos que se hayan anulado todos los métodos abstractos.

Si su clase ya está utilizando una metaclase, derivarla de ABCMeta en lugar de type y puede seguir utilizando su propia metaclase.

Una alternativa barata (y la mejor práctica antes de la introducción del módulo abc) sería tener todos los métodos abstractos acaba de lanzar una excepción (NotImplementedError es una buena) para que las clases derivadas de ella tendrían que reemplazar ese método ser útil.

Sin embargo, la solución abc es mejor porque evita que dichas clases se instancian (es decir, "falla más rápido"), y también porque puede proporcionar una implementación predeterminada o básica de cada método que se puede alcanzar usando la función super() en clases derivadas.

Answer 4

No se puede, con primitivas del lenguaje. Como se ha llamado, el abc package proporciona esta funcionalidad en Python 2.6 y posterior, pero no hay opciones para Python 2.5 y versiones anteriores. El paquete abc no es una característica nueva de Python; en su lugar, agrega funcionalidad al agregar explícita "¿esta clase dice que hace esto?" verificaciones, con verificaciones de consistencia implementadas manualmente para causar un error durante la inicialización si tales declaraciones son falsas.

Python es un lenguaje militantemente tipado dinámicamente. No especifica las primitivas del lenguaje para permitirle evitar que un programa se compile porque un objeto no coincide con los requisitos de tipo; esto solo se puede descubrir en tiempo de ejecución. Si requiere que una subclase implemente un método, documente eso, y luego simplemente llame al método con la certera esperanza de que estará allí.

Si está allí, fantástico, simplemente funciona; esto se llama duck typing, y su objeto se ha grabado lo suficiente como un pato para satisfacer la interfaz. Esto funciona muy bien incluso si self es el objeto que está llamando un método en, a los efectos de anulaciones obligatorias debido a los métodos básicos que necesitan implementaciones específicas de características (funciones genéricas), porque self es una convención, nada realmente especial.

La excepción está en __init__, porque cuando se llama a su inicializador, el inicializador del tipo derivado no, por lo que aún no ha tenido la oportunidad de grapar sus propios métodos en el objeto.

Si el método no se implementó, obtendrá un AttributeError (si no está allí) o un TypeError (si hay algo con ese nombre pero no es una función o no tiene esa firma)) Depende de usted cómo maneja eso, ya sea que lo llame error de programador y deje que bloquee el programa (y "debería" ser obvio para un desarrollador de Python lo que causa ese tipo de error allí - una interfaz de pato no satisfecha), o atrape y maneje esas excepciones cuando descubres que tu objeto no era compatible con lo que deseas. La captura de AttributeError y TypeError es importante en muchas situaciones, en realidad.

Answer 5

Antes de que abc se presentara, esto se vería con frecuencia.

class Base(object): 
    def go(self): 
     raise NotImplementedError("Please Implement this method") 


class Specialized(Base): 
    def go(self): 
     print "Consider me implemented" 

Answer 6

Las clases base abstractas son magia profunda. Periódicamente implemento algo usándolos y estoy sorprendido de mi propia astucia, muy poco después me encuentro completamente confundido por mi propia astucia (esto bien puede ser solo una limitación personal).

Otra forma de hacerlo (debería estar en la biblioteca de python si me preguntas) es hacer un decorador.

def abstractmethod(method): 
    """ 
    An @abstractmethod member fn decorator. 
    (put this in some library somewhere for reuse). 

    """ 
    def default_abstract_method(*args, **kwargs): 
     raise NotImplementedError('call to abstract method ' 
            + repr(method)) 
    default_abstract_method.__name__ = method.__name__  
    return default_abstract_method 


class Shape(object): 

    def __init__(self, shape_name): 
     self.shape = shape_name 

    @abstractmethod 
    def foo(self): 
     print "bar" 
     return 

class Rectangle(Shape): 
    # note you don't need to do the constructor twice either 
    pass 

r = Rectangle("x") 
r.foo() 

No escribí el decorador. Simplemente se me ocurrió que alguien lo hubiera hecho. Puede encontrarlo aquí: http://code.activestate.com/recipes/577666-abstract-method-decorator/ Bueno, uno jimmy2times. Tenga en cuenta la discusión en la parte inferior de esa página r.e. tipo de seguridad del decorador. (Eso podría arreglarse con el módulo de inspección si alguien tuviera tanta inclinación).

Answer 7

Puede utilizar seis y ABC para construir una clase, tanto para python2 y python3 eficiente de la siguiente manera:

import six 
import abc 

@six.add_metaclass(abc.ABCMeta) 
class MyClass(object): 
    """ 
    documentation 
    """ 

    @abc.abstractmethod 
    def initialize(self, para=None): 
     """ 
     documentation 
     """ 
     raise NotImplementedError 

This es un documento awesomoe de ella.