जादुई तरीकों का उपयोग करके पायथन में कक्षा व्यवहार को कैसे अनुकूलित करें

पायथन में, कक्षाएं डेटा और कार्यक्षमता को पुन: प्रयोज्य तत्वों में एक साथ बंडल करने का एक स्वच्छ साधन प्रदान करती हैं। कस्टम कक्षाएं बनाने से आप उपयोगकर्ताओं, उत्पादों और कर्मचारियों जैसी वास्तविक दुनिया की संस्थाओं को मॉडल कर सकते हैं।

पायथन कक्षाएं जादुई तरीकों को परिभाषित करती हैं जिन्हें आप अद्वितीय स्थितियों के लिए अपनी कक्षाओं के व्यवहार को आकार देने के लिए अनुकूलित कर सकते हैं।

जादुई तरीकों को समझना

जादुई तरीकों की कल्पना करें, जिन्हें डंडर तरीके भी कहा जाता है, गुप्त मंत्र या छिपे हुए मंत्र के रूप में जिन्हें पायथन स्वचालित रूप से कॉल करता है जब आप किसी वस्तु पर कुछ क्रियाएं करते हैं।

पायथन कक्षाओं के लिए बहुत सारे अंतर्निहित व्यवहार प्रदान करता है उदाहरण, स्थिर और वर्ग विधियाँ. तुम कर सकते हो पायथन कक्षाएं बनाएं, और जादुई तरीकों का उपयोग करके उन्हें और भी अनुकूलित करें।

जादुई विधियां पायथन में उदाहरण विधियां हैं जिनमें दो अंडरस्कोर हैं (__तरीका__) विधि नाम से पहले और बाद में।

ये विशेष विधियाँ पायथन को निर्देश देती हैं कि किसी वर्ग की वस्तुओं को कैसे संभालना है। यहां पायथन कक्षाओं में आमतौर पर उपयोग की जाने वाली कुछ जादुई विधियां दी गई हैं:

