متدهای جادویی (dunder) در پایتون — آموزش کامل

🗺️ نقشه راه آموزش متدهای جادویی پایتون

class Car:
    def __init__(self, brand, model, year):
        self.brand = brand
        self.model = model
        self.year = year
        print(f"A new car ({self.brand} {self.model}) has been created!")

my_car = Car("Toyota", "Camry", 2022)
# Output: A new car (Toyota Camry) has been created!
print(my_car.brand)
# Output: Toyota
        

کپی کد

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

    def __str__(self):
        return f"({self.x}, {self.y})" # User-friendly representation

    def __repr__(self):
        return f"Point(x={self.x}, y={self.y})" # Developer-friendly representation

p = Point(10, 20)
print(p)         # Calls __str__ -> (10, 20)
print(f"{p!r}")  # Calls __repr__ -> Point(x=10, y=20)
print(p.__repr__()) # Explicitly calls __repr__ -> Point(x=10, y=20)
        

کپی کد

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

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

    def __add__(self, other):
        if isinstance(other, Vector):
            return Vector(self.x + other.x, self.y + other.y)
        raise TypeError("Can only add Vector to another Vector")

    def __mul__(self, scalar):
        if isinstance(scalar, (int, float)):
            return Vector(self.x * scalar, self.y * scalar)
        raise TypeError("Can only multiply Vector by a scalar (int/float)")

v1 = Vector(2, 3)
v2 = Vector(4, 5)
v3 = v1 + v2
print(v3) # Output: Vector(6, 8)

v4 = v1 * 3
print(v4) # Output: Vector(6, 9)
        

کپی کد

class MyList:
    def __init__(self, items):
        self.items = list(items)

    def __len__(self):
        return len(self.items)

my_list = MyList([1, 2, 3, 4, 5])
print(len(my_list)) # Output: 5
        

کپی کد

class CustomDict:
    def __init__(self):
        self._data = {}

    def __getitem__(self, key):
        print(f"Getting item: {key}")
        return self._data[key]

    def __setitem__(self, key, value):
        print(f"Setting item: {key} = {value}")
        self._data[key] = value

    def __delitem__(self, key):
        print(f"Deleting item: {key}")
        del self._data[key]

    def __len__(self): # You might want __len__ too
        return len(self._data)

my_dict = CustomDict()
my_dict["name"] = "Alice" # Calls __setitem__
print(my_dict["name"])    # Calls __getitem__ -> Output: Getting item: name n Alice
del my_dict["name"]       # Calls __delitem__ -> Output: Deleting item: name
# print(my_dict["name"])  # This would raise KeyError now
        

کپی کد

class ManagedFile:
    def __init__(self, filename, mode):
        self.filename = filename
        self.mode = mode
        self.file = None

    def __enter__(self):
        print("Entering context: Opening file...")
        self.file = open(self.filename, self.mode)
        return self.file

    def __exit__(self, exc_type, exc_val, exc_tb):
        if self.file:
            print("Exiting context: Closing file...")
            self.file.close()
        if exc_type:
            print(f"An exception occurred: {exc_type.__name__}: {exc_val}")
        return False # Propagate the exception if any

with ManagedFile("hello.txt", "w") as f:
    f.write("Hello, Dunder Methods!n")
    # raise ValueError("Something went wrong inside with block!")

print("File operations complete.")
# Expected output (without exception):
# Entering context: Opening file...
# Exiting context: Closing file...
# File operations complete.
        

کپی کد

class AttributeLogger:
    def __setattr__(self, name, value):
        print(f"Setting attribute '{name}' to '{value}'")
        object.__setattr__(self, name, value) # Avoid infinite recursion

    def __getattr__(self, name):
        print(f"Attempting to get non-existent attribute '{name}'")
        return f"Attribute '{name}' not found!"

    def __delattr__(self, name):
        print(f"Deleting attribute '{name}'")
        object.__delattr__(self, name) # Avoid infinite recursion

log_obj = AttributeLogger()
log_obj.my_attr = 10         # Calls __setattr__
print(log_obj.my_attr)       # Normal access, doesn't call __getattr__
print(log_obj.non_existent)  # Calls __getattr__
del log_obj.my_attr          # Calls __delattr__
        

