पायथन में, मैं सुपर क्लास को कैसे कॉल करूं जब यह एक-ऑफ नामित है?

Question

तो, मेरे पास सीरियल एपीआई के लिए बड़ी संख्या में संदेश पेलोड कक्षाएं हैं, जिनमें से प्रत्येक में कई अपरिवर्तनीय फ़ील्ड, एक पार्स विधि और साझा की जाने वाली कुछ विधियां हैं। जिस तरह से मैं इसे संरचित कर रहा हूं वह यह है कि प्रत्येक क्षेत्र के व्यवहार के लिए नामांकित से उत्तराधिकारी होगा, और माता-पिता वर्ग से सामान्य तरीकों को प्राप्त करेगा। हालांकि, मैं कंस्ट्रक्टर्स के साथ कुछ कठिनाइयां आ रही हूँ:

class Payload: 
    def test(self): 
     print("bar") 

class DifferentialSpeed(Payload, namedtuple('DifferentialSpeed_', 
    'left_speed right_speed left_accel right_accel')): 
    __slots__ =() 
    def __init__(self, **kwargs): 
     super(DifferentialSpeed, self).__init__(**kwargs) 
     # TODO: Field verification 
     print("foo") 

    @classmethod 
    def parse(self, raw): 
     # Dummy for now 
     return self(left_speed = 0.0, right_speed = 0.1, 
        left_accel = 0.2, right_accel = 0.3) 

    def __str__(self): 
     return "Left Speed: %fm/s\nRight Speed: %fm/s\n"\ 
      "Left Acceleration: %fm/s^2\nRight Acceleration: %fm/s^2" % (
      self.left_speed, self.right_speed, self.left_accel, self.right_accel) 


payload = DifferentialSpeed.parse('dummy') 
print(payload) 

यह काम करता है, लेकिन मैं निम्नलिखित चेतावनी मिलती है: यदि मैं कॉल से **kwargs हटाने

DeprecationWarning: object.__init__() takes no parameters 
    super(DifferentialSpeed, self).__init__(**kwargs) 

, यह अभी भी काम करने के लिए लगता है, लेकिन क्यों? कन्स्ट्रक्टर को नामांकित करने के लिए उन तर्कों को कैसे पारित किया जा रहा है? क्या यह गारंटी है, या mro कैसे स्थापित किया गया है इसका यादृच्छिक परिणाम है?

अगर मैं सुपर से दूर रहना चाहता हूं, और इसे पुराना तरीका करना चाहता हूं, तो क्या मैं अपने कन्स्ट्रक्टर को कॉल करने के लिए नामांकित तक पहुंच सकता हूं? मुझे यह करने की ज़रूरत नहीं है:

DifferentialSpeed_ = namedtuple('DifferentialSpeed_', 
    'left_speed right_speed left_accel right_accel') 
class DifferentialSpeed(Payload, DifferentialSpeed_): 

वर्बोज़ और अनावश्यक लगता है।

यहां मेरा सबसे अच्छा तरीका क्या है? क्योंकि समय __init__ द्वारा वस्तु पहले से ही निर्माण किया है कहा जाता है

Answer 1

शुरुआत के लिए, tuple से namedtuple(whatever) इनहेरिट करती है, जो अपरिवर्तनीय है, और अपरिवर्तनीय प्रकार, __init__ से परेशान नहीं है। यदि आप namedtuple बेस क्लास में तर्क पारित करना चाहते हैं तो आपको इसके बजाय __new__ ओवरराइड करना होगा।

verbose=true तर्क में गुजरकर आप namedtuple() के परिणाम की परिभाषा देख सकते हैं; मुझे यह शैक्षिक लगता है।

Answer 2

आपके पास तीन आधार वर्ग हैं: Payload, आपके नामांकित DifferentialSpeed_, और सामान्य आधार वर्ग object। पहले दो में से कोई भी __init__ फ़ंक्शन बिल्कुल नहीं है, जिसे object से विरासत में मिला है। namedtuple को __init__ की आवश्यकता नहीं है, क्योंकि अपरिवर्तनीय कक्षाओं की शुरुआत __new__ द्वारा की जाती है, जिसे __init__ से पहले कहा जाता है।

super(DifferentialSpeed, self).__init__ के बाद से अगले __init__ कॉल श्रृंखला में ले कर जाता है, अगले __init__ जिसका मतलब है कि आपको लगता है कि कार्य करने के लिए तर्क दे रहे object.__init__ है। यह किसी की अपेक्षा नहीं करता है - object.__init__ पर तर्क पारित करने का कोई कारण नहीं है।

(यह स्वीकार करने के लिए और चुपचाप तर्क की उपेक्षा का इस्तेमाल किया है कि व्यवहार दूर जा रहा है -। जिसके कारण आप एक DeprecationWarning मिलता है - यह अजगर 3 में चला गया।) जोड़कर

आप समस्या को गति प्रदान कर सकते हैं और अधिक स्पष्ट रूप एक Payload.__init__ फ़ंक्शन जो कोई तर्क नहीं लेता है। जब आप `* kwargs के साथ पास करने का प्रयास करते हैं, तो यह एक त्रुटि उठाएगा।

इस मामले में करने के लिए सही चीज लगभग **kwargs तर्क को हटाने के लिए निश्चित रूप से है, और बस super(DifferentialSpeed, self).__init__() पर कॉल करें।यह कोई तर्क नहीं लेता है; DifferentialSpeedPayload गुजर रहा है अपने तर्क Payload, और कॉल श्रृंखला के आगे कार्य करता है, इसके बारे में कुछ भी नहीं पता है।

Answer 3

जैसा कि अन्य ने इंगित किया है, टुपल्स एक अपरिवर्तनीय प्रकार हैं, जिन्हें उनके विधि के बजाय __new__() में प्रारंभ किया जाना चाहिए - इसलिए आपको अपने उप-वर्ग (और बाद वाले से छुटकारा पाने) में पूर्व को जोड़ना होगा। नीचे यह है कि यह आपके उदाहरण कोड पर कैसे लागू होगा। एकमात्र अन्य परिवर्तन शुरुआत में from import... कथन जोड़ रहा था।

नोट:cls क्योंकि यह एक स्थिर विधि है, हालांकि यह विशेष मामलों ताकि आप इसे घोषित करने के लिए एक होने की जरूरत नहीं है है __new__() में super() कॉल में दो बार पारित कर दिया जाना चाहिए।

from collections import namedtuple 

class Payload: 
    def test(self): 
     print("bar") 

class DifferentialSpeed(Payload, namedtuple('DifferentialSpeed_', 
    'left_speed right_speed left_accel right_accel')): 
    #### NOTE: __new__ instead of an __init__ method #### 
    def __new__(cls, **kwargs): 
     self = super(DifferentialSpeed, cls).__new__(cls, **kwargs) 
     # TODO: Field verification 
     print("foo") 
     return self 

    @classmethod 
    def parse(self, raw): 
     # Dummy for now 
     return self(left_speed = 0.0, right_speed = 0.1, 
        left_accel = 0.2, right_accel = 0.3) 

    def __str__(self): 
     return "Left Speed: %fm/s\nRight Speed: %fm/s\n"\ 
      "Left Acceleration: %fm/s^2\nRight Acceleration: %fm/s^2" % (
      self.left_speed, self.right_speed, self.left_accel, self.right_accel) 


payload = DifferentialSpeed.parse('dummy') 
print(payload)