👨🏼‍🍳 🕍 🆕 पायथन: उत्पादन में मेटाप्रोग्रामिंग। एक भाग 🧕🏾 💇🏿 🆑

बहुत से लोग सोचते हैं कि पायथन में मेटाप्रोग्रामिंग अनावश्यक रूप से कोड को जटिल करता है, लेकिन यदि आप इसे सही तरीके से उपयोग करते हैं, तो आप जटिल डिजाइन पैटर्न को जल्दी और सुरुचिपूर्ण ढंग से लागू कर सकते हैं। इसके अलावा, जाने-माने पायथन फ्रेमवर्क जैसे कि Django, DRF, और SQLAlchemy मेटासेक्लेस का उपयोग करते हैं ताकि आसान एक्स्टेंसिबिलिटी और आसान कोड का पुन: उपयोग किया जा सके।

इस लेख में मैं आपको बताऊंगा कि आपको अपनी परियोजनाओं में मेटाप्रोग्रामिंग का उपयोग करने से क्यों नहीं डरना चाहिए और यह बताना चाहिए कि यह किन कार्यों के लिए सबसे उपयुक्त है। आप उन्नत पायथन कोर्स में मेटाप्रोग्रामिंग विकल्पों के बारे में अधिक जान सकते हैं।

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

पायथन डेटा मॉडल का एक त्वरित दौरा

इसलिए, हम सभी जानते हैं कि पायथन में सब कुछ एक वस्तु है, और यह कोई रहस्य नहीं है कि प्रत्येक वस्तु के लिए एक निश्चित वर्ग है जिसके द्वारा इसे उत्पन्न किया गया था, उदाहरण के लिए:

>>> def f(): pass >>> type(f) <class 'function'>

ऑब्जेक्ट का प्रकार या वर्ग जिसके द्वारा ऑब्जेक्ट उत्पन्न किया गया था, वह अंतर्निहित प्रकार फ़ंक्शन का उपयोग करके निर्धारित किया जा सकता है, जिसमें एक दिलचस्प कॉल हस्ताक्षर है (हम इसके बारे में थोड़ी देर बाद बात करेंगे)। किसी भी वस्तु पर __class__ विशेषता प्राप्त करने से एक ही प्रभाव प्राप्त किया जा सकता है।

इसलिए, फ़ंक्शन बनाने के लिए, एक निश्चित अंतर्निहित क्लास function । आइए देखें कि हम इसके साथ क्या कर सकते हैं। ऐसा करने के लिए, बिल्ट-इन प्रकार मॉड्यूल से रिक्त स्थान लें:

 >>> from types import FunctionType >>> FunctionType <class 'function'> >>> help(FunctionType) class function(object) | function(code, globals[, name[, argdefs[, closure]]]) | | Create a function object from a code object and a dictionary. | The optional name string overrides the name from the code object. | The optional argdefs tuple specifies the default argument values. | The optional closure tuple supplies the bindings for free variables.

जैसा कि हम देख सकते हैं, पायथन में कोई भी फ़ंक्शन ऊपर वर्णित कक्षा का एक उदाहरण है। आइए अब डिफ के माध्यम से अपनी घोषणा का सहारा लिए बिना एक नया फ़ंक्शन बनाने का प्रयास करें। ऐसा करने के लिए, हमें यह जानने की ज़रूरत है कि इंटरप्रेटर में निर्मित संकलन फ़ंक्शन का उपयोग करके कोड ऑब्जेक्ट कैसे बनाए जाएं:

 #   ,    "Hello, world!" >>> code = compile('print("Hello, world!")', '<repl>', 'eval') >>> code <code object <module> at 0xdeadbeef, file "<repl>", line 1> #  ,     , #      >>> func = FunctionType(code, globals(), 'greetings') >>> func <function <module> at 0xcafefeed> >>> func.__name__ 'greetings' >>> func() Hello, world!

