मैजिक विधियाँ (__str__, __repr__, आदि)

विशेष methods, जिन्हें डबल-अंडरस्कोर methods भी कहा जाता है (यह नाम 'डबल अंडरस्कोर' का संक्षिप्त रूप है), पाइथन में मौजूद ऐसे विशेष methods हैं जो आपको विशिष्ट परिस्थितियों में वस्तुओं के व्यवहार को परिभाषित करने देते हैं।

इस पाठ में आप __str__, __repr__ और अन्य सामान्य विशेष methods का उपयोग करना सीखेंगे।

विशेष methods क्या हैं?

विशेष methods पाइथन में पहले से परिभाषित methods हैं, जिन्हें वस्तुओं पर विशिष्ट संचालन किए जाने पर स्वतः बुलाया जाता है। इन्हें उनके दोहरे अंडरस्कोर से पहचाना जाता है, जैसे __init__ या __str__।

__init__ method एक कंस्ट्रक्टर है जो नई वस्तु को प्रारंभ करता है। वस्तु बनाए जाने पर इसे स्वतः बुलाया जाता है:

# Using the __init__ method to initialize attributes
class Person:
    def __init__(self, name, age):
        self.name = name  # Initialize the name attribute
        self.age = age  # Initialize the age attribute

# Creating an instance of Person
person = Person("Alice", 30)
print(person.name, person.age)  # Outputs: Alice 30

__str__ method यह परिभाषित करता है कि print() बुलाए जाने पर किसी वस्तु का स्ट्रिंग निरूपण कैसा होगा:

# Defining the __str__ method
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __str__(self):
        return f"Name: {self.name}, Age: {self.age}"  # String representation

person = Person("Alice", 30)
print(person)  # Outputs: Name: Alice, Age: 30

__repr__ method किसी वस्तु का आधिकारिक स्ट्रिंग निरूपण उपलब्ध कराता है, जिसका उपयोग अक्सर डीबगिंग के लिए किया जाता है:

# Defining the __repr__ method
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __repr__(self):
        return f"Person('{self.name}', {self.age})"  # Debug-friendly representation

person = Person("Alice", 30)
print(repr(person))  # Outputs: Person('Alice', 30)

आप + या == जैसे ऑपरेटरों के व्यवहार को अनुकूलित करने के लिए विशेष methods का उपयोग कर सकते हैं:

# Overloading the + operator with __add__
class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, other):
        return Point(self.x + other.x, self.y + other.y)  # Adding two points

    def __str__(self):
        return f"({self.x}, {self.y})"

point1 = Point(1, 2)
point2 = Point(3, 4)
result = point1 + point2  # Calls __add__
print(result)  # Outputs: (4, 6)

यहाँ कुछ सामान्यतः उपयोग किए जाने वाले विशेष methods दिए गए हैं:

• __len__: len() फ़ंक्शन के व्यवहार को परिभाषित करता है।
• __getitem__: सूची या शब्दकोश की तरह अनुक्रमण की सुविधा देता है।
• __eq__: == का उपयोग करके समानता तुलना को अनुकूलित करता है।

आप किसी अनुकूलित वस्तु की लंबाई परिभाषित करने के लिए __len__ और उसे अनुक्रमण योग्य बनाने के लिए __getitem__ का उपयोग कर सकते हैं:

# Using __len__ and __getitem__ in a custom class
class CustomList:
    def __init__(self, items):
        self.items = items

    def __len__(self):
        return len(self.items)  # Defines the behavior of len()

    def __getitem__(self, index):
        return self.items[index]  # Enables indexing

custom_list = CustomList([1, 2, 3])
print(len(custom_list))  # Outputs: 3
print(custom_list[1])  # Outputs: 2

यहाँ कुछ ऐसी गलतियाँ दी गई हैं जिनसे बचना चाहिए:

• किसी विशेष method को उसके निर्धारित व्यवहार के अनुरूप न परिभाषित करना।
• बिना आवश्यकता ऑपरेटरों को अधिभारित करना।
• अनुकूलित डेटा प्रकारों में आवश्यक विशेष methods को implementing करना भूल जाना।

हमने क्या सीखा?

इस पाठ में आपने सीखा:

• विशेष methods क्या हैं और वे उपयोगी क्यों हैं।
• __init__, __str__ और __repr__ जैसे सामान्य विशेष methods का उपयोग कैसे किया जाता है।
• विशेष methods का उपयोग करके ऑपरेटरों को अधिभारित करना।

बहुत अच्छा! अब अगले विषय पर चलते हैं।