5.3 מתודות קסם הרצאה

מתודות קסם

• מתודת קסם היא מתודה מיוחדת בפייתון, שאנחנו יכולים להשתמש בה כדי לשנות את ההתנהגות של המחלקה שלנו.
• בפיתון יש לנו כמה מתודות קסם (magic methods) מוגדרות שאנו יכולים להגדיר בהגדרת המחלקה שלנו כדי לשנות את ההתנהגות של המחלקה שלנו
• כמה דוגמאות למתודות קסם:

יצירה

• __init__(self, ...): המתודה הזו נקרא כאשר יוצרים אובייקט חדש של המחלקה, מטרת המתודה היא לאתחל את אובייקט.
• בדרך כלל הפונקציה הזו מקבלת פרמטרים שמטרתם לאתחל את האובייקט

דוגמה:

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

obj = MyClass(10)
obj.value

1. __del__(self): מתודה זו נקראת כאשר האובייקט נהרס.
2. האובייקט נהרס כשהוא יוצא מסקופ
   דוגמה:
   

   class MyClass:
       def __del__(self):
           print("Object deleted")
   
   def function():
       obj = MyClass()
   
   function()
   
   obj = MyClass()
   del obj
   

עיצוב

1. __doc__: שדה זה מחזיר את מחרוזת התיעוד של המחלקה או הפונקציה.

דוגמה:

class MyClass:
    """This is a sample class."""
    pass

print(MyClass.__doc__)

1. __str__(self): מתודה זו מחזירה את המחרוזת של האובייקט כאשר מנסים להפוך אותו למחרוזת.
2. היא נקראת כאשר אתה משתמש בפונקציה str או בפונקציה print על האובייקט.

דוגמה:

class MyClass:
    def __str__(self):
        return "This is MyClass object"

obj = MyClass()
print(str(obj))
print(obj)

1. __repr__(self): מתודה זו דומה למתודה הקודמת, רק שמשתמשים בה בדרך כלל כדי ליצג מידע על האובייקט,

דוגמה:

class MyClass:
    def __repr__(self):
        return "MyClass()"

obj = MyClass()
print(repr(obj))

פעולות מתמטיות

1. __add__(self, other): מתודה זו נקראת כאשר האופרטור + משומש עם שני אובייקטים. היא מגדירה את ההתנהגות של הפעולה חיבור עבור אובייקטים של המחלקה.

דוגמה:

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

    def __add__(self, other):
        return Point(self.x + other.x, self.y + other.y)

p1 = Point(1, 2)
p2 = Point(3, 4)
result = p1 + p2
print(result.x, result.y)

1. __sub__(self, other): מתודה זו נקראת כאשר האופרטור - משומש עם שני אובייקטים. היא מגדירה את ההתנהגות של הפעולה חיסור עבור אובייקטים של המחלקה.

דוגמה:

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

    def __sub__(self, other):
        return Point(self.x - other.x, self.y - other.y)

p1 = Point(5, 7)
p2 = Point(2, 3)
result = p1 - p2
print(result.x, result.y)

1. __mul__(self, other): מתודה זו נקראת כאשר האופרטור * משומש עם שני אובייקטים. היא מגדירה את ההתנהגות של הפעולה כפל עבור אובייקטים של המחלקה.

דוגמה:

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

    def __mul__(self, other):
        return self.value * other.value

obj1 = MyClass(5)
obj2 = MyClass(10)
result = obj1 * obj2
print(result)

- יש מתודות קסם לכל האופרטורים בפייתון.

ביטויים בוליאניים

1. __eq__(self, other): מתודה זו נקראת כאשר האופרטור == משומש להשוואת שני אובייקטים.

דוגמה:

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

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

obj1 = MyClass(5)
obj2 = MyClass(5)
print(obj1 == obj2)

1. __ne__(self, other): מתודה זו נקראת כאשר האופרטור != משומש להשוואת שני אובייקטים.

דוגמה:

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

    def __ne__(self, other):
        return self.value != other.value

obj1 = MyClass(5)
obj2 = MyClass(10)
print(obj1 != obj2)

1. __ge__(self, other), __le__(self, other), __lt__(self, other): כל מתודות אלו נקראות כאשר האופרטורים >=, <=, ו־< משומשים להשוואת שני אובייקטים.

דוגמה:

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

    def __ge__(self, other):
        return self.value >= other.value

    def __le__(self, other):
        return self.value <= other.value

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

obj1 = MyClass(5)
obj2 = MyClass(10)
print(obj1 >= obj2)
print(obj1 <= obj2)
print(obj1 < obj2)

מנהל הקשר - context manager

1. __enter__(self): מתודה זו נקראת כאשר האובייקט נכנס למנהל הקשר.

2. __exit__(self, exc_type, exc_value, traceback): מתודה זו נקראת כאשר האובייקט יוצא ממנהל הקשר

דוגמה:

class MyContextManager:
    def __enter__(self):
        print("Entering the context")
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        print("Exiting the context")

with MyContextManager() as obj:
    print("Inside the context")
# Output:
# Entering the context
# Inside the context
# Exiting the context

הכל זה אובייקטים

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

דוגמה:

def func(x):
    return x + 1

dir(func)
type(func)  # "function"

import module

dir(module)
type(module)

class MyClass:
    def __init__(self):
        return 

obj = MyClass()  # __main__.MyClass
dir(obj)
type(obj)

x = 3
dir(x)
type(x)

dir()  # Returns members of the current module

הגדרת פונקציה עם מחלקה

__call__ - מגדירה מה יקרה אם האובייקט נקרא כמו פונקציה.

דוגמה:

class FunctionAsClass:
    def __call__(self, x):
        return x ** 2

# יצירת מופע של המחלקה
square_function = FunctionAsClass()

# קריאה למופע כאילו זה פונקציה
result = square_function(4)
print(result)  # פלט: 16

• כך אנוחנו יכולים להגדיר פונקציות עם מחלקות.

מודולים

• כדי לראות את הממברים של המודול הנוכחי, נוכל פשוט להריץ את dir
  

  dir()
  

  
  __name__ - מחזיר את שם המודול
  __builtins__ - מחזיר רשימה של כל הפונקציות המובנות של פייתון

שדות קסם של אובייקטים

__dict__ - מחזיק מילון של כל השדות של האובייקט
__dir__ - מתודה שמחזירה רשימה של כל הממברים

dog = Dog(name="max", age=3)
print(dog.__dict__)
print(dog.__dir__())
print(dir(dog))

hasattr - בודק אם יש לאובייקט ממבר מסוים
getattr - גישה לממבר מסוים

dog = Dog(name="max", age=3)
print(hasattr(dog, "bark"))
print(getattr(dog, "name"))

יש עוד המון

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