מתודות ותכונות קסם בפייתון

מתודות קסם, magic methods, מתודות מיוחדות, dunder methods (קיצור של  double underscoremethods) כולם שמות לקבוצה של פונקציות פייתוניות שמספקות התנהגות מיוחדת.

כל מי שיש לו אפילו ידע מינימלי על תכנות מונחה עצמים בפייתון מכיר את המתודה __init__ המהווה קונסטרקטור שפייתון קורא לו מיד עם ייסוד אובייקט מהקלאס. וכל מי שלא יודע או לא זוכר את הנושא מוזמן לקרוא את המדריך הראשון בסדרה על תכנות מונחה עצמים בפייתון.

לדוגמה הקלאס הבא:

class MyClass:
    """
    Toy class to demonstrate Python magic methods
    """
    def __init__(self, value):
        self.my_val = value

אפשר לראות שזו מתודה מיוחדת כי היא מתחילה ומסיימת בשני קווים תחתונים. עוד דבר שהופך אותה למיוחדת זו העובדה שאפשר להשתמש בה בלי לקרוא בשמה. לדוגמה, אנחנו מייסדים אובייקט מהקלאס כך:

my_obj = MyClass('something')

ולא כך:

my_obj = MyClass.__init__('something')

ולמרות שאנחנו לא קוראים למתודה באופן מפורש פייתון יודע להשתמש במתודה כדי לאתחל את ערך השדות של האובייקט.

__init__ היא דוגמה אחת בסיסית לשימוש במתודות קסם אבל יש מתודות נוספות. כדי לראות חלק מהם נריץ את הקוד הבא:

print(dir(MyClass))

התוצאה:

['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__']

מתוך הרשימה הארוכה לעיל ננסה את תכונת הקסם __doc__ על הקלאס:

print(MyClass.__doc__)

התוצאה:

Toy class to demonstrate Python magic methods

• היא התיעוד המופיע בתוך הקלאס.

צריך לשים לב שהרשימה שניפקה המתודה dir מורכבת ממתודות קסם וגם מתכונות קסם. __doc__ היא דוגמה לתכונת קסם, ו-__init__ זו דוגמה למתודת קסם.

כאשר המתודה __dir__ היא עצמה מתודת קסם:

dir(my_obj)

• במתודת קסם נוח יותר להשתמש ללא הקווים התחתונים.

מתודות קסם לייצוג אובייקטים

המתודה __str__ היא מתודת קסם. היא משמשת להגדיר את הייצוג הטקסטואלי של קלאס. מתודת הקסם __str__ מופעלת אוטומטית כאשר נדפיס אובייקט של הקלאס באמצעות הפונקציה print().

נדגים את פעולת __str__ על הקלאס:

obj = MyClass(42)
print(obj)  # prints: __main__.MyClass object at 0x7fc84c5b5250

• הפלט ברירת המחדל מצביע על סוג האובייקט ועל מקום בזיכרון. לרוב זה לא מה שאנחנו רוצים.

בדרך כלל אנחנו רוצים ש- __str__ ידפיס לקונסולה אינפורמציה ידידותית למתכנת אודות הפונקציה. אז מה שאנחנו יכולים לעשות הוא לדרוס את המתודה המיוחדת __str__ כדי לגרום לה להדפיס את המידע הרצוי. נוסיף את המתודה __str__ לקלאס כדי לדרוס את ההתנהגות ברירת המחדל שמביא איתו פייתון:

class MyClass:
    def __init__(self, value):
        self.value = value

    def __str__(self):
        return f"MyClass instance with value {self.value}"

נדפיס את האובייקט לאחר עריכת הקוד:

obj = MyClass(42)
print(obj)

התוצאה:

MyClass instance with value 42

• אינפורמטיבית יותר.

נסכם, כאשר אנו מדפיסים את האובייקט 'obj' מתודת הקסם __str__ נכנסת לפעולה, והייצוג הטקסטואלי של הפונקציה מודפס בתור פלט. פייתון נותן התנהגות ברירת מחדל למתודה. אנחנו יכולים לשנות את ההתנהגות הזו כדי לקבל את המידע שאנחנו מצפים לו.

מתודת קסם נוספת שגם היא מספקת מידע טקסטואלי על אודות הקלאס היא __repr__, ובזה יעסוק חלקו הבא של המדריך.

שימוש במתודת הקסם __repr__

נשתמש במתודה __repr__ כדי לייצג אובייקט באופן שניתן להשתמש בייצוג כדי לשחזר את האובייקט.

דוגמה לשימוש במתודה __repr__:

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

    def __repr__(self):
        return f"Person('{self.name}', {self.age})"

לקלאס 'Person' בדוגמה לעיל יש מתודה __repr__ שמחזירה ייצוג טקסטואלי של אובייקט שניתן ליצור ממנו. לדוגמה:

person = Person("Moshe",28)
print(repr(person)) # Output: Person('Moshe', 28)

אפשר לראות, שניתן להשתמש בפלט המתודה __repr__ כדי ליצור אובייקט של 'Person' כולל הפרמטרים החיוניים לצורך הגדרת האובייקט הספציפי מן הקלאס.

