الوراثة في بايثون: الكلاسات الفرعية وsuper() وإعادة التعريف وMRO

كلاس مبني على كلاس آخر

تتيح لك الوراثة تعريف كلاس جديد على أنه امتداد لكلاس موجود. الكلاس الموجود هو الأب (ويُسمى أيضًا الكلاس الأساسي أو superclass)، والجديد هو الابن (الكلاس الفرعي أو subclass). يحصل الابن على كل توابع الأب وخصائص الكلاس فيه دون أن تكررها، ويمكنه أن يضيف توابعه الخاصة أو يستبدل تلك التي يجب أن تتصرف بشكل مختلف.

تكتب الكلاس الأب بين قوسين بعد اسم الكلاس:

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

    def describe(self):
        return f"{self.name} is an animal"

    def speak(self):
        return "..."

class Dog(Animal):
    def speak(self):
        return "Woof"

rex = Dog("Rex")
print(rex.describe())   # inherited from Animal
print(rex.speak())      # defined in Dog

المخرجات:

Rex is an animal
Woof

لا يملك Dog تابع __init__ ولا تابع describe خاصًا به. عندما تستدعي Dog("Rex")، تبحث بايثون عن __init__ في Dog، فلا تجده، فتستخدم التابع الموجود في Animal. ويحدث البحث نفسه مع rex.describe(). أما مع rex.speak() فتجد speak في Dog أولًا وتتوقف عنده.

ترتيب البحث هذا هو الآلية كلها: تبحث بايثون في كلاس الكائن نفسه، ثم في الأب، ثم في أب الأب، وتستخدم أول تطابق. إذا كانت الكلاسات جديدة عليك، فابدأ بـصفحة الكلاسات التي تشرح __init__ وself والتوابع.

إعادة تعريف تابع

التابع الموجود في الابن بالاسم نفسه الموجود في الأب يحل محله في نسخ الابن. يُسمى هذا إعادة التعريف (overriding). ويستطيع كل كلاس فرعي أن يجيب عن الاستدعاء نفسه بطريقته الخاصة:

class Shape:
    def area(self):
        return 0

    def summary(self):
        return f"{type(self).__name__} with area {self.area()}"

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def area(self):
        return self.width * self.height

class Square(Rectangle):
    def __init__(self, side):
        super().__init__(side, side)

shapes = [Rectangle(3, 4), Square(5), Shape()]
for shape in shapes:
    print(shape.summary())

المخرجات:

Rectangle with area 12
Square with area 25
Shape with area 0

يُعرَّف summary مرة واحدة في Shape، لكنه يستدعي self.area(). ولأن self هو الكائن الفعلي، فإن Rectangle ينفّذ Rectangle.area، ويجد Square التابع area في أبيه Rectangle. كود الأب يستدعي تابع الابن دون أن يعرف بوجود الابن. وهذا ما يجعل الوراثة مفيدة لمشاركة سير عمل مشترك مع ترك التفاصيل لكل كلاس فرعي.

استدعاء الأب باستخدام super()

عندما يعرّف الابن __init__ خاصًا به، لا يعود __init__ الخاص بالأب يُنفَّذ من تلقاء نفسه. فإذا كان الابن لا يزال يحتاج إلى تهيئة الأب، فاستدعها باستخدام super().__init__():

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

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

class SavingsAccount(Account):
    def __init__(self, owner, balance=0, rate=0.02):
        super().__init__(owner, balance)   # let Account set owner and balance
        self.rate = rate                   # then add what is new

    def add_interest(self):
        self.deposit(self.balance * self.rate)

acct = SavingsAccount("Ada", 1000, rate=0.05)
acct.add_interest()
print(acct.owner, acct.balance)

المخرجات:

Ada 1050.0

تُرجع super() كائنًا يبحث عن التوابع بدءًا من أب الكلاس الحالي. لذلك تنفّذ super().__init__(owner, balance) التابع Account.__init__ على الكائن نفسه، وتصبح self.owner وself.balance موجودتين بعد ذلك.

إذا حذفت ذلك السطر، يبقى الكائن مبنيًا نصف بناء:

class Account:
    def __init__(self, owner):
        self.owner = owner

class SavingsAccount(Account):
    def __init__(self, owner, rate):
        self.rate = rate   # forgot super().__init__(owner)

acct = SavingsAccount("Ada", 0.05)
print(acct.rate)

try:
    print(acct.owner)
except AttributeError as err:
    print("AttributeError:", err)

المخرجات:

