Inheritance di Python: subclass, super(), override, dan MRO

Class yang dibangun di atas class lain

Inheritance (pewarisan) memungkinkan kamu mendefinisikan class baru sebagai perluasan dari class yang sudah ada. Class yang sudah ada adalah induk (disebut juga base class atau superclass), dan class baru adalah anak (subclass). Anak mendapat setiap method dan atribut class milik induk tanpa perlu mengulanginya, dan bisa menambahkan miliknya sendiri atau mengganti yang perilakunya harus berbeda.

Kamu menuliskan induknya di dalam tanda kurung setelah nama class:

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

Output:

Rex is an animal
Woof

Dog tidak punya __init__ maupun describe sendiri. Saat kamu memanggil Dog("Rex"), Python mencari __init__ di Dog, tidak menemukannya, lalu memakai milik Animal. Pencarian yang sama terjadi untuk rex.describe(). Untuk rex.speak(), Python menemukan speak di Dog lebih dulu dan berhenti di situ.

Urutan pencarian itulah seluruh mekanismenya: Python mencari di class milik objek itu sendiri, lalu di induknya, lalu di induk dari induknya, dan memakai kecocokan pertama. Kalau kamu baru mengenal class, halaman class membahas __init__, self, dan method lebih dulu.

Override method

Method di class anak yang namanya sama dengan method di induk akan menggantikannya untuk instance dari anak itu. Ini disebut override. Setiap subclass bisa menjawab pemanggilan yang sama dengan caranya sendiri:

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())

Output:

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

summary hanya didefinisikan sekali, di Shape, tapi ia memanggil self.area(). Karena self adalah objek yang sebenarnya, sebuah Rectangle menjalankan Rectangle.area, dan sebuah Square menemukan area di induknya, Rectangle. Kode milik induk memanggil method milik anak tanpa tahu bahwa anak itu ada. Inilah yang membuat inheritance berguna untuk berbagi alur kerja yang sama sambil membiarkan setiap subclass mengisi detailnya.

Memanggil induk dengan super()

Saat anak mendefinisikan __init__ sendiri, __init__ milik induk tidak lagi berjalan dengan sendirinya. Kalau anak tetap butuh persiapan dari induk, panggil dengan 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)

Output:

Ada 1050.0

super() mengembalikan objek yang mencari method mulai dari induk class saat ini. Jadi super().__init__(owner, balance) menjalankan Account.__init__ pada objek yang sama, dan setelahnya self.owner serta self.balance sudah ada.

Kalau baris itu tidak ditulis, objeknya hanya terbangun setengah:

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)

Output:

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

Kamu juga bisa menulis Account.__init__(self, owner), dan kode lama sering melakukannya. super() lebih disarankan karena tidak mengulang nama induk dan bekerja sama dengan benar dalam multiple inheritance, yang dibahas di bawah.

Memperluas method, bukan menggantinya

super() bisa dipakai di method apa pun, bukan hanya __init__. Memanggil versi milik induk di dalam override memungkinkan kamu menambahkan perilaku di sekitarnya alih-alih menulis ulang:

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")

Output:

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

Setiap level menambahkan satu bagian dan menyerahkan sisanya ke atas. Kalau format milik induk berubah nanti, kedua anaknya ikut mendapat perubahan itu.

isinstance dan issubclass

Instance dari sebuah subclass juga merupakan instance dari setiap class di atasnya. isinstance(obj, cls) mengecek hubungan itu, dan issubclass(child, parent) mengeceknya di antara dua class:

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

Utamakan isinstance daripada membandingkan type(obj) secara langsung. Pengecekan seperti type(obj) is Animal menolak setiap subclass, sehingga langsung rusak begitu seseorang menambahkan Dog.

Setiap class yang kamu tulis mewarisi object, bahkan saat kamu tidak menuliskannya. class Animal: sama dengan class Animal(object):. Dari situlah method default seperti __str__, __repr__, dan __eq__ berasal, dan itulah kenapa override __str__ mengubah apa yang ditampilkan 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))

Output:

(2, 3)
True

Mewajibkan subclass mengimplementasikan sebuah method

