היי, שאלה כללית:
נניח יש לי מחלקה A שיש לה מספר שדות (נניח a b c
מחלקה B ירשה את מחלקה A ורציתי להוסיף לה שדה נוסף (נניח שדה d)
איך כותבים את זה נכון בפייתון כך שלא אצטרך לשכפל קוד מצד אחד (שימוש בהורשה)
ומצד שני שלא אדרוס את מה שקיים??
בסופו של דבר אני רוצה שלמחלקה B יהיה את אותו אתחול כמו מחלקה A + שדה אחד נוסף…
אתה יורש ב B את A ובפונקציה init של B אתה עושה שימוש בסופר, ומתחת מוסיף את האטריביוט הנוסף.
אתה יכול לכתוב לי את זה בבבקשה?
כי זה ממש לא ברור לי… (אני יודע שהבעיה היא בי ולא בכם…)
class B(A):
def init():
super().init()
self.d = …
משהו כזה??
אתה רוצה פעולת אתחול נוספת או פעולה נוספת (פונקציה רגילה בשם d) או תכונה?
הכוונה; שדה (שלך) שווה לפעולה, פעולת אתחול או תכונה?
כן.
שים לב שלתוך init וסופר נכנסים פרמטרים במידה ובמקורי נכנסים גם. שוב יש דוגמאות טובות במחברת
למימושים של זה.
תכונה
תכונה
תכונה
תכ
class A:
def __init__(self, a, b, c):
self.a = a
self.b = b
self.c = c
class B(A):
def __init__(self, a, b, c, d):
super().__init__(a, b, c)
self.d = d
x = B(1, 2, 3, 4)
print(x.a, x.b, x.c, x.d)
מצויין
תודה רבה
זה מה שרציתי
ממשיך באותו נושא,
האם מישהו יודע (נושא של המחברת הבאה) איך להוסיף למחלקת הבת את פעולת האתחול לדוגמא של שתי מחלקות מהן היא יורשת, לדוגמא:
class A:
def __init__(IDoWhatIWannaDo, a):
IDoWhatIWannaDo.a = a
class B:
def __init__(IDoWhatIWannaDo, b):
IDoWhatIWannaDo.b = b
class C(A, B):אני רוצה שפעולת האתחול של C תקבל 3 ארגומנטים
הכוונה, להוסיף לה אחד בנוסף לשתי המחלקות מהן היא יורשת
ו A ו B הם שניהם נפרדות נכון הם לא יורשות אחת מהשניה … מבין אותך נכון ?
הן לא יורשות אחת מהשניה.
נראה לי שלמעשה אתה כבר יודע איך לעשות את זה - למיטב הבנתי אנחנו כבר יודעים לקרוא / לכתוב את מה שיבוא.
אני יכולה לדמיין איך הייתי עושה את זה (לא בטוחה מה לגמרי מה המקובלות, אבל אם לשפוט לפי מה שלמדנו על פונקציות וארגומנטים אפשר לכתוב את זה)
יש להניח שגם חיפוש זריז באינטרנט יעזור לוודא 
אתה צריך לקרוא על RMO - Method Resolution Order
כדי לעשות את זה עם super() צריך להתעסק עם שינוי הסדרים של המחלקות וכו … לא משהו שאני מבין בו.
אלטרנטיבה אחרת שאתה יכול לעשות הוא לקרוא לקונסטרקטור ישירות בתוך הפקונציה של המחלקה השלישית:
class A:
def __init__(self, a):
self.a = a
class B:
def __init__(self, b):
self.b = b
class C(A, B):
def __init__(self, a, b):
A.__init__(self, a)
B.__init__(self, b)
c = C("Hi", "Bye")
print(c.a)
print(c.b)
הפלט:
Hi
Bye
היה קשה, אבל איזה מזל שיש דודים
class A:
def __init__(self, a):
self.a = a
class B:
def __init__(self, b):
self.b = b
class C(A, B):
def __init__(self, a, b, c):
super().__init__(a)
super(A, self).__init__(b)
self.c = c
c = C(1, 2, 3)
print(c.a, c.b, c.c)
class A:
def __init__(self, a):
self.a = a
class B:
def __init__(self, b):
self.b = b
class C(A, B):
def __init__(self, a, b, c):
A.__init__(self, a)
B.__init__(self, b)
self.c = c
c = C("Hi", "Bye", "Dye")
print(c.a)
print(c.b)
print(c.c)
כל מחלקה והשדות שלה כך שגם אם השדה נקרא אותו דבר זה לא דורס אחד את השני…
מה קורה אם רוצים כמו פה ליצור מחלקה המורכבת מ 2 מחלקות אם כאשר השדות שלהן נקראות אותו דבר אבל מסמלות תכונות שונות??
איך פייתון יודע להמנע מהתנגשות?
תסביר, לא הבנתי מה הכוונה מחלקה המורכבת משתי מחלקות, יורשת משתיים?
עשיתי עד הסוף למה להשמיץ … 
הc זה תוספת … אם בא לך תוסיף … !