मैन्युअल रूप से __class__ सेल भरकर सुपर() काम कैसे करें?

Question

अजगर 3 एक में super() बजाय super(MyClass, self), लेकिन तरीकों में यह केवल काम करता है कि वर्ग के भीतर परिभाषित किया गया उपयोग कर सकते हैं। Michele Simionato's article में बताया गया है कि निम्न उदाहरण काम नहीं करता:

def __init__(self): 
    print('calling __init__') 
    super().__init__() 

class C(object): 
    __init__ = __init__ 

if __name__ == '__main__': 
    c = C() 

यह विफल रहता है क्योंकि super() एक __class__cell, जो इस मामले में निर्धारित नहीं है के लिए लग रहा है।

यह इस सेल मैन्युअल के बाद समारोह परिभाषित किया गया है स्थापित करने के लिए संभव है, या कि असंभव है?

दुर्भाग्य से मुझे समझ नहीं आता कैसे कोशिकाओं को इस संदर्भ में काम करते हैं (उस के लिए बहुत प्रलेखन नहीं मिला)। मैं

__init__.__class_cell_thingy__ = C 

बेशक मैं केवल एक स्थिति है जहाँ क्लास असाइनमेंट स्पष्ट/अद्वितीय (में मेरे मामले में automatized है एक वर्ग के लिए विधियां जोड़ने की पूरी प्रक्रिया है में इस का प्रयोग करेंगे की तरह कुछ के लिए आशा करती हूं कि, इसलिए ऐसी लाइन जोड़ने के लिए यह आसान होगा)।

Answer 1

गंभीरता से: तुम सच में ऐसा करने के लिए नहीं करना चाहती।

लेकिन, यह समझने के लिए पाइथन के उन्नत उपयोगकर्ताओं के लिए उपयोगी है, इसलिए मैं इसे समझाऊंगा।

सेल और फ्रीवर्स बंद होने पर मान दिए गए मान हैं। उदाहरण के लिए,

def f(): 
    a = 1 
    def func(): 
     print(a) 
    return func 

ffunc के आधार पर एक बंद देता है, a के लिए एक संदर्भ के संचय। वह संदर्भ एक सेल में संग्रहीत होता है (वास्तव में एक फ्रीवर में, लेकिन जो कार्यान्वयन तक है)। आप इस की जांच कर सकते हैं:।।।

myfunc = f() 
# ('a',) 
print(myfunc.__code__.co_freevars) 
# (<cell at 0xb7abce84: int object at 0x82b1de0>,) 
print(myfunc.__closure__) 

("सेल" और "freevars" बहुत समान हैं Freevars नाम, जहां कोशिकाओं अनुक्रमित है है वे दोनों func.__closure__ में जमा हो जाती है, कोशिकाओं पहले आने के साथ कर रहे हैं हम केवल बारे में परवाह यहाँ freevars, के बाद से है कि क्या __class__ है।)

एक बार जब आप इसे समझ लेंगे, तो आप देख सकते हैं कि सुपर() वास्तव में कैसे काम करता है। किसी भी समारोह को बंद करने में शामिल है कि super के लिए एक कॉल वास्तव में है, __class__ नाम के एक freevar साथ (जो भी करता है, तो आप __class__ अपने आप का उल्लेख जोड़ा जाता है):

class foo: 
    def bar(self): 
     print(__class__) 

(चेतावनी:। यह वह जगह है जहां चीजें बुराई मिल)

ये कक्ष func.__closure__ में दिखाई दे रहे हैं, लेकिन यह केवल पढ़ने के लिए है; आप इसे बदल नहीं सकते इसे बदलने का एकमात्र तरीका एक नया फ़ंक्शन बनाना है, जो types.FunctionType कन्स्ट्रक्टर के साथ किया जाता है। हालांकि, आपके __init__ फ़ंक्शन में __class__ फ्रीवर नहीं है - इसलिए हमें एक को जोड़ने की आवश्यकता है। इसका मतलब है कि हमें एक नया कोड ऑब्जेक्ट भी बनाना है।

नीचे कोड यह करता है। मैंने प्रदर्शन उद्देश्यों के लिए बेस क्लास B जोड़ा। यह कोड कुछ धारणाएं बनाता है, उदाहरण के लिए। कि __init__ में पहले से ही एक फ्री वैरिएबल नहीं है जिसका नाम __class__ है।

यहां एक और हैक है: सेल प्रकार के लिए एक कन्स्ट्रक्टर प्रतीत नहीं होता है। इसके आसपास काम करने के लिए, एक डमी फ़ंक्शन C.dummy बनाया गया है जिसमें सेल वैरिएबल की आवश्यकता है।

import types 

class B(object): 
    def __init__(self): 
     print("base") 

class C(B): 
    def dummy(self): __class__ 

def __init__(self): 
    print('calling __init__') 
    super().__init__() 

def MakeCodeObjectWithClass(c): 
    """ 
    Return a copy of the code object c, with __class__ added to the end 
    of co_freevars. 
    """ 
    return types.CodeType(c.co_argcount, c.co_kwonlyargcount, c.co_nlocals, 
      c.co_stacksize, c.co_flags, c.co_code, c.co_consts, c.co_names, 
      c.co_varnames, c.co_filename, c.co_name, c.co_firstlineno, 
      c.co_lnotab, c.co_freevars + ('__class__',), c.co_cellvars) 

new_code = MakeCodeObjectWithClass(__init__.__code__) 
old_closure = __init__.__closure__ or() 
C.__init__ = types.FunctionType(new_code, globals(), __init__.__name__, 
    __init__.__defaults__, old_closure + (C.dummy.__closure__[0],)) 

if __name__ == '__main__': 
    c = C() 

Answer 2

हो सकता है, लेकिन क्या तुम करोगी द्वारा? दोनों मामलों में आपको किसी भी तरह से स्पष्ट होना चाहिए कि यह कौन सी कक्षा है, क्योंकि अंतर्निहित तरीका काम नहीं करता है। शायद आप सेल को किसी भी तरह से सेट कर सकते हैं, लेकिन ऐसा करने का कोई कारण नहीं है। बस पैरामीटर में स्पष्ट रूप से पास करें।

def __init__(self): 
    print('calling __init__') 
    super(self.__class__, self).__init__() 

class C(object): 
    __init__ = __init__ 

if __name__ == '__main__': 
    c = C() 

(यह बेहतर है तुम इतनी तरह सीधे वास्तविक कक्षा में पारित कर सकते हैं,:

def __init__(self): 
    print('calling __init__') 
    super(C, self).__init__() 

class C(object): 
    __init__ = __init__ 

if __name__ == '__main__': 
    c = C() 

लेकिन अगर आप, आप C पर __init__ सीधे डाल सकता है सकते हैं, तो आप मान सकते हैं ' टी।

Answer 3

आप समारोह के शब्दकोश का उपयोग कर सकते हैं।

def f(self): 
    super(f.owner_cls, self).f() 
    print("B") 

def add_to_class(cls, member, name=None): 
    if hasattr(member, 'owner_cls'): 
     raise ValueError("%r already added to class %r" % (member, member.owner_cls)) 
    member.owner_cls = cls 
    if name is None: 
     name = member.__name__ 
    setattr(cls, name, member) 

class A: 
    def f(self): 
     print("A") 

class B(A): 
    pass 

add_to_class(B, f) 

B().f() 

यदि आप फ़ंक्शन के अंदर सदस्य के नाम का नाम हार्डकोड नहीं करना चाहते हैं तो आप एक और विशेषता member_name भी जोड़ सकते हैं।