כיצד להתאים אישית את התנהגות הכיתה ב-Python באמצעות שיטות קסם

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

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

הבנת שיטות קסם

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

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

שיטות קסם הן שיטות מופע ב-Python שיש להן שני קווים תחתונים (__שיטה__) לפני ואחרי שם השיטה.

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

• __gt__: שיטה זו בודקת אם אובייקט אחד גדול מהאחר.
• __init__: שיטה זו פועלת כאשר אתה יוצר מופע של מחלקה, והיא מיועדת בעיקר לאתחול תכונות.
instagram viewer
• __str__: זה מחזיר ייצוג מחרוזת של המחלקה המתארת ​​את האובייקט.
• __repr__: שיטה זו נותנת פלט המאפשר לך ליצור מחדש את האובייקט באמצעות eval().
• __לן__: כאשר אתה משתמש ב- לן() פונקציה על אובייקט שיטה זו מחזירה את אורך האובייקט.
• __eq__: שיטה זו מאפשרת השוואה בין אובייקטים באמצעות הכפול שווה ל (==) מפעיל.
• __lt__: הוא מיישם פחות מ-(
• __לְהוֹסִיף__: כאשר אתה משתמש בתוספת (+) אופרטור על אובייקטים שיטה זו פועלת ומבצעת פעולות הוספה.
• __getitem__: מאפשר לך לאחזר פריטים מאובייקט באמצעות תחביר אינדקס, כמו obj[מפתח].

יישום שיטות קסם

הדרך הטובה ביותר להבין שיטות קסם היא באמצעותן.

ייצוג מחרוזת של אובייקט

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

classPerson:
def__init__(self, name, age):
 self.name = name
 self.age = age
p1 = Person('John', 25)
print(p1)

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

כדי להתאים אישית את ייצוג המחרוזת, הגדר את ה __str__ ו __repr__ שיטות קסם:

classPerson:
def__init__(self, name, age, height):
 self.name = name
 self.age = age
 self.height = height
def__str__(self):
returnf'{self.name} is {self.age} years old'
def__repr__(self):
returnf'{self.name} is {self.age} years old'
p1 = Person('John', 25, 78) 
print(p1)

כעת יש לך ייצוג מחרוזת קריא ומקיף יותר של p1 לְהִתְנַגֵד:

תכונת אורך של אובייקט

תאר לעצמך את זה, כשאתה מתקשר ל לן() שיטה של ​​אובייקט אדם, אתה רוצה את הגובה שלו. יישם את __לן__ שיטת קסם עבור אדם מעמד:

classPerson:
def__init__(self, name, age, height):
 self.name = name
 self.age = age
 self.height = height
def__str__(self):
returnf'{self.name} is {self.age} years old'
def__repr__(self):
returnf'{self.name} is {self.age} years old'
def__len__(self):
return self.height
p2 = Person('Issac', 25, 89) 
print(len(p2))

ה __לן__ שיטת קסם מחזירה את תכונת הגובה של a אדם למשל. כשאתה מתקשר לן (p2), זה יקרא את __לן__ שיטת קסם אוטומטית המחזירה את גובה ה p2 לְהִתְנַגֵד.

טיפול בהשוואה בין אובייקטים

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

classPerson:
def__init__(self, name, age, height):
 self.name = name
 self.age = age
 self.height = height
def__str__(self):
returnf'{self.name} is {self.age} years old'
def__repr__(self):
returnf'{self.name} is {self.age} years old'
def__len__(self):
return self.height
def__eq__(self, other):
return self.name == other.name and self.age == other.age
p1 = Person('John', 25, 56)
p2 = Person('John', 25, 61)
print(p1 == p2)

ה __eq__ השיטה משווה את שֵׁם ו גיל תכונות של השניים של אדם חפצים לקבוע שוויון.

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

על ידי יישום שיטות הקסם הללו, אתה יכול להגדיר התנהגות מותאמת אישית שתהיה עקבית עם המובנים של Python.

שיטות קסם מתקדמות

הנה כמה דוגמאות מתקדמות לשימוש בשיטות קסם להתאמה אישית של מחלקות.

לגרום לשיעורים להתנהג כמו מיכלים

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

classPerson:
def__init__(self):
 self.data = []
def__len__(self):
return len(self.data)
def__getitem__(self, index):
return self.data[index]
def__setitem__(self, index, value):
 self.data[index] = value
def__delitem__(self, index):
del self.data[index]
p1 = Person()
p1.data = [10, 2, 7]
print(len(p1)) # 3
p1[0] = 5
print(p1[0]) # 5

כעת אובייקט אדם יכול להתנהג כמו מיכל:

התאמה אישית של גישה לתכונה

משתמש ב __getattr__ שיטת קסם אתה יכול להתאים אישית את הדרך תכונות של אדם הגישה לכיתה מבוססת על תנאים מסוימים.

classPerson:
def__getattr__(self, name):
if name == 'age':
return40
else:
raise AttributeError(f'No attribute {name}')
p1 = Person()
print(p1.age) # 40

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

עבור כל שם תכונה אחר, הוא מעלה an AttributeError עם הודעה מתאימה.

לגרום לשיעורים להתנהג כמו ניתנים להתקשרות

ה __שִׂיחָה__ השיטה מאפשרת לך להתייחס למופע של המחלקה כאובייקט שניתן להתקשר (כלומר, פונקציה).

classAdder:
def__call__(self, x, y):
return x + y
adder = Adder()
print(adder(2, 3)) # 5

כאשר אתה יוצר מופע של פֶּתֶן ואז לקרוא לזה בטיעונים, ה-__שִׂיחָה__ השיטה פועלת ומבצעת את ההוספה לפני החזרת התוצאה.

עומס יתר על המפעיל

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

classVector:
def__init__(self, x, y):
 self.x = x
 self.y = y
def__add__(self, other):
if isinstance(other, Vector):
 new_x = self.x + other.x
 new_y = self.y + other.y
return Vector(new_x, new_y)
else:
raise TypeError("Unsupported operand type for +")
def__str__(self):
returnf"({self.x}, {self.y})"
# Creating two Vector instances
v1 = Vector(2, 3)
v2 = Vector(1, 4)
# Adding two Vector instances using the + operator
v3 = v1 + v2
# Printing the result
print(v3) # Output: (3, 7)

התוצאה היא וקטור חדש:

ה וֶקטוֹר הכיתה מגדירה את __לְהוֹסִיף__ שיטה, הפועלת כאשר אתה משתמש ב- + אופרטור בין שני מופעים של המחלקה. השיטה מוסיפה את הרכיבים המתאימים של שני הוקטורים ומחזירה חדש וֶקטוֹר דוגמה עם התוצאה.

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

תכנות מונחה עצמים בפייתון

שיטות קסם ב-Python מספקות דרכים רבות עוצמה להתאמה אישית ולשיפור ההתנהגות של מחלקות. שיטות קסם משתלבות עם הרעיון של תכנות מונחה עצמים (OOP) ב-Python. לכן חשוב להבין את המושג OOP כאשר מנסים להשתמש בשיטות קסם.