बहुत बढ़िया! मेटा-टूल्स की मदद से, हमने सीखा कि फ्लाई पर फ़ंक्शंस कैसे बनाएं, लेकिन व्यवहार में इस तरह के ज्ञान का उपयोग शायद ही कभी किया जाता है। अब आइए नज़र डालते हैं कि इन वर्गों की वस्तुओं और उदाहरणों को किस प्रकार बनाया जाता है:

 >>> class User: pass >>> user = User() >>> type(user) <class '__main__.User'> >>> type(User) <class 'type'>

यह काफी स्पष्ट है कि User वर्ग का उपयोग user का एक उदाहरण बनाने के लिए किया जाता है, यह type वर्ग को देखने के लिए बहुत अधिक दिलचस्प है, जिसका उपयोग User वर्ग को बनाने के लिए किया जाता है। यहां हम अंतर्निहित type फ़ंक्शन को कॉल करने के दूसरे विकल्प की ओर मुड़ेंगे, जो संयोजन में पायथन में किसी भी वर्ग के लिए एक मेटाकाॅल है। एक परिभाषा के अनुसार, एक वर्ग है जिसका उदाहरण एक अन्य वर्ग है। मेटाक्लासेस हमें एक वर्ग बनाने की प्रक्रिया को अनुकूलित करने की अनुमति देता है और एक वर्ग की आवृत्ति बनाने की प्रक्रिया को आंशिक रूप से नियंत्रित करता है।

प्रलेखन के अनुसार, दूसरा हस्ताक्षर type(name, bases, attrs) - एक नया डेटा प्रकार लौटाता है या, यदि एक सरल तरीके से - एक नया वर्ग, और name विशेषता बन जाता है लौटे हुए वर्ग की __name__ विशेषता, bases - मूल वर्गों की सूची __bases__ रूप में उपलब्ध होगी। खैर, attrs - क्लास के सभी विशेषताओं और तरीकों से युक्त एक तानाशाह जैसी वस्तु, __dict__ में __dict__ । समारोह के सिद्धांत को पायथन में एक सरल छद्म कोड के रूप में वर्णित किया जा सकता है:

 type(name, bases, attrs) ~ class name(bases): attrs

आइए देखें कि आप कैसे, केवल type कॉल का उपयोग करके, एक पूरी तरह से नए वर्ग का निर्माण कर सकते हैं:

 >>> User = type('User', (), {}) >>> User <class '__main__.User'>

जैसा कि आप देख सकते हैं, हमें एक नया वर्ग बनाने के लिए class कीवर्ड का उपयोग करने की आवश्यकता नहीं है, type फ़ंक्शन इसके बिना करता है, अब एक उदाहरण को और अधिक जटिल देखें:

 class User: def __init__(self, name): self.name = name class SuperUser(User): """Encapsulate domain logic to work with super users""" group_name = 'admin' @property def login(self): return f'{self.group_name}/{self.name}'.lower() #     SuperUser "" CustomSuperUser = type( #   'SuperUser', #  ,      (User, ), #         { '__doc__': 'Encapsulate domain logic to work with super users', 'group_name': 'admin', 'login': property(lambda self: f'{self.group_name}/{self.name}'.lower()), } ) assert SuperUser.__doc__ == CustomSuperUser.__doc__ assert SuperUser('Vladimir').login == CustomSuperUser('Vladimir').login

जैसा कि आप ऊपर के उदाहरणों से देख सकते हैं, कीवर्ड class और def का उपयोग करके कक्षाओं और फ़ंक्शंस का वर्णन केवल वाक्यविन्यास चीनी है और किसी भी प्रकार की वस्तुओं को साधारण कॉल द्वारा निर्मित कार्यों में बनाया जा सकता है। और अब, अंत में, आइए इस बारे में बात करें कि आप वास्तविक परियोजनाओं में कक्षाओं के गतिशील निर्माण का उपयोग कैसे कर सकते हैं।

औपचारिक रूप से प्रपत्र और सत्यापनकर्ता बनाएं

