पायथन में मैजिक मेथड्स

पायथन में मैजिक मेथड्स

यह लेख पायथन में मैजिक मेथड्स को समझाता है।

YouTube Video

पायथन में मैजिक मेथड्स

पायथन में मैजिक मेथड्स (विशेष मेथड्स) वे विशेष नाम वाले मेथड्स हैं जो क्लासों को विशिष्ट व्यवहार देने के लिए उपयोग किए जाते हैं। उदाहरण के तौर पर, इनकी खासियत है कि ये डबल अंडरस्कोर (डंडर) के बीच लिखे जाते हैं, जैसे __init__ और __str__। इसलिए, इन्हें डंडर मेथड्स भी कहा जाता है।

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

इनिशियलाइजेशन और स्ट्रिंग प्रतिनिधित्व के लिए मैजिक मेथड्स

__init__: इनिशियलाइजेशन मेथड

__init__ मेथड एक कंस्ट्रक्टर है जो इंस्टेंस बनाते समय अपने आप कॉल होता है।

1class Person:
2    def __init__(self, name, age):
3        self.name = name
4        self.age = age
5
6person = Person("Alice", 30)
7print(person.name)  # Alice

__str__: मानव-पठन योग्य स्ट्रिंग प्रतिनिधित्व

__str__ मेथड एक मानव-पठन योग्य स्ट्रिंग प्रतिनिधित्व लौटाता है। इसे print() और str() द्वारा कॉल किया जाता है।

1class Person:
2    def __init__(self, name):
3        self.name = name
4
5    def __str__(self):
6        return f"Person: {self.name}"
7
8person = Person("Bob")
9print(person)  # Person: Bob

__repr__: डिबगिंग के लिए स्ट्रिंग प्रतिनिधित्व

__repr__ मेथड डिबगिंग के लिए स्ट्रिंग प्रतिनिधित्व लौटाता है। यह repr() और इंटरप्रेटर में डिस्प्ले करते समय उपयोग किया जाता है।

1class Person:
2    def __init__(self, name):
3        self.name = name
4
5    def __repr__(self):
6        return f"Person(name={self.name!r})"
7
8person = Person("Eve")
9print(repr(person))  # Person(name='Eve')

अंकगणित ऑपरेटर्स की ओवरलोडिंग

__add__: + ऑपरेटर

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

 1class Vector:
 2    def __init__(self, x, y):
 3        self.x = x
 4        self.y = y
 5
 6    def __add__(self, other):
 7        return Vector(self.x + other.x, self.y + other.y)
 8
 9    def __repr__(self):
10        return f"Vector({self.x}, {self.y})"
11
12    # Other arithmetic magic methods:
13    # def __sub__(self, other):       # Subtraction (-)
14    # def __mul__(self, other):       # Multiplication (*)
15    # def __truediv__(self, other):   # True division (/)
16    # def __floordiv__(self, other):  # Floor division (//)
17    # def __mod__(self, other):       # Modulo (%)
18    # def __pow__(self, other):       # Exponentiation (**)
19
20v1 = Vector(1, 2)
21v2 = Vector(3, 4)
22print(v1 + v2)  # Vector(4, 6)

अन्य अंकगणित संबंधी मैजिक मेथड्स में निम्नलिखित शामिल हैं:।

मेथड ऑपरेटर
__add__ +
__sub__ -
__mul__ *
__truediv__ /
__floordiv__ //
__mod__ %
__pow__ **

तुलना ऑपरेटर्स का अनुकूलन

आप तुलना ऑपरेटर्स को भी ओवरलोड कर सकते हैं। जैसे कि, __eq__ मेथड समता (इक्वैलिटी) ऑपरेटर को ओवरलोड करता है।

 1class Box:
 2    def __init__(self, volume):
 3        self.volume = volume
 4
 5    def __eq__(self, other):
 6        return self.volume == other.volume
 7
 8    def __lt__(self, other):
 9        return self.volume < other.volume
10
11    # Comparison magic methods:
12    # def __eq__(self, other):  # Equal to (==)
13    # def __ne__(self, other):  # Not equal to (!=)
14    # def __lt__(self, other):  # Less than (<)
15    # def __le__(self, other):  # Less than or equal to (<=)
16    # def __gt__(self, other):  # Greater than (>)
17    # def __ge__(self, other):  # Greater than or equal to (>=)
18
19b1 = Box(100)
20b2 = Box(200)
21
22print(b1 == b2)  # False
23print(b1 < b2)   # True

