Le funzioni virtuali pure Python sono possibili e/o ne valgono la pena?

Question

Potrei venire da una mentalità diversa, essendo principalmente un programmatore C++. Questa domanda ha a che fare con OOP in Python e in particolare con metodi virtuali puri. Prendendo il codice che ho adattato da this question sto guardando questo campione di base.

class Animal(): 
    def speak(self): 
     print("...") 

class Cat(Animal): 
    def speak(self): 
     print("meow") 

class Dog(Animal): 
    def speak(self): 
     print("woof") 

my_pets = [Dog(), Cat(), Dog()] 

for _pet in my_pets: 
    _pet.speak() 

In questo modo viene chiamata la funzione parla per diverse classi derivate. Ora il mio problema è che digitando anatra è tutto buono e penso di averlo afferrato. Tuttavia, è sbagliato perseguire un OOP più rigoroso in Python? Così ho visto lo Abstract Base Classes e in particolare lo abstractmethod. A me sembra che tutto questo mi consenta di chiamare il metodo della classe base con super. Esiste un modo/ragione (in Python) per rendere puro speak() tale che l'implementazione di un animale derivato senza parlare possa generare un errore?

La mia argomentazione a favore di una tale ricerca sarebbe quando si scrivono moduli e framework che si intendono le persone in sottoclasse, questo potrebbe autocertificare per loro il fatto che è necessario implementare la funzione. Probabilmente un'idea molto brutta è una cosa del genere, visto che la funzione "pura" della classe base genera un'eccezione. Il problema è che questo errore si trova in fase di esecuzione!

class VirtualException(BaseException): 
    def __init__(self, _type, _func): 
     BaseException(self) 

class Animal(): 
    def speak(self): 
     raise VirtualException() 

class Cat(Animal): 
    def speak(self): 
     print("meow") 

class Dog(Animal): 
    def speak(self): 
     print("woof") 

class Wildebeest(Animal): 
    def function2(self): 
     print("What!") 

my_pets = [Dog(), Cat(), Dog(), Wildebeest()] 

for _pet in my_pets: 
    _pet.speak() 

Answer 1

classi base astratte già fanno quello tu vuoi. abstractmethod non ha nulla a che fare con la possibilità di chiamare il metodo con super; puoi farlo comunque. Invece, i metodi decorati con abstractmethod devono essere sovrascritte per una sottoclasse di essere istanziabile:

>>> class Foo(object): 
...  __metaclass__ = abc.ABCMeta 
...  @abc.abstractmethod 
...  def foo(self): pass 
... 
>>> class Bar(Foo): pass 
... 
>>> class Baz(Bar): 
...  def foo(self): return super(Baz, self).foo() 
... 
>>> Foo() 
Traceback (most recent call last): 
    File "<stdin>", line 1, in <module> 
TypeError: Can't instantiate abstract class Foo with abstract methods foo 
>>> Bar() 
Traceback (most recent call last): 
    File "<stdin>", line 1, in <module> 
TypeError: Can't instantiate abstract class Bar with abstract methods foo 
>>> Baz() 
<__main__.Baz object at 0x0000000001EC10B8> 

Answer 2

Il problema è che questo errore si trova in fase di esecuzione!

Bene, è Python ... la maggior parte degli errori verrà mostrata in fase di esecuzione.

Per quanto ne so, il modello più comune per affrontare è in Python è fondamentalmente ciò che si descrive: basta avere il metodo speak della classe base un'eccezione:

class Animal(): 
    def speak(self): 
     raise NotImplementedError('You need to define a speak method!')