Dunder methods ("double underscore," जिन्हें magic/special methods भी कहा जाता है) विशेष रूप से नामित methods हैं जैसे __init__, , जो आपके objects को Python के के साथ एकीकृत होने देते हैं। Python उन्हें syntax के जवाब में स्वचालित रूप से कॉल करता है — उदाहरण के लिए, को कॉल करता है।
__str____len__len(obj)obj.__len__()class Vector:
def __init__(self, x, y): # constructor — Vector(1, 2)
self.x, self.y = x, y
def __repr__(self): # repr(v) and the REPL — for developers
return f"Vector({self.x}, {self.y})"
def __str__(self): # str(v) / print(v) — for users
return f"({self.x}, {self.y})"
def __add__(self, other): # enables the + operator: v1 + v2
return Vector(self.x + other.x, self.y + other.y)
def __eq__(self, other): # enables ==
return self.x == other.x and self.y == other.y
v1, v2 = Vector(1, 2), Vector(3, 4)
v1 + v2 # Vector(4, 6) — calls __add__
print(v1) # (1, 2) — calls __str__
v1 == Vector(1, 2) # True — calls __eq__
इन्हें परिभाषित करने से आपके custom objects native syntax (+, ==, print) के साथ बिल्कुल built-in types की तरह काम करते हैं।
__init__ → constructor (object creation)
__repr__ → unambiguous developer representation (debugging, REPL)
__str__ → readable user-facing string (print, str())
__len__ → len(obj)
__getitem__→ obj[key] (indexing/subscripting)
__iter__ / __next__ → make an object iterable (for loops)
__eq__, __lt__, __gt__ → comparison operators (==, <, >)
__add__, __sub__, __mul__ → arithmetic operators
__call__ → make an instance callable like a function: obj()
__contains__ → the `in` operator
__enter__ / __exit__ → context managers (with statement)
class Deck:
def __init__(self): self.cards = [...]
def __len__(self): return len(self.cards) # len(deck)
def __getitem__(self, i): return self.cards[i] # deck[0], and iteration/slicing!
deck = Deck()
len(deck) # works
for card in deck: # __getitem__ makes it iterable too
...
__len__ और __getitem__ को लागू करने से object एक sequence की तरह व्यवहार करता है — len(), indexing, iteration और slicing का समर्थन करता है।
Dunder methods वह तरीका हैं जिससे Python अपना सुसंगत, "everything is an object" अनुभव प्राप्त करता है — वे आपकी custom classes को भाषा के operators और built-in functions (+, ==, len(), for, [], with, print) के साथ निर्बाध रूप से एकीकृत होने देते हैं।
यह Python के सुरुचिपूर्ण, polymorphic design ("duck typing" + data model) की नींव है।
प्रमुख dunders को जानना — विशेष रूप से __init__, __repr__/__str__, comparison और arithmetic operators, और iteration protocol — आपको सहज, Pythonic classes बनाने देता है जो native types जैसी महसूस होती हैं, और यह समझाता है कि भाषा का syntax अंदरूनी रूप से method calls पर कैसे map होता है।