מחלקות ב-Python: __init__, self, מתודות, ירושה ו-Dataclasses

מחלקה עוטפת נתונים ואת מה שעושים איתם

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

הנה המחלקה הפשוטה ביותר שאפשר:

class User:
    def __init__(self, name, email):
        self.name = name
        self.email = email

    def greet(self):
        print(f"Hi, I'm {self.name}. Reach me at {self.email}.")

user = User("Rosa", "rosa@example.com")
user.greet()

print(user.name)
print(user.email)

נפרק את זה:

• class User: פותחת הגדרת מחלקה. לפי המוסכמה, שמות מחלקות נכתבים ב-PascalCase.
• __init__ היא ה_מאתחל_ (initializer). היא רצה אוטומטית כשיוצרים מופע חדש, ומגדירה את התכונות שלו בעזרת self.whatever = ....
• greet היא מתודה. self הוא הדרך של מתודה להתייחס למופע שעליו היא נקראה.
• User("Rosa", "rosa@example.com") יוצרת מופע. Python קוראת ל-__init__ כש-self מוגדר כמופע החדש ושאר הארגומנטים מועברים הלאה.
• user.greet() קוראת למתודה. Python מעבירה את user בתור self אוטומטית.

self הוא פשוט הארגומנט הראשון

self הוא לא מילה שמורה. זה השם שנותנים לפרמטר הראשון של מתודות מופע: המופע שעליו המתודה רצה. אפשר לקרוא לו בכל שם; כולם משתמשים ב-self כי כך כולם עושים.

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

הוספת התנהגות

מתודות יכולות לקרוא מצב ולשנות אותו:

class BankAccount:
    def __init__(self, owner, opening_balance=0):
        self.owner = owner
        self.balance = opening_balance

    def deposit(self, amount):
        self.balance += amount

    def withdraw(self, amount):
        if amount > self.balance:
            raise ValueError("Insufficient funds")
        self.balance -= amount

    def __repr__(self):
        return f"BankAccount(owner={self.owner!r}, balance={self.balance})"

a = BankAccount("Rosa", 100)
a.deposit(50)
a.withdraw(30)
print(a)

__repr__ היא עוד מתודה מיוחדת: וו (hook) של "איך להציג את האובייקט הזה כשמדפיסים אותו?". הגדרה טובה שלה משתלמת מאוד בזמן דיבוג.

תכונות מחלקה מול תכונות מופע

תכונות שמוגדרות בגוף המחלקה (מחוץ ל-__init__) משותפות לכל המופעים. תכונות שמוצבות על self הן של כל מופע בנפרד:

class Dog:
    species = "Canis familiaris"   # תכונת מחלקה, משותפת

    def __init__(self, name):
        self.name = name           # תכונת מופע, לכל כלב בנפרד

a = Dog("Rex")
b = Dog("Luna")

print(a.species, a.name)
print(b.species, b.name)

Dog.species = "Canis lupus familiaris"  # משתנה עבור כל המופעים
print(a.species, b.species)

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

ירושה

מחלקה יכולה לרשת ממחלקה אחרת, לקבל את המתודות והתכונות שלה בחינם, ולהוסיף או לדרוס לפי הצורך:

class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        print(f"{self.name} makes a sound.")

class Dog(Animal):
    def speak(self):
        print(f"{self.name} barks.")

class Cat(Animal):
    def speak(self):
        print(f"{self.name} meows.")

rex = Dog("Rex")
luna = Cat("Luna")
rex.speak()
luna.speak()

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

class Animal:
    def __init__(self, name):
        self.name = name

class LabeledDog(Animal):
    def __init__(self, name, tag_number):
        super().__init__(name)
        self.tag_number = tag_number

d = LabeledDog("Rex", tag_number=42)
print(d.name, d.tag_number)

ירושה שימושית, אבל קל להגזים בה. מתכנתי Python חדשים פונים הרבה פעמים לירושה כשהרכבה (composition), כלומר החזקת אובייקט כתכונה, הייתה ברורה יותר. התחילו ממבנה מחלקות שטוח, והכניסו ירושה רק כשיש יחס "is-a" (הוא סוג של) אמיתי.

העמוד על ירושה ב-Python הולך רחוק יותר: הרחבת מתודה של האב עם super(), isinstance ו-issubclass, מחלקות בסיס מופשטות, ירושה מרובה וסדר רזולוציית המתודות.

Dataclasses: ברירת מחדל נוחה יותר לרשומות

כשרוצים בעיקר מחלקה שמחזיקה כמה תכונות, עם השוואה והצגה בסיסיות, @dataclass חוסך הרבה קוד תבניתי:

from dataclasses import dataclass

@dataclass
class Point:
    x: float
    y: float

p = Point(3.0, 4.0)
q = Point(3.0, 4.0)

print(p)
print(p == q)     # True: ה-dataclasses מטפלות בהשוואה אוטומטית
print(p.x, p.y)

השוו את זה לכתיבה ידנית של __init__, __repr__ ו-__eq__. Dataclasses הן הבחירה הראשונה הנכונה כשאחרת הייתם כותבים class Thing שאין בה כלום מלבד __init__ שמגדיר תכונות.

Properties: תכונות מחושבות

לפעמים רוצים "תכונה" שבעצם מחושבת. @property גורם לזה להיראות כמו גישה לתכונה:

class Circle:
    def __init__(self, radius):
        self.radius = radius

    @property
    def area(self):
        return 3.14159 * self.radius ** 2

c = Circle(5)
print(c.area)       # נקראת כמו תכונה, לא c.area()

השתמשו ב-properties במקומות שבהם הייתם כותבים obj.get_something(): החלפה ב-property גורמת ל-API להרגיש טבעי יותר. אל תשתמשו בהן כדי להסתיר פעולות יקרות; משתמשים מצפים שגישה לתכונה תהיה מהירה.

פרטי לפי מוסכמה

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

class Cache:
    def __init__(self):
        self._store = {}

    def put(self, key, value):
        self._store[key] = value

    def get(self, key, default=None):
        return self._store.get(key, default)

שמות עם שני קווים תחתונים (__name) מפעילים name mangling, שמוסיף את שם המחלקה לשם התכונה. זה כלי למניעת התנגשויות בירושה, לא אמצעי אבטחה.

מתי לא להשתמש במחלקה

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

דוגמה אחרונה

מאגר לוג קטן שמתנהג כמו קובץ:

from datetime import datetime

class Logger:
    def __init__(self, name):
        self.name = name
        self._entries = []

    def log(self, message):
        timestamp = datetime.now().strftime("%H:%M:%S")
        self._entries.append(f"[{timestamp}] {self.name}: {message}")

    def dump(self):
        return "\n".join(self._entries)

    def __len__(self):
        return len(self._entries)

logger = Logger("api")
logger.log("starting")
logger.log("ready")
logger.log("shutting down")

print(logger.dump())
print(len(logger))

שימו לב ל-__len__, עוד מתודת קסם. ההגדרה שלה גורמת ל-len(logger) לעבוד, כי len(x) הוא בעצם קריאה ל-x.__len__(). ל-Python יש עשרות ווים כאלה; תכירו אותם כשתצטרכו.