पाठ्यक्रम 250 में से पाठ 52 · ऑब्जेक्ट-ओरिएंटेड Python
ऑब्जेक्ट-ओरिएंटेड Python

Dunder मेथड

Python में दोहरे अंडरस्कोर में लिपटे ख़ास मेथड नाम हैं, जिन्हें बोलकर dunder मेथड कहते हैं। आप __init__ से मिल चुके हैं। दूसरे आपके ऑब्जेक्ट को print, बराबरी और sort जैसे बिल्ट-इन ऑपरेशनों के साथ स्वाभाविक रूप से काम करने देते हैं।

प्रिंटिंग: __str__ और __repr__

__str__ नियंत्रित करता है कि print() और str() क्या दिखाते हैं। __repr__ डेवलपर के लिए वाला रूप है, जो इंटरैक्टिव शेल में और सूचियों के अंदर इस्तेमाल होता है। अच्छी आदत है कम से कम एक परिभाषित करना।

class Money:
    def __init__(self, cents):
        self.cents = cents

    def __str__(self):
        return f"${self.cents / 100:.2f}"

    def __repr__(self):
        return f"Money({self.cents})"

m = Money(150)
print(m)        # $1.50
print(repr(m))  # Money(150)

बराबरी: __eq__

डिफ़ॉल्ट रूप से दो ऑब्जेक्ट तभी बराबर हैं जब वे सचमुच एक ही ऑब्जेक्ट हों। __eq__(self, other) आपको इसके बजाय मान से तुलना करने देता है।

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __eq__(self, other):
        return self.x == other.x and self.y == other.y

print(Point(1, 2) == Point(1, 2))   # True

__eq__ के साथ एक पेच भी आता है: जैसे ही आप इसे परिभाषित करते हैं, Python __hash__ को None पर सेट कर देता है, इसलिए आपके ऑब्जेक्ट unhashable हो जाते हैं। अगर फिर आप किसी को set में डालें या dict की कुंजी के रूप में इस्तेमाल करें तो आपको TypeError: unhashable type: 'Point' मिलता है। कारण एक नियम है जिस पर Python निर्भर करता है, कि बराबर ऑब्जेक्ट का hash एक जैसा होना चाहिए, इसलिए जब आप बराबरी दोबारा परिभाषित करते हैं तो यह आपको जानबूझकर फिर से चुनने को कहता है। अगर आपको इसकी ज़रूरत है, तो उन्हीं फ़ील्ड से बना मेल खाता __hash__ जोड़ें जिनकी आप तुलना करते हैं, या एक frozen dataclass इस्तेमाल करें (@dataclass वाले पाठ में) जो दोनों आपके लिए लिखती है।

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __eq__(self, other):
        return self.x == other.x and self.y == other.y

    def __hash__(self):
        return hash((self.x, self.y))   # same fields as __eq__

print(len({Point(1, 2), Point(1, 2)}))   # 1, and no TypeError

क्रम: __lt__

__lt__(self, other) छोटे-से वाला नियम परिभाषित करता है, जो sorted() को आपके ऑब्जेक्ट sort करने देने के लिए काफ़ी है।

class Score:
    def __init__(self, points):
        self.points = points

    def __lt__(self, other):
        return self.points < other.points

    def __repr__(self):
        return f"Score({self.points})"

print(sorted([Score(3), Score(1), Score(2)]))
# [Score(1), Score(2), Score(3)]
आपकी बारी

एक क्लास Temp परिभाषित करें जो __init__ से self.degrees रखे। "20C" जैसी स्ट्रिंग (संख्या के बाद C) लौटाने वाला __str__, __eq__ ताकि दो तापमान तब बराबर हों जब उनके degrees मेल खाएँ, और degrees से तुलना करने वाला __lt__ जोड़ें ताकि तापमानों की सूची sort हो सके।

इस पाठ में कोई समस्या दिखी? बताएँ · इस पाठ के बारे में पूछें

यह अभ्यास जल्द खुलेगा

इससे पहले वाला पाठ पूरा करें और यह खुल जाएगा। पूरा कोर्स मुफ़्त है, कोई खाता नहीं चाहिए, और आप यह पाठ अभी पढ़ सकते हैं।