पायथन

Question

में प्रत्यक्ष तत्कालता से कक्षा को रोकना मेरे पास एक ऐसी विधि है जिसमें अन्य विधियां हैं जिन्हें केवल उप-वर्गों में परिभाषित किया गया है। यही कारण है कि, जब मैं अपनी सुपर क्लास का उदाहरण बनाता हूं और अपनी विधि को कॉल करता हूं, तो यह विधि नहीं ढूंढ सकता है और एक त्रुटि उठाता है।

यहाँ एक उदाहरण है:

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' 

मैं init सुपर वर्ग के बदल रहा है और, ऑब्जेक्ट का प्रकार सत्यापित करें जब एक नया उदाहरण बन जाता है के बारे में सोच रहा था। यदि वस्तु सुपर क्लास से संबंधित है तो एक त्रुटि उठाएं। हालांकि, मुझे यकीन नहीं है कि यह करने का पाइथोनिक तरीका है या नहीं।

कोई सिफारिशें?

Answer 1

आप सार बेस क्लासेस के बारे में बात कर रहे हैं, और पायथन भाषा उन्हें मूल रूप से समर्थन नहीं देती है।

हालांकि, मानक पुस्तकालय में, एक मॉड्यूल है जिसका उपयोग आप सहायता के लिए कर सकते हैं। abc दस्तावेज़ीकरण देखें।

Answer 2

आपका दृष्टिकोण एक विशिष्ट framework pattern है।

type(self) is not SuperClass सत्यापित करने के लिए __init__ का उपयोग करना यह सुनिश्चित करने का एक उचित तरीका है कि सुपर क्लास को तुरंत चालू नहीं किया गया है।

अन्य आम दृष्टिकोण स्टब विधियों को प्रदान करना है जो raise NotImplementedError कहलाते हैं। यह अधिक विश्वसनीय है क्योंकि यह भी मान्य करता है कि उप-वर्गों ने अपेक्षित तरीकों को ओवरराइड कर दिया है।

Answer 3

यह मैं क्या कर सकता है:

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 

जब रन (अपवाद फेंक दिया जाता है!):

[ 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. 

---

(टिप्पणियों से) संपादित करें:

[ 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()" 

प्रिंट:

[ 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

मैं बेस क्लास में __new__() ओवरराइड कर दूंगा और बेस क्लास होने पर बस तत्काल विफल हो जाऊंगा।

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) 

यह चिंताओं एक छोटे से __init__() में यह होने की तुलना में बेहतर अलग करती है, और "तेजी से विफल रहता है।"