कभी-कभी हमें पहले से ज्ञात डेटा योजना के अनुसार उपयोगकर्ता या अन्य बाहरी स्रोतों से जानकारी को मान्य करने की आवश्यकता होती है। उदाहरण के लिए, हम व्यवस्थापक पैनल से उपयोगकर्ता लॉगिन फ़ॉर्म को बदलना चाहते हैं - हटाएं और फ़ील्ड जोड़ें, उनकी मान्यता की रणनीति बदलें, आदि।

वर्णन करने के लिए, चलिए Django फॉर्म को गतिशील रूप से बनाने की कोशिश करते हैं, जिसकी योजना का विवरण निम्नलिखित json प्रारूप में संग्रहीत है:

 { "fist_name": { "type": "str", "max_length": 25 }, "last_name": { "type": "str", "max_length": 30 }, "age": { "type": "int", "min_value": 18, "max_value": 99 } }

अब, ऊपर दिए गए विवरण के आधार पर, खेतों का एक सेट और एक नया रूप type फ़ंक्शन का उपयोग करके बनाएं जो हम पहले से जानते हैं:

 import json from django import forms fields_type_map = { 'str': forms.CharField, 'int': forms.IntegerField, } # form_description –  json    deserialized_form_description: dict = json.loads(form_description) form_attrs = {} #            for field_name, field_description in deserialized_form_description.items(): field_class = fields_type_map[field_description.pop('type')] form_attrs[field_name] = field_class(**field_description) user_form_class = type('DynamicForm', (forms.Form, ), form_attrs) >>> form = user_form_class({'age': 101}) >>> form <DynamicForm bound=True, valid=Unknown, fields=(fist_name;last_name;age)> >>> form.is_valid() False >>> form.errors {'fist_name': ['This field is required.'], 'last_name': ['This field is required.'], 'age': ['Ensure this value is less than or equal to 99.']}

सुपर! अब आप बनाए गए फॉर्म को टेम्प्लेट में स्थानांतरित कर सकते हैं और इसे उपयोगकर्ता के लिए प्रस्तुत कर सकते हैं। डेटा सत्यापन और प्रस्तुति ( DRF Serializers , marshmallow और अन्य) के लिए एक ही दृष्टिकोण का उपयोग अन्य रूपरेखाओं के साथ किया जा सकता है।

मेटाक्लास के माध्यम से एक नए वर्ग के निर्माण को कॉन्फ़िगर करना

ऊपर, हमने पहले से ही "समाप्त" type मेटाक्लस को देखा, लेकिन कोड में सबसे अधिक बार आप अपने स्वयं के मेटाक्लेसेस बनाएंगे और नए वर्गों और उनके उदाहरणों के निर्माण को कॉन्फ़िगर करने के लिए उनका उपयोग करेंगे। सामान्य स्थिति में, मेटाक्लस का "रिक्त" इस तरह दिखता है:

 class MetaClass(type): """   : mcs –  ,  <__main__.MetaClass> name – ,  ,     ,  "User" bases –   -,  (SomeMixin, AbstractUser) attrs – dict-like ,         cls –  ,  <__main__.User> extra_kwargs –  keyword-     args  kwargs –          """ def __new__(mcs, name, bases, attrs, **extra_kwargs): return super().__new__(mcs, name, bases, attrs) def __init__(cls, name, bases, attrs, **extra_kwargs): super().__init__(cls) @classmethod def __prepare__(mcs, cls, bases, **extra_kwargs): return super().__prepare__(mcs, cls, bases, **kwargs) def __call__(cls, *args, **kwargs): return super().__call__(*args, **kwargs)

User वर्ग को कॉन्फ़िगर करने के लिए इस मेटाक्लस का उपयोग करने के लिए, निम्नलिखित सिंटैक्स का उपयोग किया जाता है:

 class User(metaclass=MetaClass): def __new__(cls, name): return super().__new__(cls) def __init__(self, name): self.name = name

