मैंने इस प्रश्न के लिए एक अन्य उत्तर से एक अच्छे विचार के आधार पर, अपने भीतर के वर्ग से एक बाहरी वर्ग का उपयोग करने के लिए कुछ पायथन कोड बनाया है । मुझे लगता है कि यह छोटा, सरल और समझने में आसान है।
class higher_level__unknown_irrelevant_name__class:
def __init__(self, ...args...):
...other code...
# Important lines to access sub-classes.
subclasses = self._subclass_container()
self.some_subclass = subclasses["some_subclass"]
del subclasses # Free up variable for other use.
def sub_function(self, ...args...):
...other code...
def _subclass_container(self):
_parent_class = self # Create access to parent class.
class some_subclass:
def __init__(self):
self._parent_class = _parent_class # Easy access from self.
# Optional line, clears variable space, but SHOULD NOT BE USED
# IF THERE ARE MULTIPLE SUBCLASSES as would stop their parent access.
# del _parent_class
class subclass_2:
def __init__(self):
self._parent_class = _parent_class
# Return reference(s) to the subclass(es).
return {"some_subclass": some_subclass, "subclass_2": subclass_2}
मुख्य कोड, "प्रोडक्शन रेडी" (टिप्पणियों के बिना, आदि)। <x>वांछित मान के साथ कोण कोष्ठक (जैसे ) में प्रत्येक मान को प्रतिस्थापित करना याद रखें ।
class <higher_level_class>:
def __init__(self):
subclasses = self._subclass_container()
self.<sub_class> = subclasses[<sub_class, type string>]
del subclasses
def _subclass_container(self):
_parent_class = self
class <sub_class>:
def __init__(self):
self._parent_class = _parent_class
return {<sub_class, type string>: <sub_class>}
यह विधि कैसे काम करती है इसका स्पष्टीकरण (मूल चरण):
_subclass_containerचर तक पहुंचने के लिए आवरण के रूप में कार्य करने के लिए नामित फ़ंक्शन बनाएं self, उच्च स्तरीय वर्ग (फ़ंक्शन के अंदर चलने वाले कोड से) के लिए एक संदर्भ।
एक चर बनाएं जिसका नाम इस फ़ंक्शन _parent_classके चर selfके लिए एक संदर्भ है , जो उप-वर्गों _subclass_containerतक पहुंच सकता है ( selfउपवर्गों में अन्य चर के साथ नाम के टकराव से बचा जाता है )।
उप-वर्ग / उप-वर्गों को एक शब्दकोश / सूची के रूप में लौटाएं ताकि _subclass_containerफ़ंक्शन को कॉल करने वाला कोड उप-कक्षाओं तक पहुंच सके।
__init__उच्च स्तर वर्ग (या जहाँ कहीं भी आवश्यकता होती है) के अंदर फ़ंक्शन में, फ़ंक्शन से लौटे हुए उप-वर्गों _subclass_containerको चर में प्राप्त करते हैं subclasses।
subclassesउच्च स्तरीय वर्ग की विशेषताओं के लिए चर में संग्रहीत उप-वर्गों को असाइन करें ।
परिदृश्यों को आसान बनाने के लिए कुछ सुझाव:
उप-कक्षाओं को उच्च स्तर की कक्षा में असाइन करने के लिए कोड बनाना आसान है और उच्च स्तर की कक्षा से प्राप्त कक्षाओं में उपयोग किया जा सकता है जो आपके __init__ कार्य की सूची है:
मुख्य कोड में लाइन 12 से पहले डालें:
def _subclass_init(self):
फिर इस फ़ंक्शन लाइनों में 5-6 (मुख्य कोड का) डालें और लाइनों को निम्नलिखित कोड से प्रतिस्थापित करें:
self._subclass_init(self)
उपवर्गों के कई / अज्ञात मात्रा में होने पर उपवर्ग को उच्च स्तर की कक्षा में सौंपना संभव बनाता है।
निम्नलिखित कोड के साथ लाइन 6 बदलें:
for subclass_name in list(subclasses.keys()):
setattr(self, subclass_name, subclasses[subclass_name])
उदाहरण का परिदृश्य जहां यह समाधान उपयोगी होगा और जहां उच्च स्तर के वर्ग का नाम प्राप्त करना असंभव होना चाहिए:
एक वर्ग, जिसका नाम "ए" ( class a:) बनाया गया है। इसमें उपवर्ग होते हैं जिन्हें इसे (अभिभावक) तक पहुँचाने की आवश्यकता होती है। एक उपवर्ग को "X1" कहा जाता है। इस उपवर्ग में, कोड a.run_func()चलाया जाता है।
फिर एक और वर्ग, नाम "ख" बनाया जाता है, व्युत्पन्न वर्ग से "एक" ( class b(a):)। उसके बाद, कुछ कोड चलता है b.x1()(बी, एक व्युत्पन्न उप-वर्ग के उप फ़ंक्शन "एक्स 1" को कॉल करके)। इस समारोह रन a.run_func(), समारोह वर्ग के "run_func" "एक", बुला नहीं , (एकदम सही ढंग से) समारोह उसकी पेरेंट "run_func", "बी" क्योंकि समारोह कौन सी क्लास में परिभाषित किया गया था "एक" सेट कर दिया जाता उल्लेख करने के लिए कक्षा "ए" के कार्य के रूप में, इसके माता-पिता थे।
इससे समस्याएँ उत्पन्न होंगी (जैसे कि यदि फ़ंक्शन a.run_funcको हटा दिया गया है) और कक्षा में कोड को फिर से लिखने के बिना एकमात्र समाधान "क्लास" से प्राप्त सभी वर्गों के लिए अद्यतन कोड के साथ a.x1उप-वर्ग को फिर से परिभाषित x1करना होगा जो स्पष्ट रूप से मुश्किल होगा और लायक नहीं होगा। यह।