पायथन में मैजिक मेथड्स
यह लेख पायथन में मैजिक मेथड्स को समझाता है।
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 चैनल को भी देखें।