Kadang induk tidak boleh dipakai secara langsung, hanya sebagai template. Modul abc menandai class seperti itu sebagai abstract. Setiap method yang diberi decorator @abstractmethod harus di-override sebelum class itu bisa dibuat instance-nya:

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)

Tiga baris pertama output-nya adalah hasil ekspor:

exporting 2 rows
1,2
3,4

Baris terakhir adalah TypeError yang menyebut Exporter dan method export yang hilang (kalimat persisnya berbeda antar versi Python). Kesalahannya muncul saat objek dibuat, bukan nanti saat export akhirnya dipanggil.

Multiple inheritance dan MRO

Sebuah class bisa menyebutkan lebih dari satu induk. Class itu lalu mewarisi semuanya:

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__])

Output:

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

Kedua induk mendefinisikan move, dan Duck mendapat milik Swimmer. Python memutuskannya dengan method resolution order (MRO): satu daftar class, disimpan di Duck.__mro__, yang ditelusuri setiap pencarian atribut dari depan ke belakang. Daftarnya dimulai dengan class itu sendiri, mempertahankan urutan induk seperti yang kamu tulis, menaruh setiap class sebelum induk-induknya sendiri, dan diakhiri dengan object. Tukar urutannya menjadi class Duck(Flyer, Swimmer), maka move mengembalikan "flies".

super() mengikuti daftar yang sama. Di dalam method milik Swimmer, super() berarti "class berikutnya setelah Swimmer di MRO dari class objek itu", yang untuk sebuah Duck adalah Flyer, bukan object. Begitulah class-class yang bekerja sama bisa masing-masing memanggil super() dan membuat setiap class di rantai itu berjalan tepat sekali, bahkan dalam bentuk berlian ketika dua induk punya kakek yang sama.

Dalam praktiknya, multiple inheritance kebanyakan dipakai untuk mixin: class kecil yang menambahkan satu kemampuan, misalnya JsonMixin yang menambahkan method to_json, digabung dengan satu induk utama. Hierarki yang dalam dengan beberapa induk penuh sulit diikuti dan jarang dibutuhkan.

Inheritance atau komposisi?

Inheritance memodelkan hubungan "adalah sebuah" (is a). Sebuah SavingsAccount adalah sebuah Account: kode apa pun yang bekerja dengan Account seharusnya bekerja dengannya tanpa perubahan. Kalau kalimat itu terdengar janggal, mungkin yang kamu inginkan adalah komposisi, yang memodelkan "punya sebuah" (has a): objek menyimpan objek lain sebagai atribut lalu memanggilnya.

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())

Output:

Roadster: 300 hp engine running

class Car(Engine) juga akan berjalan, tapi itu sama saja mengklaim bahwa mobil adalah sejenis mesin, memberi Car setiap method milik mesin, dan membuatnya mustahil menukar dengan mesin lain tanpa class yang berbeda. Dengan komposisi, bagian-bagiannya tetap terpisah, dan mengganti mesin cukup dengan memberikan objek lain.

Beberapa tanda bahwa inheritance adalah alat yang salah:

• Anak menimpa sebagian besar method milik induk, atau menonaktifkan beberapa di antaranya.
• Kamu mewarisi hanya untuk memakai ulang satu atau dua method bantu.
• Hierarkinya tumbuh lebih dari dua atau tiga level, dan kamu harus membaca beberapa file untuk melihat apa yang dilakukan sebuah method.

Kesalahan umum

• Lupa memanggil super().__init__(). __init__ milik anak menggantikan milik induk, jadi atribut induk tidak pernah diisi dan nanti kamu mendapat AttributeError.
• Mengirim self ke pemanggilan super(). Tulis super().__init__(name), bukan super().__init__(self, name). super() sudah mengikat method-nya ke objek saat ini.
• Signature yang tidak cocok saat override. Kalau speak(self) milik induk dipanggil oleh kode bersama, speak(self, volume) milik anak yang mewajibkan argumen tambahan akan merusak kode itu. Jaga override tetap kompatibel, atau beri parameter baru nilai default.
• Mengecek type(obj) == SomeClass. Cara ini mengabaikan subclass. Pakai isinstance.
• Memakai inheritance untuk berbagi kode antar class yang tidak berhubungan. Pindahkan kode bersama itu ke sebuah fungsi atau objek bantu.