• __gt__: यह विधि जांच करती है कि एक वस्तु दूसरी से बड़ी है या नहीं।
• __इस में__: यह विधि तब चलती है जब आप किसी वर्ग का उदाहरण बनाते हैं, और यह मुख्य रूप से विशेषता आरंभीकरण के लिए होता है।
• __str__: यह ऑब्जेक्ट का वर्णन करने वाले वर्ग का एक स्ट्रिंग प्रतिनिधित्व लौटाता है।
• __repr__: यह विधि एक आउटपुट देती है जो आपको ऑब्जेक्ट का उपयोग करके फिर से बनाने की अनुमति देती है eval().
• __लेन__: जब आप उपयोग करते हैं लेन() किसी ऑब्जेक्ट पर फ़ंक्शन यह विधि ऑब्जेक्ट की लंबाई लौटाती है।
• __eq__: यह विधि डबल बराबर का उपयोग करके वस्तुओं के बीच तुलना करने में सक्षम बनाती है (==) ऑपरेटर।
• __lt__: यह वस्तुओं के लिए (
• __जोड़ना__: जब आप अतिरिक्त का उपयोग करते हैं (+) ऑब्जेक्ट पर ऑपरेटर यह विधि चलाता है और अतिरिक्त ऑपरेशन करता है।
• __वस्तु ले आओ__: आपको इंडेक्स सिंटैक्स का उपयोग करके किसी ऑब्जेक्ट से आइटम पुनर्प्राप्त करने की अनुमति देता है, जैसे ओबीजे[कुंजी]।

जादुई तरीकों को लागू करना

जादुई तरीकों को समझने का सबसे अच्छा तरीका उनका उपयोग करना है।

किसी वस्तु का स्ट्रिंग प्रतिनिधित्व

आप पठनीयता या आगे की प्रक्रिया के लिए किसी ऑब्जेक्ट के स्ट्रिंग प्रतिनिधित्व को अनुकूलित कर सकते हैं।

classPerson:
def__init__(self, name, age):
 self.name = name
 self.age = age
p1 = Person('John', 25)
print(p1)

यहाँ आपके लिए एक सरल है व्यक्ति एक के साथ कक्षा __इस में__ इसे आरंभ करने की जादुई विधि। जब आप प्रिंट करते हैं पी1 ऑब्जेक्ट, यह पायथन द्वारा प्रदान की गई डिफ़ॉल्ट स्ट्रिंग प्रस्तुति का उपयोग करता है।

स्ट्रिंग प्रतिनिधित्व को अनुकूलित करने के लिए, परिभाषित करें __str__ और __repr__ जादुई तरीके:

classPerson:
def__init__(self, name, age, height):
 self.name = name
 self.age = age
 self.height = height
def__str__(self):
returnf'{self.name} is {self.age} years old'
def__repr__(self):
returnf'{self.name} is {self.age} years old'
p1 = Person('John', 25, 78) 
print(p1)

अब आपके पास इसका अधिक पठनीय और व्यापक स्ट्रिंग प्रतिनिधित्व है पी1 वस्तु:

किसी वस्तु की लंबाई संपत्ति

कल्पना कीजिए कि, जब आप कॉल करते हैं लेन() किसी व्यक्ति ऑब्जेक्ट की विधि, आप उनकी ऊँचाई चाहते हैं। लागू करें __लेन__ के लिए जादुई विधि व्यक्ति कक्षा:

classPerson:
def__init__(self, name, age, height):
 self.name = name
 self.age = age
 self.height = height
def__str__(self):
returnf'{self.name} is {self.age} years old'
def__repr__(self):
returnf'{self.name} is {self.age} years old'
def__len__(self):
return self.height
p2 = Person('Issac', 25, 89) 
print(len(p2))

__लेन__ जादुई विधि a की ऊंचाई विशेषता लौटाती है व्यक्ति उदाहरण। जब तुमने फोन किया लेन (पी2), यह कॉल करेगा __लेन__ जादू विधि स्वचालित रूप से जो की ऊंचाई लौटाता है पी2 वस्तु।

वस्तुओं के बीच तुलना को संभालना

यदि आपको वर्ग के कुछ गुणों के आधार पर किसी वर्ग की वस्तुओं की तुलना करने की आवश्यकता है। आप परिभाषित कर सकते हैं __eq__ जादू विधि और अपने तुलना तर्क को लागू करें।

classPerson:
def__init__(self, name, age, height):
 self.name = name
 self.age = age
 self.height = height
def__str__(self):
returnf'{self.name} is {self.age} years old'
def__repr__(self):
returnf'{self.name} is {self.age} years old'
def__len__(self):
return self.height
def__eq__(self, other):
return self.name == other.name and self.age == other.age
p1 = Person('John', 25, 56)
p2 = Person('John', 25, 61)
print(p1 == p2)

__eq__ विधि तुलना करती है नाम और आयु दोनों के गुण व्यक्ति का समानता निर्धारित करने के लिए वस्तुएँ।

डबल के बराबर (==) ऑपरेटर पहचानों की तुलना करने के बजाय समानता की जांच करने के लिए इस पद्धति का उपयोग करता है। तो दो व्यक्ति यदि उनके नाम और आयु विशेषताएँ मेल खाती हैं तो उदाहरण समान हैं। यह आपको अपने कस्टम वर्ग के लिए डिफ़ॉल्ट समानता-जांच व्यवहार को ओवरराइड करने की अनुमति देता है।

इन जादुई तरीकों को लागू करके, आप कस्टम व्यवहार को परिभाषित कर सकते हैं जो पायथन के बिल्ट-इन के अनुरूप होगा।

उन्नत जादुई तरीके

कक्षाओं को अनुकूलित करने के लिए जादुई तरीकों का उपयोग करने के कुछ उन्नत उदाहरण यहां दिए गए हैं।

कक्षाओं को कंटेनरों की तरह बनाना

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

classPerson:
def__init__(self):
 self.data = []
def__len__(self):
return len(self.data)
def__getitem__(self, index):
return self.data[index]
def__setitem__(self, index, value):
 self.data[index] = value
def__delitem__(self, index):
del self.data[index]
p1 = Person()
p1.data = [10, 2, 7]
print(len(p1)) # 3
p1[0] = 5
print(p1[0]) # 5

अब एक व्यक्ति वस्तु एक कंटेनर की तरह व्यवहार कर सकती है:

विशेषता पहुंच को अनुकूलित करना

का उपयोग __getattr__ जादुई विधि से आप तरीके की विशेषताओं को अनुकूलित कर सकते हैं व्यक्ति कुछ शर्तों के आधार पर कक्षा तक पहुंच प्राप्त की जा रही है।

classPerson:
def__getattr__(self, name):
if name == 'age':
return40
else:
raise AttributeError(f'No attribute {name}')
p1 = Person()
print(p1.age) # 40

__getattr__ विधि तब चलेगी जब आप किसी ऐसी विशेषता तक पहुँचने का प्रयास करेंगे जो सीधे ऑब्जेक्ट में मौजूद नहीं है। इस मामले में, यह जाँचता है कि विशेषता नाम है या नहीं आयु और 40 लौटाता है।

किसी अन्य विशेषता नाम के लिए, यह एक उठाता है विशेषतात्रुटि संबंधित संदेश के साथ.

कक्षाओं को कॉल करने योग्य जैसा व्यवहार बनाना

__पुकारना__ विधि आपको क्लास के एक उदाहरण को कॉल करने योग्य ऑब्जेक्ट (यानी, एक फ़ंक्शन) के रूप में मानने की अनुमति देती है।

classAdder:
def__call__(self, x, y):
return x + y
adder = Adder()
print(adder(2, 3)) # 5

जब आप इसका एक उदाहरण बनाते हैं एडर और फिर इसे तर्कों के साथ बुलाएं, __पुकारना__ विधि चलती है और परिणाम लौटाने से पहले जोड़-घटाव करती है।

ऑपरेटर ओवरलोडिंग

जादुई तरीकों का उपयोग करके आप ऑपरेटर ओवरलोडिंग कर सकते हैं। ऑपरेटर ओवरलोडिंग आपको अपने स्वयं के वर्गों के उदाहरणों के साथ उपयोग किए जाने पर अंतर्निहित ऑपरेटरों के लिए कस्टम व्यवहार को परिभाषित करने की अनुमति देता है। यहां एक सामान्य उदाहरण दिया गया है जो ऑपरेटर ओवरलोडिंग की व्याख्या करता है।

classVector:
def__init__(self, x, y):
 self.x = x
 self.y = y
def__add__(self, other):
if isinstance(other, Vector):
 new_x = self.x + other.x
 new_y = self.y + other.y
return Vector(new_x, new_y)
else:
raise TypeError("Unsupported operand type for +")
def__str__(self):
returnf"({self.x}, {self.y})"
# Creating two Vector instances
v1 = Vector(2, 3)
v2 = Vector(1, 4)
# Adding two Vector instances using the + operator
v3 = v1 + v2
# Printing the result
print(v3) # Output: (3, 7)

परिणाम एक नया वेक्टर है:

वेक्टर वर्ग परिभाषित करता है __जोड़ना__ विधि, जो आपके उपयोग करने पर चलती है + कक्षा के दो उदाहरणों के बीच ऑपरेटर। विधि दो वैक्टरों के संबंधित घटकों को जोड़ती है और एक नया रिटर्न देती है वेक्टर परिणाम के साथ उदाहरण.

यहां आपने मौलिक जादूई विधियां देखी हैं जिन्हें आप अपने कक्षा व्यवहार को अनुकूलित करने के लिए लागू कर सकते हैं। पायथन में कई जादुई विधियां हैं जो कक्षाएं बनाते समय अधिक लचीलापन प्रदान करती हैं। को देखें आधिकारिक दस्तावेज पूरी सूची के लिए.

पायथन में ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग

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