निम्नलिखित मैजिक मेथड्स भी हैं:। ये मैजिक मेथड्स वस्तुओं के बीच समानता और क्रम जैसी तुलना को परिभाषित करते हैं।

ऑपरेटर मैजिक मेथड
== __eq__
!= __ne__
< __lt__
<= __le__
> __gt__
>= __ge__

कंटेनर टाइप्स के लिए मैजिक मेथड्स

आप ऐसी क्लासें बना सकते हैं जो लिस्ट या डिक्शनरी की तरह व्यवहार करती हैं।

__len__: एलिमेंट्स की संख्या प्राप्त करना

__len__ एक मैजिक मेथड है जो एलिमेंट्स की संख्या लौटाता है।

1class Basket:
2    def __init__(self, items):
3        self.items = items
4
5    def __len__(self):
6        return len(self.items)
7
8basket = Basket(["apple", "banana"])
9print(len(basket))  # 2

__getitem__: इंडेक्स द्वारा एक्सेस

__getitem__ मेथड इंडेक्स से एक्सेस करने पर कॉल होता है।

1class Basket:
2    def __init__(self, items):
3        self.items = items
4
5    def __getitem__(self, index):
6        return self.items[index]
7
8basket = Basket(["apple", "banana"])
9print(basket[1])  # banana

__setitem__ और __delitem__: लिखना और हटाना

__setitem__ और __delitem__ मेथड्स आइटम लिखते या हटाते समय कॉल होती हैं।

 1class Basket:
 2    def __init__(self, items):
 3        self.items = items
 4
 5    def __setitem__(self, index, value):
 6        self.items[index] = value
 7
 8    def __delitem__(self, index):
 9        del self.items[index]
10
11basket = Basket(["apple", "banana"])
12basket[1] = "grape"
13del basket[0]
14print(basket.items)  # ['grape']

पुनरावृत्ति (इटेरेशन) के लिए मैजिक मेथड्स

किसी वस्तु को for लूप में इटेरेबल बनाने के लिए, निम्नलिखित को लागू करें:।

__iter__ और __next__

 1class Counter:
 2    def __init__(self, limit):
 3        self.limit = limit
 4        self.current = 0
 5
 6    def __iter__(self):
 7        return self
 8
 9    def __next__(self):
10        if self.current >= self.limit:
11            raise StopIteration
12        self.current += 1
13        return self.current
14
15for num in Counter(3):
16    print(num)
17# Output:
18# 1
19# 2
20# 3

कॉण्टेक्स्ट मैनेजर (with स्टेटमेंट)

__enter__ और __exit__ मेथड्स को परिभाषित कर के आप with स्टेटमेंट के लिए पूर्व और पश्च-प्रोसेसिंग लागू कर सकते हैं।

 1class FileOpener:
 2    def __init__(self, filename):
 3        self.filename = filename
 4
 5    def __enter__(self):
 6        self.file = open(self.filename, 'r')
 7        return self.file
 8
 9    def __exit__(self, exc_type, exc_val, exc_tb):
10        self.file.close()
11
12with FileOpener("example.txt") as f:
13    content = f.read()
14    print(content)

कॉल करने योग्य ऑब्जेक्ट्स: __call__

__call__ मेथड को परिभाषित कर आप किसी इंस्टेंस को फंक्शन की तरह कॉल कर सकते हैं।

1class Greeter:
2    def __init__(self, greeting):
3        self.greeting = greeting
4
5    def __call__(self, name):
6        return f"{self.greeting}, {name}!"
7
8hello = Greeter("Hello")
9print(hello("Alice"))  # Hello, Alice!

सारांश

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

मैजिक मेथड्स एक 'अदृश्य इंटरफेस' के रूप में कार्य करते हैं, जो पर्दे के पीछे पायथन ऑब्जेक्ट्स के आपसी संपर्क और व्यवहार का समर्थन करते हैं।

आप हमारे YouTube चैनल पर Visual Studio Code का उपयोग करके ऊपर दिए गए लेख के साथ आगे बढ़ सकते हैं। कृपया YouTube चैनल को भी देखें।

YouTube Video