जैसा कि एक StackOverflow उपयोगकर्ता ने कहा, "SO का उपयोग किसी लिंक की गई सूची के बजाय हैशटेबल के साथ लुकअप करने जैसा है।" हम फिर से इस अद्भुत संसाधन की ओर मुड़ते हैं, जो विभिन्न प्रकार के प्रश्नों के अत्यंत विस्तृत और समझने योग्य उत्तर देता है।

इस बार हम चर्चा करेंगे कि मेटाक्लास क्या हैं, कैसे, कहाँ, और क्यों उनका उपयोग करना है, और क्यों यह आमतौर पर ऐसा करने के लायक नहीं है।

वस्तुओं के रूप में कक्षाएं

इससे पहले कि आप मेटाक्लासेस का अध्ययन करें, आपको कक्षाओं को अच्छी तरह से समझने की आवश्यकता है, और पायथन में कक्षाएं एक बहुत ही विशिष्ट चीज हैं (स्मॉलटॉक भाषा के विचारों पर आधारित)।

अधिकांश भाषाओं में, एक वर्ग कोड का एक टुकड़ा होता है जो बताता है कि ऑब्जेक्ट कैसे बनाया जाए। सामान्य तौर पर, यह पायथन के लिए भी सच है:

>>> class ObjectCreator(object): ... pass ... >>> my_object = ObjectCreator() >>> print my_object <__main__.ObjectCreator object at 0x8974f2c> 

लेकिन पायथन में, एक वर्ग कुछ और है - कक्षाएं भी वस्तुएं हैं।

एक बार class कीवर्ड का उपयोग करने के बाद, पायथन कमांड को निष्पादित करता है और ऑब्जेक्ट बनाता है। निर्देश मैनुअल

  >>> class ObjectCreator(object): ... pass ... 

मेमोरी में एक ऑब्जेक्ट ObjectCreator जिसे ObjectCreator कहा जाता है।

यह ऑब्जेक्ट (क्लास) खुद ऑब्जेक्ट्स (इंस्टेंस) बना सकता है, इसलिए यह एक क्लास है।

हालाँकि, यह एक वस्तु है, और इसलिए:

• यह एक चर को सौंपा जा सकता है,
• इसे कॉपी किया जा सकता है,
• आप इसमें एक विशेषता जोड़ सकते हैं,
• इसे एक तर्क के रूप में कार्य में पारित किया जा सकता है,

गतिशील वर्ग निर्माण

चूंकि कक्षाएं ऑब्जेक्ट हैं, उन्हें किसी भी ऑब्जेक्ट की तरह, चलते-फिरते बनाया जा सकता है।

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

  >>> def choose_class(name): ... if name == 'foo': ... class Foo(object): ... pass ... return Foo #  ,    ... else: ... class Bar(object): ... pass ... return Bar ... >>> MyClass = choose_class('foo') >>> print MyClass #   ,    <class '__main__.Foo'> >>> print MyClass() #      <__main__.Foo object at 0x89c6d4c> 

हालांकि, यह बहुत गतिशील नहीं है, क्योंकि आपको अभी भी पूरी कक्षा को स्वयं लिखने की आवश्यकता है।

चूंकि कक्षाएं ऑब्जेक्ट हैं, इसलिए उन्हें किसी चीज़ से उत्पन्न होना चाहिए।

जब class कीवर्ड का उपयोग किया जाता है, तो पायथन स्वचालित रूप से इस ऑब्जेक्ट को बनाता है। लेकिन पायथन में अधिकांश चीजों की तरह, मैन्युअल रूप से ऐसा करने का एक तरीका है।

type फ़ंक्शन याद रखें? एक अच्छा पुराना फ़ंक्शन जो आपको ऑब्जेक्ट के प्रकार को निर्धारित करने की अनुमति देता है:

 >>> print type(1) <type 'int'> >>> print type("1") <type 'str'> >>> print type(ObjectCreator) <type 'type'> >>> print type(ObjectCreator()) <class '__main__.ObjectCreator'> 

वास्तव में, type फ़ंक्शन में एक पूरी तरह से अलग अनुप्रयोग है: यह भी जाने पर कक्षाएं बना सकता है। type एक कक्षा घोषणा लेता है और कक्षा को बुलाता है।

(मुझे पता है, यह मूर्खता है कि एक ही फ़ंक्शन का उपयोग किए गए तर्कों के आधार पर दो पूरी तरह से अलग-अलग चीजों के लिए किया जा सकता है। यह पिछड़े संगतता के लिए किया जाता है)

