Metaclasses ਅਤੇ descriptors Python ਦੀਆਂ ਉੱਨਤ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਹਨ ਜੋ meta-programming ਲਈ ਹਨ — ਜੋ ਇਹ ਨਿਯੰਤਰਿਤ ਕਰਦੀਆਂ ਹਨ ਕਿ ਕਲਾਸਜ਼ ਅਤੇ attribute access ਕਿਵੇਂ ਵਿਵਹਾਰ ਕਰਦੇ ਹਨ। ਉਹ frameworks (ORMs, Pydantic) ਵਿੱਚ ਬਹੁਤ "magic" ਨੂੰ ਚਲਾਉਂਦੇ ਹਨ، ਭਾਵੇਂ ਤੁਸੀਂ ਉਹਨਾਂ ਨੂੰ application code ਵਿੱਚ ਸਿੱਧੇ ਲਿਖਦੇ ਹੀ ਨਹੀਂ ਹੋ।
:
(Dog)
(Dog())
ਜਿਸ ਤਰ੍ਹਾਂ ਇੱਕ ਕਲਾਸ instances ਬਣਾਉਂਦੀ ਹੈ، ਇੱਕ metaclass ਕਲਾਸਜ਼ ਬਣਾਉਂਦੀ ਹੈ। Metaclass ਨੂੰ customize ਕਰਕੇ، ਤੁਸੀਂ ਕਲਾਸ creation ਨੂੰ intercept ਅਤੇ modify ਕਰ ਸਕਦੇ ਹੋ:
class Meta(type):
def __new__(mcs, name, bases, namespace):
# runs when a class USING this metaclass is DEFINED
namespace["created_by"] = "Meta" # inject an attribute into every such class
return super().__new__(mcs, name, bases, namespace)
class MyClass(metaclass=Meta):
pass
MyClass.created_by # "Meta" — injected by the metaclass at class-creation time
ਇਹ frameworks ਨੂੰ automatically ਕਲਾਸਜ਼ ਨੂੰ register ਕਰਨ، definitions ਨੂੰ validate ਕਰਨ، ਜਾਂ ਹਰੇਕ subclass ਨੂੰ behavior ਜੋੜਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ — ਉਦਾਹਰਨ ਲਈ ORMs ਕਿਵੇਂ ਕਲਾਸ attributes ਨੂੰ database columns ਵਿੱਚ ਬਦਲਦੀਆਂ ਹਨ।
ਇੱਕ descriptor ਇੱਕ object ਹੈ ਜੋ __get__/__set__/__delete__ ਨੂੰ define ਕਰਦਾ ਹੈ، ਇਹ ਨਿਯੰਤਰਿਤ ਕਰਦਾ ਹੈ ਕਿ attribute ਨੂੰ read ਜਾਂ write ਕਰਨ ਵੇਲੇ ਕੀ ਹੁੰਦਾ ਹੈ:
class Positive:
def __set_name__(self, owner, name):
self.name = f"_{name}"
def __get__(self, obj, objtype=None):
return getattr(obj, self.name)
def __set__(self, obj, value):
if value < 0:
raise ValueError("must be positive") # validate on assignment
setattr(obj, self.name, value)
class Account:
balance = Positive() # a descriptor as a class attribute
a = Account()
a.balance = 100 # calls Positive.__set__ → validates
a.balance = -5 # ❌ ValueError
Descriptors attribute access ਨੂੰ intercept ਕਰਦੇ ਹਨ — validation، computed attributes، ਅਤੇ lazy loading ਨੂੰ enable ਕਰਦੇ ਹਨ। ਅਸਲ ਵਿੱਚ، @property، @classmethod، ਅਤੇ @staticmethod ਸਾਰੇ descriptors ਦੇ ਤੌਰ ਉੱਤੇ implement ਕੀਤੇ ਜਾਂਦੇ ਹਨ।
Metaclasses → Django/SQLAlchemy ORM models, ABCs, Pydantic, framework registration
Descriptors → @property, ORM fields, validation libraries, lazy attributes
Metaclasses ਅਤੇ descriptors ਉਹ meta-programming machinery ਹਨ ਜੋ Python ਦੇ ਸਭ ਤੋਂ ਸ਼ਕਤੀਸ਼ਾਲੀ libraries ਦੇ ਪਿੱਛੇ ਲੁਕੀਆਂ ਹੋਈਆਂ ਹਨ — ORMs ਜੋ ਕਲਾਸ definitions ਨੂੰ database schemas ਵਿੱਚ ਬਦਲਦੀਆਂ ਹਨ، Pydantic ਵਰਗੀਆਂ validation frameworks، ਅਤੇ ਇੱਥੋ @property (ਇੱਕ descriptor) ਵਰਗੀਆਂ built-ins।
ਜਦਕਿ ਜ਼ਿਆਦਾਤਰ developers ਉਹਨਾਂ ਨੂੰ ਸਿੱਧੇ ਲਿਖਦੇ ਹੀ ਨਹੀਂ ਹਨ (ਅਤੇ ਜਦੋਂ ਸਧਾਰਨ ਟੂਲਸ ਕਾਫ਼ੀ ਹਨ ਤਾਂ ਆਪਣੇ ਤੇ ਨਹੀਂ ਲੈਣਾ ਚਾਹੀਦਾ)، ਉਹਨਾਂ ਨੂੰ ਸਮਝਣਾ ਇਹ ਸਪੱਸ਼ਟ ਕਰਦਾ ਹੈ ਕਿ ਇਹ frameworks ਕਲਾਸ-level customization ਅਤੇ controlled attribute access ਦੀ ਆਪਣੀ "magic" ਕਿਵੇਂ ਪ੍ਰਾਪਤ ਕਰਦੇ ਹਨ।
ਇਹ ਗਿਆਨ advanced library design، framework behavior ਨੂੰ debug ਕਰਨ، ਅਤੇ Python ਦੇ object model ਨੂੰ deeply ਸਮਝਣ ਲਈ valuable ਹੈ — ਇਹ ਉਹ ਹੈ ਜੋ intermediate ਤੋਂ expert-level ਦੀ Python ਦੀ ਸਮਝ ਨੂੰ ਵੱਖ ਕਰਦਾ ਹੈ।