de Python(), las clases base abstractas y NotImplementedError

Question

Abstract base classes can still be handy in Python. Al escribir una clase base abstracta donde quiero que cada subclase que tiene, por ejemplo, un método spam(), quiero escribir algo como esto:

class Abstract(object): 
    def spam(self): 
     raise NotImplementedError 

El desafío también es querer usar super(), y hacerlo correctamente incluyéndolo en toda la cadena de subclases. En este caso, parece que tengo para envolver cada super llamada como la siguiente:

class Useful(Abstract): 
    def spam(self): 
     try: 
      super(Useful, self).spam() 
     except NotImplementedError, e: 
      pass 
     print("It's okay.") 

Eso está bien para un simple subclase, pero cuando se escribe una clase que tiene muchos métodos, el try-excepto que se hace un poco engorroso y un poco feo ¿Hay una manera más elegante de crear subclases a partir de clases base abstractas? ¿Lo estoy haciendo mal?

Answer 1

Puede hacerlo limpiamente en Python 2.6+ con el abc module:

import abc 
class B(object): 
    __metaclass__ = abc.ABCMeta 
    @abc.abstractmethod 
    def foo(self): 
     print 'In B' 

class C(B): 
    def foo(self): 
     super(C, self).foo() 
     print 'In C' 

C().foo() 

La salida será

In B 
In C 

Answer 2

No escribir todo ese código. La simple inspección de la clase abstracta puede ahorrarle la escritura de todo ese código.

Si el método es abstracto, la subclase concreta no llama súper.

Si el método es concreto, la subclase concreta llama súper.

Answer 3

El punto clave para entender esto es super() es para implementar la herencia cooperativa. Cómo colaboran las clases depende de usted, el programador. super() no es mágico y no sabe exactamente lo que quiere! No tiene mucho sentido usar super para una jerarquía plana que no necesita herencia cooperativa, por lo que en ese caso la sugerencia de S. Lott es acertada. Las subclases de mayo útil o pueden no desear usar super() dependiendo de sus objetivos :)

Por ejemplo: El extracto es A. A < - B, pero entonces usted quiere apoyar la inserción de C como tal A < - C < - B .

class A(object):                       
    """I am an abstract abstraction :)""" 
    def foo(self): 
     raise NotImplementedError('I need to be implemented!') 

class B(A): 
    """I want to implement A""" 
    def foo(self): 
     print('B: foo') 
     # MRO Stops here, unless super is not A 
     position = self.__class__.__mro__.index 
     if not position(B) + 1 == position(A): 
      super().foo() 

b = B()  
b.foo() 

class C(A): 
    """I want to modify B and all its siblings (see below)""" 
    def foo(self): 
     print('C: foo') 
     # MRO Stops here, unless super is not A 
     position = self.__class__.__mro__.index 
     if not position(C) + 1 == position(A): 
      super().foo() 

print('') 
print('B: Old __base__ and __mro__:\n') 
print('Base:', B.__bases__) 
print('MRO:', B.__mro__) 
print('') 
# __mro__ change implementation 
B.__bases__ = (C,) 
print('B: New __base__ and __mro__:\n') 
print('Base:', B.__bases__) 
print('MRO:', B.__mro__) 
print('') 
b.foo() 

Y la salida:

B: foo 

B: Old __base__ and __mro__: 

Base: (<class '__main__.A'>,) 
MRO: (<class '__main__.B'>, <class '__main__.A'>, <class 'object'>) 

B: New __base__ and __mro__: 

Base: (<class '__main__.C'>,) 
MRO: (<class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>) 

B: foo 
C: foo