type निम्नानुसार काम करता है:

  type(< >, <  >, #  ,    <,     >) 

उदाहरण के लिए

 >>> class MyShinyClass(object): ... pass 

निम्नानुसार मैन्युअल रूप से बनाया जा सकता है:

  >>> MyShinyClass = type('MyShinyClass', (), {}) #  - >>> print MyShinyClass <class '__main__.MyShinyClass'> >>> print MyShinyClass() #    <__main__.MyShinyClass object at 0x8997cec> 

आपने देखा होगा कि हम "MyShinyClass" को एक वर्ग के नाम के रूप में और एक चर के लिए एक नाम के रूप में उपयोग करते हैं जो वर्ग के संदर्भ में है। वे अलग हो सकते हैं, लेकिन इसे जटिल क्यों करते हैं?

type एक डिक्शनरी को परिभाषित करता है जो क्लास की विशेषताएं बताता है:

 >>> class Foo(object): ... bar = True 

के रूप में फिर से लिखा जा सकता है

  >>> Foo = type('Foo', (), {'bar':True}) 

और एक नियमित वर्ग के रूप में उपयोग करें

  >>> print Foo <class '__main__.Foo'> >>> print Foo.bar True >>> f = Foo() >>> print f <__main__.Foo object at 0x8a9b84c> >>> print f.bar True 

बेशक, आप इसे विरासत में दे सकते हैं:

  >>> class FooChild(Foo): ... pass 

में बदल जाएगा

  >>> FooChild = type('FooChild', (Foo,), {}) >>> print FooChild <class '__main__.FooChild'> >>> print FooChild.bar # bar is inherited from Foo True 

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

 >>> def echo_bar(self): ... print self.bar ... >>> FooChild = type('FooChild', (Foo,), {'echo_bar': echo_bar}) >>> hasattr(Foo, 'echo_bar') >>> hasattr(FooChild, 'echo_bar') True >>> my_foo = FooChild() >>> my_foo.echo_bar() True 

यह पहले से ही स्पष्ट है कि मुझे क्या मिल रहा है: कक्षाएं पायथन में ऑब्जेक्ट हैं और आप जाने पर कक्षाएं बना सकते हैं।

class कीवर्ड का उपयोग करने पर यह ठीक यही करता है कि पायथन करता है, और यह मेटाक्लस का उपयोग करता है।

मेटाक्लास क्या है (अंत में)

मेटाक्लास एक "चीज़" है जो कक्षाएं बनाता है।

हम वस्तुओं को बनाने के लिए एक वर्ग बनाते हैं, है ना? और कक्षाएं ऑब्जेक्ट हैं। एक मेटाक्लास वह है जो इन वस्तुओं को बनाता है। वे कक्षाओं के वर्ग हैं, आप इसकी कल्पना इस प्रकार कर सकते हैं:

  MyClass = MetaClass() MyObject = MyClass() 

हमने पहले ही देखा है कि type आपको कुछ ऐसा करने की अनुमति देता है:

  MyClass = type('MyClass', (), {}) 

ऐसा इसलिए है क्योंकि type फ़ंक्शन वास्तव में एक मेटाक्लस है। type मेटाक्लास है जिसे पायथन आंतरिक रूप से सभी वर्गों को बनाने के लिए उपयोग करता है।

स्वाभाविक सवाल यह है कि ऐसा क्यों है कि उसका नाम निचले मामले में लिखा गया है, Type नहीं?

मुझे लगता है कि यह सिर्फ मिलान करने के लिए है, पंक्ति वस्तुओं को बनाने के लिए एक वर्ग, और पूर्णांक ऑब्जेक्ट बनाने के लिए एक वर्ग। type केवल क्लास ऑब्जेक्ट बनाने के लिए एक वर्ग है।

यह __class__ विशेषता का उपयोग करके आसानी से सत्यापित किया गया है:

अजगर में, सब कुछ (सब कुछ!) वस्तुएं हैं। संख्या, स्ट्रिंग, फ़ंक्शन और कक्षाएं शामिल हैं - वे सभी ऑब्जेक्ट हैं और वे सभी एक वर्ग से बनाए गए थे:

  >>> age = 35 >>> age.__class__ <type 'int'> >>> name = 'bob' >>> name.__class__ <type 'str'> >>> def foo(): pass >>> foo.__class__ <type 'function'> >>> class Bar(object): pass >>> b = Bar() >>> b.__class__ <class '__main__.Bar'> 

और प्रत्येक __class__ लिए __class__ क्या है?

  >>> a.__class__.__class__ <type 'type'> >>> age.__class__.__class__ <type 'type'> >>> foo.__class__.__class__ <type 'type'> >>> b.__class__.__class__ <type 'type'> 

तो, एक मेटाक्लास सिर्फ एक चीज है जो क्लास ऑब्जेक्ट बनाता है।

आप चाहें तो इसे "क्लास फैक्ट्री" कह सकते हैं

type अंतर्निहित मेटाक्लास है जिसे पायथन उपयोग करता है, लेकिन आप निश्चित रूप से अपना खुद का बना सकते हैं।

__metaclass__ विशेषता

कक्षा लिखते समय, आप __metaclass__ विशेषता जोड़ सकते हैं:

 class Foo(object): __metaclass__ = something... [...] 

इस मामले में, Foo क्लास बनाते समय पायथन निर्दिष्ट मेटाक्लास का उपयोग करेगा।

सावधानी, सूक्ष्मता है!

यद्यपि आप class Foo(object) लिखते हैं, एक वर्ग वस्तु अभी तक स्मृति में नहीं बनाई गई है।

कक्षा की परिभाषा में पायथन __metaclass__ करेगा। यदि वह इसे पा लेता है, तो वह कक्षा बनाने के लिए Foo का उपयोग करेगा। यदि नहीं, तो यह type उपयोग करेगा।

यानी जब आप लिखेंगे

 class Foo(Bar): pass 

पायथन निम्नलिखित करता है:

क्या Foo वर्ग में __metaclass__ विशेषता है?

यदि ऐसा है, तो यह __metaclass__ में निर्दिष्ट किए गए उपयोग से Foo नाम के साथ मेमोरी में एक क्लास ऑब्जेक्ट बनाता है।

यदि पायथन को __metaclass__ नहीं __metaclass__ , तो यह मूल वर्ग Bar में __metaclass__ खोज करता है और वही करने की कोशिश करता है।

यदि __metaclass__ माता-पिता में से किसी में नहीं है, तो पायथन मॉड्यूल स्तर पर __metaclass__ तलाश करेगा।

और अगर वह किसी भी __metaclass__ को नहीं पा सकता है, तो वह क्लास ऑब्जेक्ट बनाने के लिए type का उपयोग करता है।

अब महत्वपूर्ण सवाल यह है: मैं __metaclass__ में क्या डाल सकता हूं?

उत्तर: कुछ भी जो कक्षाएं बना सकता है।

क्या वर्ग बनाता है? type या इसका कोई उपवर्ग, साथ ही साथ कुछ भी जो उनका उपयोग करता है।

कस्टम मेटाक्लस

मेटाक्लास का मुख्य उद्देश्य सृजन के समय कक्षा को स्वचालित रूप से बदलना है।

यह आमतौर पर एपीआई के लिए किया जाता है जब आप वर्तमान संदर्भ के अनुसार कक्षाएं बनाना चाहते हैं।

एक मूर्खतापूर्ण उदाहरण की कल्पना करें: आपने तय किया कि आपके मॉड्यूल के सभी वर्गों के पास ऊपरी मामले में विशेषता नाम होने चाहिए। ऐसा करने के कई तरीके हैं, लेकिन उनमें से एक मॉड्यूल स्तर पर __metaclass__ सेट __metaclass__ है।

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

सौभाग्य से, __metaclass__ को कोई भी वस्तु कहा जा सकता है, जरूरी नहीं कि एक औपचारिक वर्ग हो (मुझे नाम में "वर्ग" शब्द के साथ कुछ पता है कि कक्षा होना जरूरी नहीं है, यह किस प्रकार की बकवास है? हालांकि, यह उपयोगी है)।

तो हम एक फ़ंक्शन का उपयोग करके एक सरल उदाहरण के साथ शुरू करेंगे।

 #        , #     `type` def upper_attr(future_class_name, future_class_parents, future_class_attr): """  -,        """ #   ,    '__' attrs = ((name, value) for name, value in future_class_attr.items() if not name.startswith('__')) #      uppercase_attr = dict((name.upper(), value) for name, value in attrs) #     `type` return type(future_class_name, future_class_parents, uppercase_attr) __metaclass__ = upper_attr #        class Foo(object): #    __metaclass__ ,       bar = 'bip' print hasattr(Foo, 'bar') # Out: False print hasattr(Foo, 'BAR') # Out: True f = Foo() print f.BAR # Out: 'bip' 

और अब वही बात, केवल वास्तविक वर्ग का उपयोग कर:

 # ,  `type`     ,  `str`  `int`, #       class UpperAttrMetaclass(type): #  __new__   __init__ #       , #     __init__   ,    . #     __new__,     , #    #       ,     , #    __new__. #    -  __init__,  . #        __call__, #      . def __new__(upperattr_metaclass, future_class_name, future_class_parents, future_class_attr): attrs = ((name, value) for name, value in future_class_attr.items() if not name.startswith('__')) uppercase_attr = dict((name.upper(), value) for name, value in attrs) return type(future_class_name, future_class_parents, uppercase_attr) 

लेकिन यह बिल्कुल OOP नहीं है। हम सीधे कॉल type करते हैं और पैरेंट __new__ कॉल को ओवरलोड नहीं करते हैं। चलो इसे करते हैं:

 class UpperAttrMetaclass(type): def __new__(upperattr_metaclass, future_class_name, future_class_parents, future_class_attr): attrs = ((name, value) for name, value in future_class_attr.items() if not name.startswith('__')) uppercase_attr = dict((name.upper(), value) for name, value in attrs) #   type.__new__ #  ,   return type.__new__(upperattr_metaclass, future_class_name, future_class_parents, uppercase_attr) 

आपने वैकल्पिक upperattr_metaclass तर्क पर ध्यान दिया होगा। इसके बारे में कुछ खास नहीं है: एक विधि हमेशा मौजूदा उदाहरण को अपने पहले तर्क के रूप में प्राप्त करती है। जैसे आप नियमित तरीकों में self का इस्तेमाल करते हैं।

बेशक, मैंने यहाँ जो नाम इस्तेमाल किए हैं, वे स्पष्टता के लिए बहुत लंबे हैं, लेकिन self तरह, इन सभी तर्कों के नामकरण के लिए एक सम्मेलन है। तो असली मेटाक्लास कुछ इस तरह दिखता है:

 class UpperAttrMetaclass(type): def __new__(cls, name, bases, dct): attrs = ((name, value) for name, value in dct.items() if not name.startswith('__')) uppercase_attr = dict((name.upper(), value) for name, value in attrs) return type.__new__(cls, name, bases, uppercase_attr) 

आप super का उपयोग करके और भी बेहतर कर सकते हैं, जो वंशानुक्रम का कारण बनेगा (चूंकि, निश्चित रूप से, आप type से विरासत में मिली मेटासेल्स से विरासत में मिला मेटाचैल्स बना सकते हैं):

 class UpperAttrMetaclass(type): def __new__(cls, name, bases, dct): attrs = ((name, value) for name, value in dct.items() if not name.startswith('__')) uppercase_attr = dict((name.upper(), value) for name, value in attrs) return super(UpperAttrMetaclass, cls).__new__(cls, name, bases, uppercase_attr) 

वह सब है। मेटाक्लासेस के बारे में कहने के लिए ज्यादा कुछ नहीं है।

मेटाक्लासेस का उपयोग कर कोड की जटिलता का कारण स्वयं मेटाक्लासेस में नहीं है। यह है कि आमतौर पर आत्मनिरीक्षण, विरासत में हेरफेर, __dict__ जैसे चर और इसी तरह के आधार पर सभी प्रकार की परिष्कृत चीजों के लिए __dict__ का उपयोग किया जाता है।

वास्तव में, मेटाक्लास विशेष रूप से सभी "काले जादू" के लिए उपयोगी होते हैं, और इसलिए, जटिल टुकड़े। लेकिन वे स्वयं सरल हैं:

• अवरोधन वर्ग निर्माण
• कक्षा बदलें
• वापसी संशोधित

कार्यों के बजाय मेटाक्लासेस का उपयोग क्यों करें?

चूंकि __metaclass__ किसी भी ऑब्जेक्ट को स्वीकार करता है, इसलिए यदि आप स्पष्ट रूप से अधिक जटिल हैं, तो आप अचानक एक वर्ग का उपयोग क्यों करेंगे?

इसके कई कारण हैं:

• उद्देश्य स्पष्ट है। जब आप UpperAttrMetaclass(type) देखते हैं, तो आप तुरंत जानते हैं कि आगे क्या आता है।
• आप OOP का उपयोग कर सकते हैं। पैतृक तरीकों से ओवरलैपिंग करके मेटाक्लस को मेटाक्लासेस से विरासत में लिया जा सकता है।
• बेहतर संरचित कोड। आप इस तरह की सरल चीजों के लिए मेटाक्लस का उपयोग नहीं करेंगे जैसे कि ऊपर दिए गए उदाहरण में। आमतौर पर यह कुछ जटिल है। कई तरीकों को बनाने और उन्हें एक कक्षा में समूह बनाने की क्षमता कोड को अधिक पठनीय बनाने के लिए बहुत उपयोगी है।
• आप __new__ , __init__ और __call__ उपयोग कर सकते हैं। बेशक, आप आमतौर पर __new__ में सब कुछ कर सकते हैं, लेकिन कुछ __init__ का उपयोग करके अधिक आरामदायक हैं
• उन्हें मेटा क्लासेस कहा जाता है, धिक्कार है! इसका मतलब कुछ तो होना चाहिए!

मेटाक्लासेस का उपयोग क्यों करें?

अंत में, मुख्य सवाल। कोई व्यक्ति कुछ अस्पष्ट (और त्रुटियों में योगदान) सुविधा का उपयोग क्यों करेगा?

ठीक है, आमतौर पर आपको उपयोग नहीं करना चाहिए:

Metaclasses गहरा जादू है कि 99% उपयोगकर्ताओं को सोचने की भी आवश्यकता नहीं है। यदि आपको लगता है कि क्या आपको उनका उपयोग करने की आवश्यकता है, तो आपको आवश्यकता नहीं है (ऐसे लोग जिन्हें वास्तव में उनकी आवश्यकता है, वे वास्तव में जानते हैं कि उन्हें उनकी आवश्यकता क्यों है, और स्पष्टीकरण की आवश्यकता क्यों नहीं है)।
~ पायथन गुरु टिम पीटर्स

मेटाक्लासेस का मुख्य उपयोग एपीआई बनाना है। एक विशिष्ट उदाहरण Django ORM है।

यह आपको कुछ इस तरह लिखने की अनुमति देता है:

  class Person(models.Model): name = models.CharField(max_length=30) age = models.IntegerField() 

हालाँकि, यदि आप निम्नलिखित कोड निष्पादित करते हैं:

  guy = Person(name='bob', age='35') print guy.age 

आपको IntegerField नहीं, लेकिन int , और मूल्य सीधे डेटाबेस से प्राप्त किया जा सकता है।

यह संभव है क्योंकि __metaclass__ को परिभाषित करता है, जो कुछ जादू करेगा और Person वर्ग को बदल देगा जिसे हमने एक सरल अभिव्यक्ति के साथ एक जटिल डेटाबेस बाइंडिंग में परिभाषित किया है।

Django एक सरल एपीआई को उजागर करके और एपीआई से कोड को फिर से बनाने के लिए मेटाक्लासेस का उपयोग करके कुछ जटिल दिखता है और चुपचाप सभी काम करता है।

अंत में

सबसे पहले, आपने सीखा है कि कक्षाएं ऐसी वस्तुएं हैं जो त्वरित कर सकती हैं।

वास्तव में, कक्षाएं भी उदाहरण हैं। मेटाक्लासेस के उदाहरण।

  >>> class Foo(object): pass >>> id(Foo) 142630324 

पाइथन में कोई भी वस्तु एक वस्तु है: एक वर्ग का उदाहरण या एक मेटाकाॅल का उदाहरण।

सिवाय type ।

type अपनी स्वयं की मेटाक्लस है। इसे शुद्ध पायथन में पुन: पेश नहीं किया जा सकता है और इसे कार्यान्वयन के स्तर पर थोड़ा धोखा दिया जाता है।

दूसरे, मेटाक्लास जटिल हैं। आपको बस कक्षाएं बदलने के लिए उनका उपयोग करने की आवश्यकता नहीं है। यह दो अलग-अलग तरीकों से किया जा सकता है:

• हाथ
• वर्ग सज्जाकार

99% मामलों में जब आपको कक्षा बदलने की आवश्यकता होती है, तो इन दोनों का उपयोग करना बेहतर होता है।

लेकिन 99% मामलों में आपको कक्षाओं को बदलने की आवश्यकता नहीं है :-)