Python में मेटाक्लास क्या है: पूरी गाइड

Python में मेटाक्लास (Metaclass) एक विशेष प्रकार का क्लास होता है जो दूसरे क्लासेज़ को बनाता और मैनेज करता है। चूंकि Python में सब कुछ एक ऑब्जेक्ट है, जिसमें क्लास भी शामिल हैं, इसलिए मेटाक्लास को "क्लास का क्लास" कहा जा सकता है। यह क्लास बनाने की प्रक्रिया को कंट्रोल करने और उनके व्यवहार को डेफिनेशन के समय बदलने का एक तरीका प्रदान करता है।

मेटाक्लास कैसे काम करता है?

जब Python कोई क्लास डेफिनेशन देखता है, तो वह स्वचालित रूप से type मेटाक्लास का उपयोग करके उस क्लास को बनाता है। यह प्रक्रिया इस प्रकार है:

class MyClass:
    pass

अंदरूनी तौर पर, Python यह करता है:

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

जहां:

• 'MyClass' — क्लास का नाम
• () — पैरेंट क्लासेज़ का टपल
• {} — क्लास के एट्रीब्यूट और मेथड का डिक्शनरी

बिल्ट-इन मेटाक्लास type डिफ़ॉल्ट रूप से Python में सभी क्लासेज़ बनाने के लिए जिम्मेदार है।

अपना खुद का मेटाक्लास बनाना

कस्टम मेटाक्लास type से इनहेरिट करके और उसके मेथड को ओवरराइड करके बनाए जाते हैं:

class MyMeta(type):
    def __new__(cls, name, bases, attrs):
        print(f"क्लास {name} बन रहा है")
        attrs['created_by_metaclass'] = True
        return super().__new__(cls, name, bases, attrs)

class MyClass(metaclass=MyMeta):
    pass

print(MyClass.created_by_metaclass)  # True

मेटाक्लास के मुख्य मेथड

__new__

क्लास बनाने की प्रक्रिया को कंट्रोल करता है। __init__ से पहले कॉल होता है और नया क्लास रिटर्न करता है:

class CreationMeta(type):
    def __new__(cls, name, bases, attrs):
        # क्लास बनाने से पहले एट्रीब्यूट में बदलाव
        attrs['class_id'] = id(cls)
        return super().__new__(cls, name, bases, attrs)

__init__

पहले से बने क्लास को इनिशियलाइज़ करता है:

class InitMeta(type):
    def __init__(cls, name, bases, attrs):
        print(f"क्लास {name} इनिशियलाइज़ हो रहा है")
        super().__init__(name, bases, attrs)

__call__

क्लास के इंस्टेंस बनाने पर व्यवहार को परिभाषित करता है:

class CallMeta(type):
    def __call__(cls, *args, **kwargs):
        print(f"{cls.__name__} का इंस्टेंस बन रहा है")
        return super().__call__(*args, **kwargs)

व्यावहारिक उदाहरण

एट्रीब्यूट का ऑटोमैटिक कन्वर्ज़न

class UpperAttrMeta(type):
    def __new__(cls, name, bases, attrs):
        uppercase_attrs = {}
        for attr_name, attr_value in attrs.items():
            if not attr_name.startswith('__'):
                uppercase_attrs[attr_name.upper()] = attr_value
            else:
                uppercase_attrs[attr_name] = attr_value
        return super().__new__(cls, name, bases, uppercase_attrs)

class MyClass(metaclass=UpperAttrMeta):
    attr1 = 'value1'
    attr2 = 'value2'

print(hasattr(MyClass, 'ATTR1'))  # True
print(hasattr(MyClass, 'attr1'))  # False

Singleton पैटर्न को लागू करना

class SingletonMeta(type):
    _instances = {}
    
    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super().__call__(*args, **kwargs)
        return cls._instances[cls]

class DatabaseConnection(metaclass=SingletonMeta):
    def __init__(self):
        print("डेटाबेस कनेक्शन बन रहा है")

db1 = DatabaseConnection()
db2 = DatabaseConnection()
print(db1 is db2)  # True

क्लास स्ट्रक्चर की वैलिडेशन

class ValidatedMeta(type):
    def __new__(cls, na