Prevenzione di una classe dall'istanza diretta in Python

Question

Ho una super classe con un metodo che chiama altri metodi che sono definiti solo nelle sue sottoclassi. Ecco perché, quando creo un'istanza della mia super classe e chiamo il suo metodo, non riesce a trovare il metodo e genera un errore.

Ecco un esempio:

class SuperClass(object): 

    def method_one(self): 
    value = self.subclass_method() 
    print value 


class SubClassOne(SuperClass): 

    def subclass_method(self): 
    return 'subclass 1' 


class SubClassTwo(SuperClass): 

    def subclass_method(self): 
    return 'nubclass 2' 


s1 = SubClassOne() 
s1.method_one() 

s2 = SubClassTwo() 
s2.method_one() 

c = SuperClass() 
c.method_one() 

# Results: 
# subclass 1 
# nubclass 2 
# Traceback (most recent call last): 
# File "abst.py", line 28, in <module> 
#  c.method_one() 
# File "abst.py", line 4, in method_one 
#  value = self.subclass_method() 
# AttributeError: 'SuperClass' object has no attribute 'subclass_method' 

stavo pensando di cambiare il init di classe super e verificare il tipo di oggetto, quando viene creata una nuova istanza. Se l'oggetto appartiene alla super classe, genera un errore. Tuttavia, non sono sicuro se sia il modo Pythoniano di farlo.

Qualche consiglio?

Answer 1

Stai parlando di Base Base astratta e il linguaggio Python non li supporta in modo nativo.

Tuttavia, nella libreria standard è disponibile un modulo che può essere d'aiuto. Controlla la documentazione di abc.

Answer 2

L'approccio è un tipico framework pattern.

Utilizzare __init__ per verificare che type(self) is not SuperClass sia un modo ragionevole per assicurarsi che la SuperClass non sia stata creata direttamente.

L'altro approccio comune è quello di fornire metodi di stub che vengono chiamati raise NotImplementedError. Ciò è più affidabile perché convalida anche che le sottoclassi hanno sovrascritto i metodi previsti.

Answer 3

Questo è quello che potrei fare:

class SuperClass(object): 
    def __init__(self): 
     if type(self) == SuperClass: 
      raise Exception("<SuperClass> must be subclassed.") 
     # assert(type(self) == SuperClass) 

class SubClass(SuperClass): 
    def __init__(self): 
     SuperClass.__init__(self) 

subC = SubClassOne() 
supC = SuperClass() # This line should throw an exception 

Quando run (viene generata un'eccezione!):

[ 18:32 jon@hozbox ~/so/python ]$ ./preventing-direct-instantiation.py 
Traceback (most recent call last): 
    File "./preventing-direct-instantiation.py", line 15, in <module> 
    supC = SuperClass() 
    File "./preventing-direct-instantiation.py", line 7, in __init__ 
    raise Exception("<SuperClass> must be subclassed.") 
Exception: <SuperClass> must be subclassed. 

---

Edit (dai commenti):

[ 20:13 jon@hozbox ~/SO/python ]$ cat preventing-direct-instantiation.py 
#!/usr/bin/python 

class SuperClass(object): 
    def __init__(self): 
     if type(self) == SuperClass: 
      raise Exception("<SuperClass> must be subclassed.") 

class SubClassOne(SuperClass): 
    def __init__(self): 
     SuperClass.__init__(self) 

class SubSubClass(SubClassOne): 
    def __init__(self): 
     SubClassOne.__init__(self) 

class SubClassTwo(SubClassOne, SuperClass): 
    def __init__(self): 
     SubClassOne.__init__(self) 
     SuperClass.__init__(self) 

subC = SubClassOne() 

try: 
    supC = SuperClass() 
except Exception, e: 
    print "FAILED: supC = SuperClass() - %s" % e 
else: 
    print "SUCCESS: supC = SuperClass()" 

try: 
    subSubC = SubSubClass() 
except Exception, e: 
    print "FAILED: subSubC = SubSubClass() - %s" % e 
else: 
    print "SUCCESS: subSubC = SubSubClass()" 

try: 
    subC2 = SubClassTwo() 
except Exception, e: 
    print "FAILED: subC2 = SubClassTwo() - %s" % e 
else: 
    print "SUCCESS: subC2 = SubClassTwo()" 

Stampe:

[ 20:12 jon@hozbox ~/SO/python ]$ ./preventing-direct-instantiation.py 
FAILED: supC = SuperClass() - <SuperClass> must be subclassed. 
SUCCESS: subSubC = SubSubClass() 
SUCCESS: subC2 = SubClassTwo() 

Answer 4

Ignorerei __new__() nella classe base e semplicemente non riuscirò a istanziare affatto se è la classe base.

class BaseClass(object): 

    def __new__(cls, *args, **kwargs): 
     if cls is BaseClass: 
      raise TypeError("base class may not be instantiated") 
     return object.__new__(cls, *args, **kwargs) 

Questo separa riguarda un po 'meglio averlo in __init__(), e "fallisce veloce".