מה זה פולימורפיזם (Polymorphism)?

ב-Python, len("hello") מחזירה 5, len([4, 8, 15]) מחזירה 3, ו-len({"a": 1}) מחזירה 1. זה שם פונקציה אחד שמשמש לשלושה טיפוסים, וכל טיפוס סופר בדרך שלו: מחרוזת סופרת תווים, רשימה סופרת פריטים, מילון סופר מפתחות. המילה מגיעה מיוונית: poly, הרבה, ו-morph, צורה. קריאה אחת, צורות רבות של התנהגות.

איך פולימורפיזם עובד

קוד קורא למתודה לפי שם, כמו shape.area(). כשהשורה הזו רצה, השפה מסתכלת על האובייקט בפועל ומוצאת את area במחלקה של האובייקט עצמו. החיפוש הזה נקרא dynamic dispatch, והוא מה שמאפשר לשורה אחת לעשות עבודה שונה לאובייקטים שונים:

import math

class Shape:
    def area(self):
        raise NotImplementedError

class Circle(Shape):
    def __init__(self, r):
        self.r = r
    def area(self):
        return math.pi * self.r ** 2

class Square(Shape):
    def __init__(self, side):
        self.side = side
    def area(self):
        return self.side ** 2

shapes = [Circle(1), Square(3), Circle(2)]
for shape in shapes:
    # One line of code, a different area() for each type
    print(type(shape).__name__, round(shape.area(), 2))

Circle 3.14
Square 9
Circle 12.57

Python מוצאת את המתודה כשהיא מחפשת קודם במחלקה של האובייקט, ואז במחלקות האב שלה בסדר קבוע שנקרא method resolution order. אם ל-Square לא הייתה area() משלה, החיפוש היה מגיע ל-Shape.area() וזורק NotImplementedError, סימן לכך שכל תת מחלקה חייבת לספק אחת.

הלולאה אף פעם לא בודקת איזו צורה היא מחזיקה. כדי להוסיף משולש, כותבים מחלקת Triangle עם area() משלה, והלולאה עובדת בלי שינוי. בלי פולימורפיזם, הלולאה הייתה צריכה ענף if isinstance(...) לכל צורה, ולערוך אותו בכל פעם שמופיעה צורה חדשה.

סוגי פולימורפיזם

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

ב-Python יש את שלושתם, כל אחד בדרכו. דריסה עובדת כמו בדוגמת הצורות. אופרטורים כמו + הם פולימורפיזם אד הוק. פונקציות כמו max() ו-sorted() הן פרמטריות ברוחן: הן מקבלות רשימה של מספרים, מחרוזות או תאריכים, כל עוד אפשר להשוות בין הפריטים, ורמזי טיפוס כמו list[int] או TypeVar יכולים לציין את זה במפורש.

פולימורפיזם בזמן קומפילציה מול בזמן ריצה ב-Java

ב-Java יש את שני הסוגים, ושאלות בראיונות עבודה שואלות לעתים קרובות על ההבדל:

class Animal { String sound() { return "..."; } }
class Dog extends Animal {
    @Override String sound() { return "Woof"; }
}

Animal pet = new Dog();
pet.sound();          // "Woof": chosen at run time from the object

int add(int a, int b)          { return a + b; }
double add(double a, double b) { return a + b; }
add(2, 3);            // int version, chosen by the compiler
add(2.5, 1.0);        // double version

המשתנה pet הוא מטיפוס Animal, ובכל זאת הגרסה של Dog רצה, כי הבחירה תלויה באובייקט ולא במשתנה. שתי מתודות ה-add הן העמסה: הקומפיילר בוחר אחת לפי טיפוסי הארגומנטים לפני שהתוכנית רצה. ממשקים נותנים את אותה התנהגות בזמן ריצה בלי לשתף קוד: כל מחלקה שמממשת Comparable אפשר למיין עם Collections.sort. C++ עובדת באותה דרך עם הבדל אחד: מתודה מקבלת dispatch בזמן ריצה רק אם הוכרזה כ-virtual. ראו פולימורפיזם ב-Java, העמסת מתודות ופונקציות וירטואליות ב-C++.

פולימורפיזם ב-Python: duck typing ואופרטורים

Python לא דורשת מחלקת אב משותפת. אם לאובייקט יש את המתודה שהקוד קורא לה, זה עובד: "אם זה הולך כמו ברווז ומגעגע כמו ברווז, זה ברווז". גם אופרטורים הם פולימורפיים. כתיבת a + b קוראת ל-a.__add__(b), כך שהמחלקות שלכם יכולות לתמוך ב-+, ב-len() וב-print():

class Vector:
    def __init__(self, x, y):
        self.x, self.y = x, y
    def __add__(self, other):          # called for v1 + v2
        return Vector(self.x + other.x, self.y + other.y)
    def __len__(self):                 # called for len(v)
        return 2
    def __repr__(self):                # called by print()
        return f"Vector({self.x}, {self.y})"

print(1 + 2, "ab" + "cd", [1] + [2])   # built-in types
print(Vector(1, 2) + Vector(10, 20))    # your own type
print(len("hello"), len([1, 2, 3]), len(Vector(0, 0)))

3 abcd [1, 2]
Vector(11, 22)
5 3 2

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

טעויות נפוצות

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

def greet(name):
    return "Hi " + name

def greet(first, last):          # replaces the first greet
    return "Hi " + first + " " + last

print(greet("Ana", "Silva"))
print(greet("Ana"))

Hi Ana Silva
Traceback (most recent call last):
  ...
TypeError: greet() missing 1 required positional argument: 'last'

השתמשו בארגומנט עם ערך ברירת מחדל במקום: def greet(first, last="").

לשכוח virtual ב-C++. בלעדיו, קריאה למתודה דרך מצביע למחלקת הבסיס מריצה את הגרסה של הבסיס, גם כשהאובייקט הוא תת מחלקה.

דריסות שמשנות את המשמעות. אם area() בתת מחלקה אחת מחזירה את ההיקף, כל קורא שסומך על area() נשבר. דריסה חייבת לקיים את ההבטחה שהאב נתן; הכלל הזה ידוע כעקרון ההחלפה של ליסקוב (Liskov substitution principle).

בדיקות טיפוס בכל מקום. שרשרת של ענפי if type(x) == ... היא בדרך כלל סימן שכל טיפוס צריך לשאת מתודה משלו.

לאן ממשיכים מכאן

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