सबसे दिलचस्प बात यह है कि वह क्रम जिसमें पायथन दुभाषिया मेटाक्लास मेटामेथोड को उस समय बुलाता है जब कक्षा खुद बनाई जाती है:

दुभाषिया वर्तमान कक्षा (यदि कोई हो) के लिए मूल कक्षाएं निर्धारित करता है और पाता है।
दुभाषिया एक MetaClass (हमारे मामले में MetaClass ) को परिभाषित करता है।
MetaClass.__prepare__ विधि को MetaClass.__prepare__ - इसे एक MetaClass.__prepare__ जैसी वस्तु को वापस करना चाहिए जिसमें कक्षा की विशेषताओं और विधियों को लिखा जाएगा। उसके बाद, ऑब्जेक्ट को MetaClass.__new__ से MetaClass.__new__ तर्क के माध्यम से पास किया जाएगा। हम इस पद्धति के व्यावहारिक उपयोग के बारे में उदाहरणों में थोड़ी देर बाद बात करेंगे।
दुभाषिया User वर्ग के शरीर को पढ़ता है और MetaClass उन्हें पारित करने के लिए पैरामीटर उत्पन्न करता है।
MetaClass.__new__ विधि को MetaClass.__new__ - MetaClass.__new__ विधि, निर्मित वर्ग वस्तु को लौटाता है। जब हम उन्हें type फंक्शन में पास करते हैं तो हम पहले से ही तर्कों, name और bases साथ मिलते हैं, और हम **extra_kwargs पैरामीटर के बारे में थोड़ी देर बाद बात करेंगे। यदि __prepare__ तर्क का प्रकार __prepare__ का उपयोग करके बदल दिया गया था, तो इसे super() विधि कॉल में पास करने से पहले इसे एक __prepare__ परिवर्तित किया जाना चाहिए।
MetaClass.__init__ विधि को MetaClass.__init__ - प्रारंभिक विधि जिसके साथ आप कक्षा में क्लास ऑब्जेक्ट में अतिरिक्त विशेषताओं और विधियों को जोड़ सकते हैं। व्यवहार में, इसका उपयोग उन मामलों में किया जाता है जहां मेटाक्लास अन्य मेटाक्लासेस से विरासत में मिला है, अन्यथा __init__ में जो कुछ भी किया जा सकता है वह __new__ में बेहतर है। उदाहरण के लिए, __slots__ पैरामीटर को केवल __new__ पद्धति में सेट किया जा सकता है, इसे __new__ ऑब्जेक्ट पर लिखकर।
इस कदम पर, वर्ग का निर्माण माना जाता है।

अब हमारे User वर्ग का एक उदाहरण बनाएं और कॉल श्रृंखला देखें:

 user = User(name='Alyosha')

User(...) को कॉल करने के समय User(...) दुभाषिया MetaClass.__call__(name='Alyosha') विधि को कॉल करता है, जहां यह क्लास ऑब्जेक्ट और तर्कों को पारित करता है।
MetaClass.__call__ कॉल User.__new__(name='Alyosha') MetaClass.__call__ User.__new__(name='Alyosha') - एक निर्माण विधि है जो User वर्ग का एक उदाहरण बनाता है और रिटर्न करता है
इसके बाद, MetaClass.__call__ कॉल User.__init__(name='Alyosha') MetaClass.__call__ User.__init__(name='Alyosha') - एक इनिशियलाइज़र विधि जो बनाए गए उदाहरण में नई विशेषताएँ जोड़ती है।
MetaClass.__call__ User वर्ग का बनाया और आरंभिक उदाहरण देता है।
इस बिंदु पर, वर्ग का एक उदाहरण बनाया जाता है।

यह विवरण, निश्चित रूप से, मेटाक्लासेस का उपयोग करने की सभी बारीकियों को कवर नहीं करता है, लेकिन कुछ वास्तुशिल्प पैटर्न को लागू करने के लिए मेटाप्रोग्रामिंग का उपयोग करना शुरू करने के लिए पर्याप्त है। उदाहरण के लिए आगे!

