Dunder methods ("ਡਬਲ ਅਂਡਰਸਕੋਰ," ਜਿਨ੍ਹਾਂ ਨੂੰ magic/special methods ਵੀ ਕਿਹਾ ਜਾਂਦਾ ਹੈ) ਵਿਸ਼ੇਸ਼ ਤਰੀਕੇ ਹਨ ਜਿਵੇਂ __init__, __str__, ਜੋ ਤੁਹਾਡੀਆਂ ਆਬਜੈਕਟਾਂ ਨੂੰ Python ਦੇ ਨਾਲ ਏਕੀਕ੍ਰਿਤ ਕਰਨ ਦਿੰਦੇ ਹਨ। Python ਉਹਨਾਂ ਨੂੰ ਸਿੰਟੈਕਸ ਦੇ ਜਵਾਬ ਵਿੱਚ ਆਪਣੇ ਆਪ ਕਾਲ ਕਰਦਾ ਹੈ — ਉਦਾਹਰਣ ਦੇ ਲਈ ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ।
__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__
ਇਹਨਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨਾ ਤੁਹਾਡੀਆਂ ਕਸਟਮ ਆਬਜੈਕਟਾਂ ਨੂੰ ਨੇਟਿਵ ਸਿੰਟੈਕਸ (+, ==, print) ਨਾਲ ਕੰਮ ਕਰਨ ਦਿੰਦਾ ਹੈ ਬਿਲਕੁਲ ਬਿਲਟ-ਇਨ ਟਾਈਪਾਂ ਵਾਂਗ।
__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__ ਨੂੰ ਲਾਗੂ ਕਰਨਾ ਆਬਜੈਕਟ ਨੂੰ ਇੱਕ ਸਿਲਸਿਲੇ ਵਾਂਗ ਵਿਵਹਾਰ ਕਰਾਉਂਦਾ ਹੈ — len(), indexing, iteration, ਅਤੇ slicing ਨੂੰ ਸਮਰਥਨ ਦਿੰਦਾ ਹੈ।
Dunder methods ਉਹ ਤਰੀਕਾ ਹੈ ਜਿਸ ਨਾਲ Python ਇਸ ਦੀ ਲਗਾਤਾਰ, "ਸਭ ਕੁਝ ਇੱਕ ਆਬਜੈਕਟ ਹੈ" ਭਾਵਨਾ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ — ਉਹ ਤੁਹਾਡੀਆਂ ਕਸਟਮ ਕਲਾਸਾਂ ਨੂੰ ਭਾਸ਼ਾ ਦੇ ਆਪਰੇਟਰਾਂ ਅਤੇ ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨਾਂ (+, ==, len(), for, [], with, print) ਨਾਲ ਸੁਚਾਣੂ ਢੰਗ ਨਾਲ ਏਕੀਕ੍ਰਿਤ ਕਰਨ ਦਿੰਦੇ ਹਨ।
ਇਹ Python ਦੇ ਸੁੰਦਰ, polymorphic ਡਿਜ਼ਾਇਨ ("duck typing" + ਡਾਟਾ ਮਾਡਲ) ਦੀ ਬਨਿਆਦ ਹੈ।
ਮੁੱਖ dunders ਨੂੰ ਜਾਣਨਾ — ਖਾਸ ਕਰ __init__, __repr__/__str__, ਤੁਲਨਾ ਅਤੇ ਰਿਐਮਟਿਕ ਆਪਰੇਟਰ, ਅਤੇ iteration protocol — ਤੁਹਾਨੂੰ ਸਹਿਜ, Pythonic ਕਲਾਸਾਂ ਬਣਾਉਣ ਦਿੰਦਾ ਹੈ ਜੋ ਨੇਟਿਵ ਟਾਈਪਾਂ ਵਾਂਗ ਲੱਗਦੀਆਂ ਹਨ, ਅਤੇ ਸਮਝਾਉਂਦਾ ਹੈ ਕਿ ਭਾਸ਼ਾ ਦਾ ਸਿੰਟੈਕਸ ਕਿਵੇਂ ਹੁੱਡ ਦੇ ਤਹਿਤ ਵਿਧੀ ਕਾਲਾਂ ਨਾਲ ਮੰਜਿਤ ਹੁੰਦਾ ਹੈ।