0.05
AttributeError: 'SavingsAccount' object has no attribute 'owner'

يمكنك أن تكتب Account.__init__(self, owner) بدلًا من ذلك، والكود القديم يفعل هذا كثيرًا. لكن super() مفضّلة لأنها لا تكرر اسم الأب، وتتعاون بشكل صحيح مع الوراثة المتعددة التي نشرحها لاحقًا.

توسيع تابع بدلًا من استبداله

تعمل super() في أي تابع، وليس في __init__ وحده. استدعاء نسخة الأب داخل التابع المُعاد تعريفه يتيح لك إضافة سلوك حولها بدلًا من إعادة كتابتها:

class Logger:
    def format(self, message):
        return message

    def log(self, message):
        print(self.format(message))

class TimestampLogger(Logger):
    def format(self, message):
        base = super().format(message)
        return f"[12:00] {base}"

class LevelLogger(TimestampLogger):
    def format(self, message):
        return "INFO " + super().format(message)

Logger().log("started")
TimestampLogger().log("started")
LevelLogger().log("started")

المخرجات:

started
[12:00] started
INFO [12:00] started

كل مستوى يضيف قطعة واحدة ويفوّض الباقي إلى الأعلى. وإذا تغيّر format في الأب لاحقًا، يلتقط الابنان التغيير كلاهما.

isinstance وissubclass

نسخة الكلاس الفرعي هي أيضًا نسخة من كل كلاس فوقه. تفحص isinstance(obj, cls) هذه العلاقة، وتفحصها issubclass(child, parent) بين كلاسين:

class Animal:
    pass

class Dog(Animal):
    pass

class Cat(Animal):
    pass

rex = Dog()

print(isinstance(rex, Dog))       # True
print(isinstance(rex, Animal))    # True: a Dog is an Animal
print(isinstance(rex, Cat))       # False
print(isinstance(rex, (Cat, Dog)))  # True: matches any class in the tuple

print(issubclass(Dog, Animal))    # True
print(issubclass(Animal, Dog))    # False
print(issubclass(Dog, Dog))       # True: a class counts as its own subclass

print(type(rex) is Animal)        # False: type() ignores inheritance

فضّل isinstance على مقارنة type(obj) مباشرة. فحص مثل type(obj) is Animal يرفض كل كلاس فرعي، وينكسر بمجرد أن يضيف أحدهم Dog.

كل كلاس تكتبه يرث من object، حتى لو لم تذكر ذلك. class Animal: هي نفسها class Animal(object):. ومن هناك تأتي التوابع الافتراضية مثل __str__ و__repr__ و__eq__، ولهذا تغيّر إعادة تعريف __str__ ما تعرضه print():

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

    def __str__(self):
        return f"({self.x}, {self.y})"

print(Point(2, 3))
print(issubclass(Point, object))

المخرجات:

(2, 3)
True

إلزام الكلاسات الفرعية بتنفيذ تابع

أحيانًا لا ينبغي استخدام الأب مباشرة أبدًا، بل كقالب فقط. تُعلِّم الوحدة abc مثل هذا الكلاس على أنه مجرد (abstract). وأي تابع مزيّن بـ@abstractmethod يجب إعادة تعريفه قبل أن يمكن إنشاء نسخة من الكلاس:

from abc import ABC, abstractmethod

class Exporter(ABC):
    @abstractmethod
    def export(self, rows):
        ...

    def run(self, rows):
        print(f"exporting {len(rows)} rows")
        return self.export(rows)

class CsvExporter(Exporter):
    def export(self, rows):
        return "\n".join(",".join(map(str, row)) for row in rows)

print(CsvExporter().run([[1, 2], [3, 4]]))

try:
    Exporter()
except TypeError as err:
    print("TypeError:", err)

الأسطر الثلاثة الأولى من المخرجات هي نتيجة التصدير:

exporting 2 rows
1,2
3,4

السطر الأخير خطأ TypeError يذكر Exporter والتابع export الناقص فيه (تختلف الصياغة الدقيقة بين إصدارات بايثون). يظهر الخطأ عند إنشاء الكائن، وليس لاحقًا عندما يُستدعى export أخيرًا.

الوراثة المتعددة وMRO

يمكن للكلاس أن يذكر أكثر من أب واحد، فيرث منهم جميعًا:

class Swimmer:
    def move(self):
        return "swims"

    def swim(self):
        return "paddling"

class Flyer:
    def move(self):
        return "flies"

    def fly(self):
        return "flapping"

