जादूई मेथड्स

Python में, जादूई मेथड्स विशेष मेथड्स होते हैं जिन्हें आप अपनी क्लास में नई कार्यक्षमता जोड़ने के लिए परिभाषित कर सकते हैं। इन्हें डंडर मेथड्स (dunder methods) के नाम से भी जाना जाता है, क्योंकि इनके नाम के आगे और पीछे दोहरे अंडरस्कोर __ होते हैं। आप इन मेथड्स में से दो से पहले ही मिल चुके हैं: __init__ और __str__। एक सरल उदाहरण देखें:

class Circle:
    def __init__(self, radius):                     # ऑब्जेक्ट को इनिशियलाइज़ करें
        self.radius = radius

    def __str__(self):                              # स्ट्रिंग के रूप में प्रदर्शित करें
        return f'Circle with radius {self.radius}'

c = Circle(5)    # c नामक Circle ऑब्जेक्ट बनाएँ
print(c)         # Circle with radius 5

इस उदाहरण में, हमने दो जादूई मेथड्स को परिभाषित किया है:

__init__ एक कंस्ट्रक्टर मेथड है जो क्लास का एक उदाहरण बनाने पर कॉल होता है। यहाँ, यह Circle का रेडियस सेट करता है।

__str__ परिभाषित करता है कि क्लास के एक उदाहरण को print() जैसे संदर्भों में स्ट्रिंग में कैसे परिवर्तित किया जाए।

लेकिन ये Python में केवल यही जादूई मेथड्स नहीं हैं। कई और भी हैं। कुछ नीचे प्रस्तुत किए गए हैं जो हमें क्लास के इंस्टैंस को + के साथ जोड़ने या < या > के साथ तुलना करने की क्षमता प्रदान करते हैं:

class Circle:
    def __init__(self, radius):                     # ऑब्जेक्ट को इनिशियलाइज़ करें
        self.radius = radius

    def __str__(self):                              # स्ट्रिंग के रूप में प्रदर्शित करें
        return f'Circle with radius {self.radius}'

    def __add__(self, other):                       # दो सर्कल्स को जोड़ें
        return Circle(self.radius + other.radius)   # नया सर्कल लौटाएँ

    def __lt__(self, other):                        # दो सर्कल्स की तुलना (कम है या नहीं)
        return self.radius < other.radius           # रेडियस की तुलना करें

c1 = Circle(5)
c2 = Circle(7)
c3 = c1 + c2     # यह रेडियस 12 के साथ एक नया Circle बनाएगा
print(c3)        # Circle with radius 12
print(c1 < c2)   # True

इस स्थिति में:

__add__ हमें Circle इंस्टैंस के साथ + ऑपरेटर का उपयोग करने की अनुमति देता है। यह सर्कल्स के रेडियस को जोड़ता है और एक नया Circle लौटाता है।

__lt__ (लेस दैन) हमें < ऑपरेटर के साथ दो Circle इंस्टैंस की तुलना करने की अनुमति देता है। यह जांचता है कि पहले सर्कल का रेडियस दूसरे सर्कल के रेडियस से कम है या नहीं।

जादूई मेथड्स हमारी Python क्लासों को अधिक अभिव्यंजक और सहज बनाते हैं, जिससे वे बिल्ट-इन Python ऑब्जेक्ट्स की तरह व्यवहार करते हैं।

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

मैजिक मेथड	ऑपरेटर	विवरण
`__eq__`	`==`	यदि `self` `other` के बराबर है तो `True` लौटाता है।
`__lt__`	`<`	यदि `self` `other` से कम है तो `True` लौटाता है।
`__le__`	`<=`	यदि `self` `other` से कम या बराबर है तो `True` लौटाता है।
`__gt__`	`>`	यदि `self` `other` से बड़ा है तो `True` लौटाता है।
`__ge__`	`>=`	यदि `self` `other` से बड़ा या बराबर है तो `True` लौटाता है।
`__add__(self, other)`	`+`	`+` ऑपरेटर के साथ जोड़ को लागू करता है।
`__sub__(self, other)`	`-`	`-` ऑपरेटर के साथ घटाव को लागू करता है।
`__mul__(self, other)`	`*`	`*` ऑपरेटर के साथ गुणा को लागू करता है।
`__truediv__(self, other)`	`/`	`/` ऑपरेटर के साथ विभाजन को लागू करता है।
`__floordiv__(self, other)`	`//`	`//` ऑपरेटर के साथ फ्लोर डिवीजन को लागू करता है।
`__mod__(self, other)`	`%`	`%` ऑपरेटर के साथ मॉड्यूलस को लागू करता है।
`__pow__(self, other)`	`**`	`**` पावर ऑपरेटर को लागू करता है।
`__abs__(self)`	`abs()`	इन-बिल्ट `abs()` फ़ंक्शन के लिए व्यवहार को लागू करता है।
`__round__(self, n)`	`round()`	इन-बिल्ट `round()` फ़ंक्शन के लिए व्यवहार को लागू करता है।
`__neg__(self)`	`-`	यूनरी `-` ऑपरेटर के साथ निगेशन को लागू करता है।

💡

ध्यान दें कि सभी मेथड्स सभी क्लासों के लिए सार्थक नहीं होते; आपको केवल वही मेथड्स लागू करने चाहिए जो आपकी समस्या के लिए उपयोगी हों।

चुनौती: एक Vector क्लास बनाएं

आपसे एक क्लास, Vector, परिभाषित करने को कहा गया है, जो x, y, और z गुणों के साथ तीन-आयामी वेक्टर का प्रतिनिधित्व करता है।

इस क्लास में विशेष मेथड्स __add__, __sub__ और __mul__ का कार्यान्वयन शामिल होना चाहिए, जो क्रमशः वेक्टरों का जोड़, घटाव और डॉट प्रोडक्ट करते हैं।

इनके अलावा, एक मेथड magnitude भी लागू करें, जो वेक्टर की परिमाण (लंबाई) की गणना करता है।

अनुरोधित मेथड्स:

__add__: यह मेथड एक अन्य Vector ऑब्जेक्ट को स्वीकार करना चाहिए और एक नया Vector लौटाना चाहिए, जो दो वेक्टरों के x, y, और z घटकों के जोड़ का परिणाम है।

__sub__: यह मेथड एक अन्य Vector ऑब्जेक्ट को स्वीकार करना चाहिए और एक नया Vector लौटाना चाहिए, जो पहले वेक्टर से दूसरे वेक्टर के x, y, और z घटकों के घटाव का परिणाम है।

__mul__: यह मेथड एक अन्य Vector ऑब्जेक्ट को स्वीकार करना चाहिए और वेक्टरों का डॉट प्रोडक्ट लौटाना चाहिए, जो निम्नानुसार गणना किया गया है: $$(x1 \cdot x2) + (y1 \cdot y2) + (z1 \cdot z2)$$।

magnitude: यह मेथड वेक्टर की परिमाण (लंबाई) लौटाना चाहिए, जो निम्नानुसार गणना किया गया है: $$\sqrt{x^2 + y^2 + z^2}$$।

इनपुट	आउटपुट
`v1 = Vector(1, 2, 3); v2 = Vector(4, 5, 6); v3 = v1 + v2; v4 = v1 - v2; print(v1 * v2); print(v1.magnitude()); v4 = Vector(-3, -3, -3)`	32 3.74165

चुनौती: एक Vector क्लास बनाएं

Constraints

To check your solution you need to sign in

Sign in to continue