మెటాక్లాసెస్ మరియు డిస్క్రిప్టర్లు అనేవి మెటా-ప్రోగ్రామింగ్ కోసం అధునాతన Python లక్షణాలు — క్లాసెస్ మరియు attribute ఆక్సెస్ ఎలా ప్రవర్తిస్తాయో నియంత్రించడం. ఫ్రేమ్వర్క్లలో (ORMs, Pydantic) చాలా "మ్యాజిక్" శక్తి ఇవ్వే కారకం ఇవే, అయితే నిజానికి application కోడ్లో మీరు వాటిని సరిగా రాయరు.
:
(Dog)
(Dog())
ఒక క్లాస్ ఇన్స్టాన్సెస్ సృష్టించినట్లుగానే, మెటాక్లాస్ క్లాసెస్ సృష్టిస్తుంది. మెటాక్లాసને కస్టమైజ్ చేయడం ద్వారా, మీరు క్లాస్ క్రియేషన్ను ఆపివేసుకోవచ్చు మరియు సవరించవచ్చు:
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
ఇది ఫ్రేమ్వర్క్లను ఆటోమేటిక్గా క్లాసెస్ నమోదు చేయడానికి, డెఫినిషన్లను వాలిడేట్ చేయడానికి, లేదా ప్రతి సబక్లాసుకు ప్రవర్తన జోడించడానికి ఇవ్వండి — ఉదాహరణకు ORMs క్లాస్ attributesలను database కాలమ్లుగా ఎలా మార్చుతుందో.
డిస్క్రిప్టర్ అనేది __get__/__set__/__delete__ను నిర్వచించే ఆబ్జెక్ట్, attribute చదివినప్పుడు లేదా రాసినప్పుడు ఏమి జరుగుతుందో నియంత్రిస్తుంది:
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
డిస్క్రిప్టర్లు attribute ఆక్సెస్ కోసం రెండు పొరలను జోడిస్తాయి — validation, కంప్యూటెడ్ attributes, మరియు lazy లోడింగ్ ఎనేబిల్ చేస్తాయి. వాస్తవానికి, @property, @classmethod, మరియు @staticmethod అన్నీ డిస్క్రిప్టర్లుగా అమలు చేయబడతాయి.
Metaclasses → Django/SQLAlchemy ORM models, ABCs, Pydantic, framework registration
Descriptors → @property, ORM fields, validation libraries, lazy attributes
మెటాక్లాసెస్ మరియు డిస్క్రిప్టర్లు Python యొక్క అత్యంత శక్తివంతమైన లైబ్రరీలన్నింటిలో meta-ప్రోగ్రామింగ్ యంత్రాలు — ORMs క్లాస్ డెఫినిషన్లను database స్కీమాలుగా మారుస్తాయి, Pydantic వంటి validation ఫ్రేమ్వర్క్లు, మరియు @property (ఒక డిస్క్రిప్టర్) వంటి built-ins కూడా.
చాలా డెవలపర్లు వాటిని నేరుగా రాయరు (మరియు సరళ సాధనాలు సరిపోయినప్పుడు వాటికి చేరూ కూడా చేయకూడదు), అయితే వాటిని అర్థం చేసుకోవడం ఈ ఫ్రేమ్వర్క్లు తమ "మ్యాజిక్" ఎలా సాధిస్తాయో డీమిస్టిఫై చేస్తుంది — class-level కస్టమైజేషన్ మరియు నియంత్రిత attribute ఆక్సెస్.
ఈ జ్ఞానం అధునాతన లైబ్ररీ డిజైన్, ఫ్రేమ్వర్క్ ప్రవర్తనను డీబగ్ చేయడం, మరియు Python యొక్క object model గভీరంగా అర్థం చేసుకోవడం కోసం విలువైనది — ఇది intermediate నుండి language యొక్క expert-level అర్థమైకకు వేరుచేసేది.