सार वर्ग

और बहुत पहला उदाहरण मानक पुस्तकालय में पाया जा सकता है: एबीसीमेटा - एक मेटाक्लास आपको हमारे किसी भी वर्ग के सार को घोषित करने और उसके सभी वंशों को पूर्वनिर्धारित तरीकों, गुणों और विशेषताओं को लागू करने के लिए मजबूर करने की अनुमति देता है, इसलिए देखें:

 from abc import ABCMeta, abstractmethod class BasePlugin(metaclass=ABCMeta): """   supported_formats   run        """ @property @abstractmethod def supported_formats(self) -> list: pass @abstractmethod def run(self, input_data: dict): pass

यदि वारिस में सभी अमूर्त विधियां और विशेषताएं लागू नहीं की जाती हैं, तो जब हम वारिस वर्ग का एक उदाहरण बनाने की कोशिश करते हैं, तो हमें एक TypeError मिलता है:

 class VideoPlugin(BasePlugin): def run(self): print('Processing video...') plugin = VideoPlugin() # TypeError: Can't instantiate abstract class VideoPlugin # with abstract methods supported_formats

अमूर्त कक्षाओं का उपयोग बेस क्लास इंटरफ़ेस को तुरंत ठीक करने में मदद करता है और भविष्य की विरासत की त्रुटियों से बचने के लिए, उदाहरण के लिए ओवरडोज्ड विधि के नाम पर टाइपो।

स्वचालित पंजीकरण प्लगइन प्रणाली

अक्सर, मेटाप्रोग्रामिंग का उपयोग विभिन्न डिज़ाइन पैटर्न को लागू करने के लिए किया जाता है। रजिस्ट्री वस्तुओं को बनाने के लिए लगभग कोई भी प्रसिद्ध ढांचा मेटाक्लस का उपयोग करता है। ऐसी वस्तुएं अन्य वस्तुओं के लिंक को संग्रहीत करती हैं और उन्हें कार्यक्रम में कहीं भी जल्दी से प्राप्त करने की अनुमति देती हैं। विभिन्न प्रारूपों के मीडिया फ़ाइलों को चलाने के लिए प्लगइन्स के ऑटो-पंजीकरण के एक सरल उदाहरण पर विचार करें।

मेटाक्लोजर कार्यान्वयन:

 class RegistryMeta(ABCMeta): """ ,      .     " " -> " " """ _registry_formats = {} def __new__(mcs, name, bases, attrs): cls: 'BasePlugin' = super().__new__(mcs, name, bases, attrs) #     (BasePlugin) if inspect.isabstract(cls): return cls for media_format in cls.supported_formats: if media_format in mcs._registry_formats: raise ValueError(f'Format {media_format} is already registered') #       mcs._registry_formats[media_format] = cls return cls @classmethod def get_plugin(mcs, media_format: str): try: return mcs._registry_formats[media_format] except KeyError: raise RuntimeError(f'Plugin is not defined for {media_format}') @classmethod def show_registry(mcs): from pprint import pprint pprint(mcs._registry_formats)

और यहाँ स्वयं प्लगइन्स हैं, हम पिछले उदाहरण से BasePlugin कार्यान्वयन को लेंगे:

 class BasePlugin(metaclass=RegistryMeta): ... class VideoPlugin(BasePlugin): supported_formats = ['mpg', 'mov'] def run(self): ... class AudioPlugin(BasePlugin): supported_formats = ['mp3', 'flac'] def run(self): ...

इस कोड को निष्पादित करने के बाद, दुभाषिया हमारी रजिस्ट्री में 4 प्रारूप और 2 प्लग इन को पंजीकृत करेगा जो इन प्रारूपों को संसाधित कर सकता है:

 >>> RegistryMeta.show_registry() {'flac': <class '__main__.AudioPlugin'>, 'mov': <class '__main__.VideoPlugin'>, 'mp3': <class '__main__.AudioPlugin'>, 'mpg': <class '__main__.VideoPlugin'>} >>> plugin_class = RegistryMeta.get_plugin('mov') >>> plugin_class <class '__main__.VideoPlugin'> >>> plugin_class().run() Processing video...