کپی کد

from functools import total_ordering

@total_ordering
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __eq__(self, other):
        if not isinstance(other, Person):
            return NotImplemented
        return self.age == other.age and self.name == other.name

    def __lt__(self, other):
        if not isinstance(other, Person):
            return NotImplemented
        return self.age < other.age # Or any other logic

p1 = Person("Alice", 30)
p2 = Person("Bob", 25)
p3 = Person("Alice", 30)

print(p1 == p3) # True (calls __eq__)
print(p1 == p2) # False
print(p1  p2)  # True (inferred from __lt__ by @total_ordering)
        

کپی کد

class Multiplier:
    def __init__(self, factor):
        self.factor = factor

    def __call__(self, number):
        return number * self.factor

double = Multiplier(2)
triple = Multiplier(3)

print(double(5)) # Output: 10 (calls __call__)
print(triple(5)) # Output: 15
        

کپی کد

نکته مهم: اگه __eq__ رو پیاده‌سازی کنی اما __hash__ رو نه، آبجکتت دیگه به صورت پیش‌فرض hashable نیست. همچنین اگه دو آبجکت == باشن، باید مقدار هش یکسانی داشته باشن.

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

    def __eq__(self, other):
        if not isinstance(other, ImmutablePoint):
            return NotImplemented
        return self.x == other.x and self.y == other.y

    def __hash__(self):
        # A simple way to combine hashes of immutable components
        return hash((self.x, self.y))

p1 = ImmutablePoint(1, 2)
p2 = ImmutablePoint(1, 2)
p3 = ImmutablePoint(3, 4)

my_set = {p1, p3}
print(p2 in my_set) # Output: True (because p1 == p2 and hash(p1) == hash(p2))

my_dict = {p1: "first point"}
print(my_dict[p2]) # Output: first point
        

کپی کد

اشکالاتی که ممکنه بخوری و چطور رفعشون کنی

def __setattr__(self, name, value):
    # logging.info(f"Setting {name} to {value}")
    object.__setattr__(self, name, value) # صحیح
                

❓ دندر متدها چی هستن؟

متدهای جادویی یا دندر متدها (Dunder methods) متدهایی با دو آندرلاین در ابتدا و انتها (مثل __init__) هستند که به شما اجازه می‌دهند رفتار پیش‌فرض عملگرها و توابع داخلی پایتون را برای آبجکت‌های کلاس خودتان شخصی‌سازی کنید.

❓ چرا باید از دندر متدها استفاده کنیم؟

استفاده از دندر متدها باعث می‌شود کدهای شما پایتونیک‌تر و خواناتر شوند. به جای فراخوانی متدهای طولانی، می‌توانید از عملگرهای آشنا و توابع داخلی پایتون (مثل + یا len()) روی آبجکت‌های خودتان استفاده کنید.

❓ تفاوت __str__ و __repr__ چیست؟

__str__ برای تولید یک نمایش کاربرپسند از آبجکت است (مثل خروجی print()). __repr__ برای تولید یک نمایش توسعه‌دهنده-پسند و بدون ابهام است که معمولاً می‌تواند برای بازسازی آبجکت استفاده شود.

❓ چطور می‌توانم آبجکتم را قابل Hash کردن کنم؟

اگر آبجکت شما تغییرناپذیر (immutable) است و نیاز دارید که از آن به عنوان کلید در دیکشنری یا عضو در مجموعه استفاده کنید، باید متد __hash__ را پیاده‌سازی کنید. همچنین، باید مطمئن شوید که اگر دو آبجکت با __eq__ برابرند، __hash__ آن‌ها نیز یکسان باشد.

❓ آیا استفاده از دندر متدها سرعت کد را کم می‌کند؟

در بیشتر موارد، سربار (overhead) استفاده از دندر متدها ناچیز است و تأثیر محسوسی بر عملکرد برنامه شما نخواهد داشت. فواید آن‌ها در خوانایی و پایتونیک بودن کد معمولاً بسیار بیشتر از هرگونه افت عملکرد جزئی است