שים לב שהמתודה __repr__ היא שונה מהמתודה __str__. במתודה __str__ נשתמש להגדיר ייצוג טקסטואלי של האובייקט ללא קונבנציות מיוחדות ובצורה חופשית למדי, השימוש ב-__repr__ מצריך שפלט הפונקציה יוכל לשמש מפתחים לצורך פיתוח ובדיקה של הקוד.

מתודות קסם לביצוע פעולות חשבון

מהתיעוד הרשמי של פייתון אפשר ללמוד המון על מתודות קסם. לדוגמה, האם ידעת שביצוע פעולות חשבון מפעיל מאחורי הקלעים מתודות קסם? קח למשל את הביטוי הבא:

1 + 1

פייתון יודע שעליו להוסיף את האובייקט הראשון לשני בזכות הפעלת מתודת הקסם __add__ מאחורי הקלעים.

כמו שאנחנו יכולים להשתמש בהתנהגות ברירת המחדל של סימן החיבור בפייתון אנחנו יכולים לדרוס את התנהגות המתודה כרצוננו.

נחזור לקלאס 'Person'. ננסה לחבר את המשקלים של שני אובייקטים בצורה נאיבית באמצעות "+":

class Person:
   def __init__(self, name, weight):
       self.name = name
       self.weight = weight




person1 = Person("Moshe",72)
person2 = Person("Moshit",59)


combined_weight = person1 + person2

והתוצאה היא הודעת שגיאה:

TypeError: unsupported operand type(s) for +: 'Person' and 'Person'

• זה לא מה שאנחנו רוצים.

נדרוס את מתודת הקסם __add__ כדי שפייתון ידע לחבר את המשקלים:

class Person:
   def __init__(self, name, weight):
       self.name = name
       self.weight = weight


   def __add__(self, other):
       return self.weight + other.weight






person1 = Person("Moshe",72)
person2 = Person("Moshit",59)




combined_weight = person1 + person2
print(combined_weight)

התוצאה:

131

כשיש לנו מתודת קסם עם יחסים בין שני גורמים נעביר לה שני ארגומנטים: self, בשביל האובייקט הנוכחי, ו- other בשביל האובייקט האחר:

def __add__(self, other):
       return self.weight + other.weight

פעולות חשבון שהם למעשה מתודות קסם שניתן לדרוס כדי לקבל את ההתנהגות הרצויה. הם:

object.__add__(self, other)
object.__sub__(self, other)
object.__mul__(self, other)
object.__pow__(self, other[, modulo])

אילו רק דוגמאות בסיסיות. כדאי לעיין ברשימה המלאה באתר פייתון.

מתודות קסם המשמשות להשוואה

יש מתודות קסם המשמשות להשוואה:

object.__lt__(self, other)
object.__le__(self, other)
object.__eq__(self, other)
object.__ne__(self, other)
object.__gt__(self, other)
object.__ge__(self, other)

המתודה __eq__ בודקת שוויון. המתודה __lt__ בודקת האם קטן יותר. __le__ האם קטן או שווה. תוצאת ההשוואה היא בוליאנית True או False.

נדרוס את המתודה __eq__ של הקלאס 'Person' כדי שתבדוק האם המשקלים של שני אנשים שווים:

class Person:
   def __init__(self, name, weight):
       self.name = name
       self.weight = weight


   def __eq__(self, other):
       return self.weight == other.weight

נבדוק:

person1 = Person("Moshe",72)
person2 = Person("Moshit",59)




if person1 == person2:
   print("The objects weigh the same")
else:
   print("The objects don't have the same weight")

התוצאה:

The objects don't have the same weight

סיכום מקסים

מתודות קסם של פייתון יכולות להעניק תכונות נסתרות לקלאסים שלך, ולהתאים את התנהגות המתודות. החל מהתאמת פעולות חשבון פשוטות לצרכים שלך ועד להכתבה כיצד האובייקטים שלך מיוצגים. אבל כמו כל קסם, עליך להיזהר בשימוש. למרות שהמתודות יכולות להפוך את הקוד שלך לאלגנטי וגמיש, שימוש עודף או לא נכון, יהפוך את הקוד שלך למבוך מפותל שקשה לצאת ממנו. לכן, כשאתה משתמש במתודות קסם הקפד על שימוש נבון, ועל בהירות ופשטות כעקרונות מנחים.

זכור תמיד, יש להשתמש במתודות קסם כדי לפתור בעיות אמיתית, לא כדי לעשות רושם. אילו כלי נשק רבי עוצמה אז השתמש בהם באחריות.

אז בפעם הבאה שאתה מוצא את עצמך עומד בפני אתגר קידודי, זכור את כוחם החבוי של מתודות הקסם. רתום את הפוטנציאל הטמון בהם בחוכמה, וראה את הקוד שלך נוסק לגבהים חדשים, מטיל כישוף של יעילות, אקספרסיביות וקסם פייתוני.

מדריכים נוספים בסדרה ללימוד פייתון

פייתון מונחה עצמים 1: מחלקות, אובייקטים, תכונות ומתודות

דקורטורים של פייתון : דפוס, הבנה ויישום הלכה למעשה

למה ואיך לעבוד עם סביבה וירטואלית בפייתון

לכל המדריכים בסדרה ללימוד פייתון

אהבתם? לא אהבתם? דרגו!

0 הצבעות, ממוצע 0 מתוך 5 כוכבים