यह मेटाक्लासेस के साथ काम करने की एक और दिलचस्प बारीकियों पर ध्यान देने योग्य है, गैर-स्पष्ट विधि संकल्प क्रम के लिए धन्यवाद, हम न केवल RegistyMeta वर्ग पर show_registry पद्धति को कॉल कर सकते हैं, बल्कि किसी भी अन्य वर्ग पर यह RegistyMeta :

 >>> AudioPlugin.get_plugin('avi') # RuntimeError: Plugin is not found for avi

मेटाडेटा के रूप में विशेषता नामों का उपयोग करना

मेटाक्लास का उपयोग करते हुए, आप अन्य वस्तुओं के लिए मेटाडेटा के रूप में वर्ग विशेषता नामों का उपयोग कर सकते हैं। कुछ भी स्पष्ट नहीं है? लेकिन मुझे यकीन है कि आपने पहले ही इस दृष्टिकोण को कई बार देखा है, उदाहरण के लिए, Django में मॉडल फ़ील्ड की घोषणात्मक घोषणा:

 class Book(models.Model): title = models.Charfield(max_length=250)

उपरोक्त उदाहरण में, title पायथन पहचानकर्ता का नाम है, इसका उपयोग book तालिका में कॉलम का नाम देने के लिए भी किया जाता है, हालांकि हमने स्पष्ट रूप से कहीं भी यह संकेत नहीं दिया है। हाँ, इस तरह के "जादू" को मेटाप्रोग्रामिंग की मदद से महसूस किया जा सकता है। उदाहरण के लिए, एप्लिकेशन त्रुटियों को फ्रंट-एंड पर प्रसारित करने के लिए एक प्रणाली लागू करें, ताकि प्रत्येक संदेश में एक पठनीय कोड हो, जिसका उपयोग संदेश को दूसरी भाषा में अनुवाद करने के लिए किया जा सके। तो, हमारे पास एक संदेश ऑब्जेक्ट है जिसे json बदला जा सकता है:

 class Message: def __init__(self, text, code=None): self.text = text self.code = code def to_json(self): return json.dumps({'text': self.text, 'code': self.code})

हमारे सभी त्रुटि संदेश एक अलग "नेमस्पेस" में संग्रहीत किए जाएंगे:

 class Messages: not_found = Message('Resource not found') bad_request = Message('Request body is invalid') ... >>> Messages.not_found.to_json() {"text": "Resource not found", "code": null}

अब हम चाहते हैं कि code null नहीं, बल्कि not_found , इसके लिए हम निम्नलिखित not_found लिखते हैं:

 class MetaMessage(type): def __new__(mcs, name, bases, attrs): for attr, value in attrs.items(): #          Message #    code    # ( code   ) if isinstance(value, Message) and value.code is None: value.code = attr return super().__new__(mcs, name, bases, attrs) class Messages(metaclass=MetaMessage): ...

आइए देखें कि हमारी पोस्ट अब कैसी दिखती हैं:

 >>> Messages.not_found.to_json() {"text": "Resource not found", "code": "not_found"} >>> Messages.bad_request.to_json() {"text": "Request body is invalid", "code": "bad_request"}

आपको क्या चाहिए! अब आप जानते हैं कि ऐसा क्या करना है कि डेटा प्रारूप से आप आसानी से उस कोड को पा सकते हैं जो उन्हें संसाधित करता है।

एक वर्ग और उसके वंश के बारे में मेटाडेटा को कैशिंग

एक अन्य सामान्य मामला वर्ग निर्माण के चरण में किसी भी स्थैतिक डेटा को कैशिंग कर रहा है, ताकि एप्लिकेशन को चालू करते समय इसकी गणना करने में समय बर्बाद न करें। इसके अलावा, वर्गों के नए उदाहरण बनाते समय कुछ डेटा को अपडेट किया जा सकता है, उदाहरण के लिए, बनाई गई वस्तुओं की संख्या का एक काउंटर।

