पायथन में जादुई तरीकों को समझना

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

1. विशेषता पहुंच विधियां

ये जादुई तरीके नियंत्रित करते हैं कि आपकी वस्तुओं की विशेषताओं तक कैसे पहुंचा जाए, संशोधित किया जाए या हटाया जाए।

__getattr__ और __getattribute__

• __getattr__: जब किसी ऑब्जेक्ट में कोई विशेषता नहीं मिलती है तो कॉल किया जाता है।

• __getattribute__: किसी भी विशेषता तक पहुंचने के लिए बिना शर्त कॉल किया जाता है।

उदाहरण: लॉगिंग के साथ कस्टम विशेषता पहुंच

class LoggedAttributes:
    def __init__(self, name):
        self.name = name

    def __getattr__(self, item):
        print(f"Accessing non-existent attribute: {item}")
        return None

    def __getattribute__(self, item):
        print(f"Getting attribute: {item}")
        return super().__getattribute__(item)

# Usage
obj = LoggedAttributes("Alice")
print(obj.name)  # Output: Getting attribute: name\nAlice
print(obj.age)   # Output: Accessing non-existent attribute: age\nNone

व्यावहारिक उपयोग का मामला: गुणों को कब और कैसे एक्सेस किया जाता है या संशोधित किया जाता है, इसका पता लगाने के लिए डिबगिंग परिदृश्य में लॉगिंग विशेषता पहुंच।

__setattr__ और __delattr__

• __setattr__: जब किसी विशेषता असाइनमेंट का प्रयास किया जाता है तो कॉल किया जाता है।

• __delattr__: जब किसी विशेषता को हटाने का प्रयास किया जाता है तो कॉल किया जाता है।

उदाहरण: सत्यापन के साथ कस्टम विशेषता संशोधन

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __setattr__(self, key, value):
        if key == "age" and value 



व्यावहारिक उपयोग का मामला: विशेषताओं को सेट या हटाते समय सत्यापन नियम या प्रतिबंध लागू करना।


  
  
  2. कंटेनर तरीके


ये जादुई तरीके आपकी वस्तुओं को कंटेनर (सूचियां, शब्दकोश, आदि) की तरह व्यवहार करने की अनुमति देते हैं।


  
  
  __len__, __getitem__, __setitem__, __delitem__, और __iter__

• __len__: कंटेनर की लंबाई लौटाता है।

• __getitem__: किसी दिए गए इंडेक्स या कुंजी पर एक आइटम पुनर्प्राप्त करता है।

• __setitem__: किसी आइटम को किसी दिए गए इंडेक्स या कुंजी पर सेट करता है।

• __delitem__: किसी दिए गए इंडेक्स या कुंजी पर एक आइटम हटाता है।

• __iter__: एक पुनरावर्तक ऑब्जेक्ट लौटाता है।

उदाहरण: कस्टम सूची-जैसी वस्तु

class CustomList:
    def __init__(self):
        self._items = []

    def __len__(self):
        return len(self._items)

    def __getitem__(self, index):
        return self._items[index]

    def __setitem__(self, index, value):
        self._items[index] = value

    def __delitem__(self, index):
        del self._items[index]

    def __iter__(self):
        return iter(self._items)

    def append(self, item):
        self._items.append(item)

# Usage
cl = CustomList()
cl.append(1)
cl.append(2)
cl.append(3)
print(len(cl))  # Output: 3
print(cl[1])    # Output: 2
for item in cl:
    print(item)  # Output: 1 2 3

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

3. संख्यात्मक और तुलना विधियां

ये विधियां परिभाषित करती हैं कि आपकी कक्षा की वस्तुएं संख्यात्मक संचालन और तुलनाओं के साथ कैसे इंटरैक्ट करती हैं।

संख्यात्मक विधियां

• __जोड़ें__, __sub__, __mul__, __truediv__, __floordiv__, __mod__, __pow__: अंकगणितीय संक्रियाओं को परिभाषित करें।

उदाहरण: कस्टम कॉम्प्लेक्स नंबर क्लास

class Complex:
    def __init__(self, real, imag):
        self.real = real
        self.imag = imag

    def __add__(self, other):
        return Complex(self.real   other.real, self.imag   other.imag)

    def __sub__(self, other):
        return Complex(self.real - other.real, self.imag - other.imag)

    def __repr__(self):
        return f"({self.real}   {self.imag}i)"

# Usage
c1 = Complex(1, 2)
c2 = Complex(3, 4)
print(c1   c2)  # Output: (4   6i)
print(c1 - c2)  # Output: (-2   -2i)

व्यावहारिक उपयोग का मामला: जटिल संख्याओं, वैक्टर, या मैट्रिक्स जैसे कस्टम संख्यात्मक प्रकारों को लागू करना।

तुलना के तरीके

• __eq__, __ne__, __lt__, __le__, __gt__, __ge__: तुलना संचालन को परिभाषित करें।

उदाहरण: एक कस्टम क्लास के लिए कुल ऑर्डर लागू करना

from functools import total_ordering

@total_ordering
class Book:
    def __init__(self, title, author):
        self.title = title
        self.author = author

    def __eq__(self, other):
        return (self.title, self.author) == (other.title, other.author)

    def __lt__(self, other):
        return (self.title, self.author) 



व्यावहारिक उपयोग का मामला: कस्टम ऑब्जेक्ट को सॉर्ट करने या तुलना करने में सक्षम बनाना, ढेर, बाइनरी सर्च ट्री जैसी डेटा संरचनाओं में उपयोगी, या बस कस्टम ऑब्जेक्ट की सूचियों को सॉर्ट करते समय।


  
  
  4. कंटेनर विधियां: व्यावहारिक उपयोग का मामला



  
  
  केस-असंवेदनशील कुंजियों के साथ कस्टम शब्दकोश


एक शब्दकोश जैसी वस्तु बनाना जो कुंजियों को केस-असंवेदनशील मानता है।

उदाहरण: केस-असंवेदनशील शब्दकोश



class CaseInsensitiveDict:
    def __init__(self):
        self._data = {}

    def __getitem__(self, key):
        return self._data[key.lower()]

    def __setitem__(self, key, value):
        self._data[key.lower()] = value

    def __delitem__(self, key):
        del self._data[key.lower()]

    def __contains__(self, key):
        return key.lower() in self._data

    def keys(self):
        return self._data.keys()

    def items(self):
        return self._data.items()

    def values(self):
        return self._data.values()

# Usage
cid = CaseInsensitiveDict()
cid["Name"] = "Alice"
print(cid["name"])  # Output: Alice
print("NAME" in cid)  # Output: True




व्यावहारिक उपयोग का मामला: ऐसे शब्दकोष बनाना जहां कुंजियों को केस-असंवेदनशील माना जाना चाहिए, उपयोगकर्ता इनपुट, कॉन्फ़िगरेशन सेटिंग्स आदि को संभालने के लिए उपयोगी है।


  
  
  निष्कर्ष


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