class Duck(Swimmer, Flyer):
    pass

d = Duck()
print(d.swim(), d.fly())
print(d.move())
print([cls.__name__ for cls in Duck.__mro__])

المخرجات:

paddling flapping
swims
['Duck', 'Swimmer', 'Flyer', 'object']

كلا الأبوين يعرّف move، ويحصل Duck على التابع الموجود في Swimmer. تحسم بايثون ذلك بترتيب تحليل التوابع (MRO): قائمة واحدة من الكلاسات مخزّنة في Duck.__mro__، يمر عليها كل بحث عن خاصية من أولها إلى آخرها. تبدأ القائمة بالكلاس نفسه، وتحافظ على الآباء بالترتيب الذي كتبتهم به، وتضع كل كلاس قبل آبائه، وتنتهي بـobject. بدّل الترتيب إلى class Duck(Flyer, Swimmer) فيُرجع move القيمة "flies".

وتتبع super() القائمة نفسها. داخل تابع في Swimmer، تعني super() "الكلاس التالي بعد Swimmer في MRO الخاص بكلاس الكائن"، وهو Flyer في حالة Duck، وليس object. وبهذا تستطيع الكلاسات المتعاونة أن تستدعي كل منها super() فيُنفَّذ كل كلاس في السلسلة مرة واحدة بالضبط، حتى في شكل الماسة (diamond) حيث يشترك أبوان في جد واحد.

عمليًا، تُستخدم الوراثة المتعددة غالبًا مع الـmixins: كلاسات صغيرة تضيف قدرة واحدة، مثل JsonMixin الذي يضيف تابع to_json، وتُدمج مع أب رئيسي واحد. أما التسلسلات الهرمية العميقة ذات الآباء الكاملين المتعددين فيصعب تتبعها ونادرًا ما تحتاجها.

الوراثة أم التركيب؟

تمثّل الوراثة علاقة "هو نوع من". SavingsAccount هو Account: أي كود يعمل مع Account يجب أن يعمل معه دون تغيير. وعندما تبدو هذه الجملة خاطئة، فأنت على الأرجح تحتاج إلى التركيب (composition)، الذي يمثّل علاقة "يملك": يحتفظ الكائن بكائن آخر كخاصية ويستدعيه.

class Engine:
    def __init__(self, horsepower):
        self.horsepower = horsepower

    def start(self):
        return f"{self.horsepower} hp engine running"

class Car:
    def __init__(self, model, engine):
        self.model = model
        self.engine = engine   # a Car has an Engine

    def start(self):
        return f"{self.model}: {self.engine.start()}"

car = Car("Roadster", Engine(300))
print(car.start())

المخرجات:

Roadster: 300 hp engine running

class Car(Engine) سيعمل أيضًا، لكنه سيدّعي أن السيارة نوع من المحركات، ويعطي Car كل توابع المحرك، ويجعل تركيب محرك مختلف مستحيلًا دون كلاس مختلف. أما مع التركيب فتبقى الأجزاء منفصلة، واستبدال المحرك مسألة تمرير كائن آخر.

بعض العلامات على أن الوراثة هي الأداة الخطأ:

• الابن يعيد تعريف معظم توابع الأب، أو يعطّل بعضها.
• ترث فقط لتعيد استخدام تابع مساعد أو اثنين.
• يتجاوز التسلسل الهرمي مستويين أو ثلاثة، وتضطر إلى قراءة عدة ملفات لتعرف ما يفعله تابع ما.

أخطاء شائعة

• نسيان super().__init__(). __init__ في الابن يحل محل __init__ في الأب، فلا تُضبط خصائص الأب أبدًا، وتحصل على AttributeError لاحقًا.
• تمرير self في استدعاءات super(). اكتب super().__init__(name)، وليس super().__init__(self, name). فـsuper() تربط التابع بالكائن الحالي مسبقًا.
• توقيعات غير متطابقة عند إعادة التعريف. إذا كان كود مشترك يستدعي speak(self) الموجود في الأب، فإن speak(self, volume) في الابن مع وسيط إضافي إلزامي يكسر ذلك الكود. اجعل إعادة التعريف متوافقة، أو أعطِ المعاملات الجديدة قيمًا افتراضية.
• فحص type(obj) == SomeClass. يتجاهل الكلاسات الفرعية. استخدم isinstance.
• استخدام الوراثة لمشاركة الكود بين كلاسات لا علاقة بينها. انقل الكود المشترك إلى دالة أو كائن مساعد بدلًا من ذلك.