इसका उपयोग कैसे किया जा सकता है? मान लीजिए कि आप रिपोर्ट और तालिकाओं के निर्माण के लिए एक रूपरेखा विकसित कर रहे हैं और आपके पास ऐसी कोई वस्तु है:

 class Row(metaclass=MetaRow): name: str age: int ... def __init__(self, **kwargs): self.counter = None for attr, value in kwargs.items(): setattr(self, attr, value) def __str__(self): out = [self.counter] #  __header__      for name in self.__header__[1:]: out.append(getattr(self, name, 'N/A')) return ' | '.join(map(str, out))

हम एक नई पंक्ति बनाते समय काउंटर को सहेजना और बढ़ाना चाहते हैं, और परिणामी तालिका के हेडर को पहले से जनरेट करना चाहते हैं। बचाव के लिए मेटासेल्स!

 class MetaRow(type): #      row_count = 0 def __new__(mcs, name, bases, attrs): cls = super().__new__(mcs, name, bases, attrs) #          cls.__header__ = ['№'] + sorted(attrs['__annotations__'].keys()) return cls def __call__(cls, *args, **kwargs): #      row: 'Row' = super().__call__(*args, **kwargs) #    cls.row_count += 1 #     row.counter = cls.row_count return row

यहां दो बातें स्पष्ट करने की आवश्यकता है:

Row वर्ग में name और age के नाम के साथ वर्ग गुण नहीं हैं - ये प्रकार एनोटेशन हैं , इसलिए वे attrs शब्दकोश कुंजियों में नहीं हैं, और फ़ील्ड की सूची प्राप्त करने के लिए, हम __annotations__ वर्ग __annotations__ उपयोग करते हैं।
ऑपरेशन cls.row_count += 1 आपको गुमराह करने वाला था: ऐसा कैसे? आखिरकार, row_count एक Row वर्ग है, इसमें row_count विशेषता नहीं है। सब कुछ सच है, लेकिन जैसा कि मैंने ऊपर बताया है - यदि निर्मित वर्ग में एक विशेषता या विधि नहीं है जिसे वे कॉल करने की कोशिश कर रहे हैं, तो दुभाषिया बेस कक्षाओं की श्रृंखला के साथ आगे बढ़ता है - अगर उनमें से कोई भी नहीं है, तो मेटाफ़्लास में एक खोज की जाती है। ऐसे मामलों में, किसी को भ्रमित न करने के लिए, एक और रिकॉर्ड का उपयोग करना बेहतर होता है: MetaRow.row_count += 1 ।

देखें कि अब आप पूरी तालिका को कितनी भव्यता से प्रदर्शित कर सकते हैं:

 rows = [ Row(name='Valentin', age=25), Row(name='Sergey', age=33), Row(name='Gosha'), ] print(' | '.join(Row.__header__)) for row in rows: print(row)

 № | age | name 1 | 25 | Valentin 2 | 33 | Sergey 3 | N/A | Gosha

वैसे, तालिका के साथ प्रदर्शित करना और काम करना एक अलग Sheet वर्ग में समझाया जा सकता है।

जारी रखने के लिए ...

इस लेख के अगले भाग में , मैं वर्णन करूँगा कि अपने एप्लिकेशन कोड को डिबग करने के लिए __prepare__ का उपयोग कैसे करें, __prepare__ के निर्माण को कैसे __prepare__ , और __prepare__ विधि का उपयोग करने के बुनियादी उदाहरण दिखाएं। देखते रहो!

पायथन में मेटाक्लासेस और डिस्क्रिप्टर के बारे में अधिक विस्तार से मैं उन्नत पायथन के ढांचे में बताऊंगा।

पायथन: उत्पादन में मेटाप्रोग्रामिंग। एक भाग